From de28eb32679def7de43e36e865f5ecc8198ed29f Mon Sep 17 00:00:00 2001 From: NathanBhanji Date: Tue, 10 Feb 2026 10:54:57 +0000 Subject: [PATCH] feat: sync with upstream aws-actions/aws-cloudformation-github-deploy v2.0.0 Major upgrade from v1 to v2: - Node 12 -> Node 20 runtime - AWS SDK v2 -> AWS SDK v3 (@aws-sdk/client-cloudformation) - TypeScript 3.9 -> 5.9, Jest 26 -> 30 - Added Zod input validation layer - Added 3-mode operation: create-and-execute, create-only, execute-only - Added changeset formatting for PR comments (changes-markdown output) - Added real-time event streaming during deployments - Added nested stacks changeset support - Added drift revert mode (deployment-mode: REVERT_DRIFT) - Added new outputs: change-set-id, has-changes, changes-count, changes-summary - Updated CI workflows to actions/checkout@v4, Node 20 Backward compatibility preserved for fork-specific features: - parameters-file: load params from {"Parameters":{"Key":"Value"}} JSON - changeset-postfix: deprecated alias, falls back when change-set-name not set - YAML parameter-overrides: Key: Value format still supported - no-fail-on-empty-changeset: deprecated inverted alias for fail-on-empty-changeset Consumers can pin to @v1 for the old version, @v2 for this version. Co-Authored-By: Claude Opus 4.6 --- .eslintrc.js | 25 - .github/workflows/check.yml | 6 +- .github/workflows/package.yml | 6 +- .github/workflows/release.yml | 12 +- .husky/pre-commit | 1 + .husky/pre-push | 1 + .lintstagedrc.js | 19 +- .prettierignore | 5 + __tests__/changeset-formatter.test.ts | 759 + __tests__/deploy.test.ts | 567 + __tests__/event-streaming-coverage.test.ts | 1056 + .../event-streaming-property.test.ts.skip | 2414 + __tests__/event-streaming.test.ts | 772 + __tests__/main.test.ts | 2193 +- __tests__/params.test.json | 14 +- __tests__/utils.test.ts | 432 +- action.yml | 68 +- dist/136.index.js | 903 + dist/360.index.js | 93 + dist/443.index.js | 795 + dist/566.index.js | 387 + dist/579.index.js | 270 + dist/605.index.js | 234 + dist/869.index.js | 225 + dist/956.index.js | 1039 + dist/998.index.js | 1455 + dist/index.js | 108905 ++++++++++----- eslint.config.js | 26 + jest.config.js | 21 +- jest.setup.js | 9 + package-lock.json | 23985 +--- package.json | 64 +- prettier.config.js | 3 +- src/changeset-formatter.ts | 492 + src/deploy.ts | 507 +- src/event-streaming.ts | 1567 + src/main.ts | 434 +- src/utils.ts | 231 +- src/validation.ts | 127 + 39 files changed, 98304 insertions(+), 51818 deletions(-) delete mode 100644 .eslintrc.js create mode 100644 .husky/pre-commit create mode 100644 .husky/pre-push create mode 100644 .prettierignore create mode 100644 __tests__/changeset-formatter.test.ts create mode 100644 __tests__/deploy.test.ts create mode 100644 __tests__/event-streaming-coverage.test.ts create mode 100644 __tests__/event-streaming-property.test.ts.skip create mode 100644 __tests__/event-streaming.test.ts create mode 100644 dist/136.index.js create mode 100644 dist/360.index.js create mode 100644 dist/443.index.js create mode 100644 dist/566.index.js create mode 100644 dist/579.index.js create mode 100644 dist/605.index.js create mode 100644 dist/869.index.js create mode 100644 dist/956.index.js create mode 100644 dist/998.index.js create mode 100644 eslint.config.js create mode 100644 jest.setup.js create mode 100644 src/changeset-formatter.ts create mode 100644 src/event-streaming.ts create mode 100644 src/validation.ts diff --git a/.eslintrc.js b/.eslintrc.js deleted file mode 100644 index 289ad74..0000000 --- a/.eslintrc.js +++ /dev/null @@ -1,25 +0,0 @@ -module.exports = { - parser: "@typescript-eslint/parser", - extends: [ - "plugin:@typescript-eslint/recommended", - "prettier/@typescript-eslint", - "plugin:prettier/recommended", - ], - settings: { - react: { - version: "detect", // Tells eslint-plugin-react to automatically detect the version of React to use - }, - }, - globals: { - Atomics: "readonly", - SharedArrayBuffer: "readonly", - }, - parserOptions: { - ecmaVersion: 2020, // Allows for the parsing of modern ECMAScript features - sourceType: "module", // Allows for the use of imports - ecmaFeatures: { - jsx: true, // Allows for the parsing of JSX - }, - }, - rules: {}, -}; diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml index f0f5970..3d093e3 100644 --- a/.github/workflows/check.yml +++ b/.github/workflows/check.yml @@ -8,7 +8,11 @@ jobs: runs-on: ubuntu-latest steps: - name: Checkout - uses: actions/checkout@v2 + uses: actions/checkout@v4 + - name: Setup Node + uses: actions/setup-node@v4 + with: + node-version: 20 - name: Run tests run: | npm ci diff --git a/.github/workflows/package.yml b/.github/workflows/package.yml index 7742590..535349a 100644 --- a/.github/workflows/package.yml +++ b/.github/workflows/package.yml @@ -11,9 +11,13 @@ jobs: runs-on: ubuntu-latest steps: - name: Checkout - uses: actions/checkout@v2 + uses: actions/checkout@v4 with: ref: master + - name: Setup Node + uses: actions/setup-node@v4 + with: + node-version: 20 - name: Package run: | npm ci diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 6836121..7bbc1f6 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -11,16 +11,12 @@ jobs: runs-on: ubuntu-latest steps: - name: Checkout code - uses: actions/checkout@master + uses: actions/checkout@v4 - name: Create Release - id: create_release - uses: actions/create-release@latest - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # This token is provided by Actions, you do not need to create your own token + uses: softprops/action-gh-release@v2 with: - tag_name: ${{ github.ref }} - release_name: ${{ github.ref }} + name: ${{ github.ref_name }} body: | See the CHANGELOG for more details on the release. draft: false - prerelease: false \ No newline at end of file + prerelease: false diff --git a/.husky/pre-commit b/.husky/pre-commit new file mode 100644 index 0000000..f27575a --- /dev/null +++ b/.husky/pre-commit @@ -0,0 +1 @@ +npm run precommit diff --git a/.husky/pre-push b/.husky/pre-push new file mode 100644 index 0000000..e37998f --- /dev/null +++ b/.husky/pre-push @@ -0,0 +1 @@ +npm run test diff --git a/.lintstagedrc.js b/.lintstagedrc.js index 359f829..fba73f5 100644 --- a/.lintstagedrc.js +++ b/.lintstagedrc.js @@ -1,11 +1,10 @@ module.exports = { - // Prettier - '**/*.{md}': ['prettier --ignore-path .gitignore --write'], - - // Eslint - '**/*.{ts,tsx}': ['eslint --fix'], - - // Jest - '**/*.test.{ml,mli,mly,ts,js,json}': 'jest', - } - \ No newline at end of file + // Prettier + '**/*.md': ['prettier --ignore-path .gitignore --write'], + + // Eslint + '**/*.{ts,tsx}': ['eslint --fix'], + + // Jest + '**/*.test.{ml,mli,mly,ts,js,json}': 'jest' +} diff --git a/.prettierignore b/.prettierignore new file mode 100644 index 0000000..64520f9 --- /dev/null +++ b/.prettierignore @@ -0,0 +1,5 @@ +dist/ +node_modules/ +coverage/ +*.min.js +package-lock.json diff --git a/__tests__/changeset-formatter.test.ts b/__tests__/changeset-formatter.test.ts new file mode 100644 index 0000000..6cba7ea --- /dev/null +++ b/__tests__/changeset-formatter.test.ts @@ -0,0 +1,759 @@ +import { + displayChangeSet, + generateChangeSetMarkdown +} from '../src/changeset-formatter' + +// Mock @actions/core +jest.mock('@actions/core', () => ({ + info: jest.fn(), + startGroup: jest.fn(), + endGroup: jest.fn(), + warning: jest.fn() +})) + +import * as core from '@actions/core' + +describe('Change Set Formatter', () => { + beforeEach(() => { + jest.clearAllMocks() + }) + + test('displays simple add change', () => { + const changesSummary = JSON.stringify({ + changes: [ + { + type: 'Resource', + ResourceChange: { + Action: 'Add', + LogicalResourceId: 'MyBucket', + ResourceType: 'AWS::S3::Bucket', + Replacement: 'False', + Scope: ['Properties'] + } + } + ], + totalChanges: 1, + truncated: false + }) + + displayChangeSet(changesSummary, 1, false) + + expect(core.info).toHaveBeenCalledWith(expect.stringContaining('1 to add')) + expect(core.startGroup).toHaveBeenCalledWith(expect.stringContaining('[+]')) + expect(core.startGroup).toHaveBeenCalledWith( + expect.stringContaining('AWS::S3::Bucket') + ) + expect(core.startGroup).toHaveBeenCalledWith( + expect.stringContaining('MyBucket') + ) + }) + + test('displays modify change with replacement warning', () => { + const changesSummary = JSON.stringify({ + changes: [ + { + type: 'Resource', + ResourceChange: { + Action: 'Modify', + LogicalResourceId: 'MyFunction', + ResourceType: 'AWS::Lambda::Function', + Replacement: 'True', + Scope: ['Properties'] + } + } + ], + totalChanges: 1, + truncated: false + }) + + displayChangeSet(changesSummary, 1, false) + + expect(core.info).toHaveBeenCalledWith( + expect.stringContaining('1 to change') + ) + expect(core.info).toHaveBeenCalledWith( + expect.stringContaining('Resource will be replaced') + ) + }) + + test('displays remove change', () => { + const changesSummary = JSON.stringify({ + changes: [ + { + type: 'Resource', + ResourceChange: { + Action: 'Remove', + LogicalResourceId: 'OldTable', + ResourceType: 'AWS::DynamoDB::Table', + Scope: [] + } + } + ], + totalChanges: 1, + truncated: false + }) + + displayChangeSet(changesSummary, 1, false) + + expect(core.info).toHaveBeenCalledWith( + expect.stringContaining('1 to remove') + ) + expect(core.startGroup).toHaveBeenCalledWith(expect.stringContaining('[-]')) + }) + + test('displays property details with before/after values', () => { + const changesSummary = JSON.stringify({ + changes: [ + { + type: 'Resource', + ResourceChange: { + Action: 'Modify', + LogicalResourceId: 'MyFunction', + ResourceType: 'AWS::Lambda::Function', + Replacement: 'False', + Scope: ['Properties'], + Details: [ + { + Target: { + Attribute: 'Properties', + Name: 'Runtime', + RequiresRecreation: 'Never', + BeforeValue: 'nodejs18.x', + AfterValue: 'nodejs20.x' + }, + Evaluation: 'Static', + ChangeSource: 'DirectModification' + } + ] + } + } + ], + totalChanges: 1, + truncated: false + }) + + displayChangeSet(changesSummary, 1, false) + + expect(core.info).toHaveBeenCalledWith(expect.stringContaining('Runtime')) + expect(core.info).toHaveBeenCalledWith( + expect.stringContaining('nodejs18.x') + ) + expect(core.info).toHaveBeenCalledWith( + expect.stringContaining('nodejs20.x') + ) + }) + + test('displays multiline before/after values', () => { + const changesSummary = JSON.stringify({ + changes: [ + { + type: 'Resource', + ResourceChange: { + Action: 'Modify', + LogicalResourceId: 'MyFunction', + ResourceType: 'AWS::Lambda::Function', + Replacement: 'False', + Scope: ['Properties'], + Details: [ + { + Target: { + Attribute: 'Properties', + Name: 'Code.ZipFile', + RequiresRecreation: 'Never', + BeforeValue: + 'exports.handler = async function(event) {\n return { statusCode: 200 };\n};', + AfterValue: + 'exports.handler = async function(event) {\n return { statusCode: 201 };\n};' + }, + Evaluation: 'Static', + ChangeSource: 'DirectModification' + } + ] + } + } + ], + totalChanges: 1, + truncated: false + }) + + displayChangeSet(changesSummary, 1, false) + + expect(core.info).toHaveBeenCalledWith( + expect.stringContaining('Code.ZipFile') + ) + expect(core.info).toHaveBeenCalledWith( + expect.stringContaining('statusCode: 200') + ) + expect(core.info).toHaveBeenCalledWith( + expect.stringContaining('statusCode: 201') + ) + }) + + test('displays requires recreation warning', () => { + const changesSummary = JSON.stringify({ + changes: [ + { + type: 'Resource', + ResourceChange: { + Action: 'Modify', + LogicalResourceId: 'MyInstance', + ResourceType: 'AWS::EC2::Instance', + Replacement: 'True', + Scope: ['Properties'], + Details: [ + { + Target: { + Attribute: 'Properties', + Name: 'InstanceType', + RequiresRecreation: 'Always' + }, + Evaluation: 'Static', + ChangeSource: 'DirectModification' + } + ] + } + } + ], + totalChanges: 1, + truncated: false + }) + + displayChangeSet(changesSummary, 1, false) + + expect(core.info).toHaveBeenCalledWith( + expect.stringContaining('Requires replacement') + ) + }) + + test('displays change source information', () => { + const changesSummary = JSON.stringify({ + changes: [ + { + type: 'Resource', + ResourceChange: { + Action: 'Modify', + LogicalResourceId: 'MyFunction', + ResourceType: 'AWS::Lambda::Function', + Replacement: 'False', + Scope: ['Properties'], + Details: [ + { + Target: { + Attribute: 'Properties', + Name: 'Environment.Variables.TABLE_NAME' + }, + Evaluation: 'Dynamic', + ChangeSource: 'ResourceReference', + CausingEntity: 'MyTable' + } + ] + } + } + ], + totalChanges: 1, + truncated: false + }) + + displayChangeSet(changesSummary, 1, false) + + expect(core.info).toHaveBeenCalledWith( + expect.stringContaining('ResourceReference') + ) + expect(core.info).toHaveBeenCalledWith(expect.stringContaining('MyTable')) + }) + + test('displays truncation warning', () => { + const changesSummary = JSON.stringify({ + changes: [ + { + type: 'Resource', + ResourceChange: { + Action: 'Add', + LogicalResourceId: 'Resource1', + ResourceType: 'AWS::S3::Bucket' + } + } + ], + totalChanges: 100, + truncated: true + }) + + displayChangeSet(changesSummary, 100, false) + + expect(core.warning).toHaveBeenCalledWith( + expect.stringContaining('truncated') + ) + expect(core.warning).toHaveBeenCalledWith( + expect.stringContaining('1 of 100') + ) + }) + + test('displays multiple changes grouped by action', () => { + const changesSummary = JSON.stringify({ + changes: [ + { + type: 'Resource', + ResourceChange: { + Action: 'Add', + LogicalResourceId: 'NewBucket', + ResourceType: 'AWS::S3::Bucket' + } + }, + { + type: 'Resource', + ResourceChange: { + Action: 'Modify', + LogicalResourceId: 'ExistingFunction', + ResourceType: 'AWS::Lambda::Function' + } + }, + { + type: 'Resource', + ResourceChange: { + Action: 'Remove', + LogicalResourceId: 'OldTable', + ResourceType: 'AWS::DynamoDB::Table' + } + } + ], + totalChanges: 3, + truncated: false + }) + + displayChangeSet(changesSummary, 3, false) + + expect(core.info).toHaveBeenCalledWith(expect.stringContaining('1 to add')) + expect(core.info).toHaveBeenCalledWith( + expect.stringContaining('1 to change') + ) + expect(core.info).toHaveBeenCalledWith( + expect.stringContaining('1 to remove') + ) + }) + + test('handles invalid JSON gracefully', () => { + displayChangeSet('invalid json', 0, false) + + expect(core.warning).toHaveBeenCalledWith( + expect.stringContaining('Failed to format') + ) + expect(core.info).toHaveBeenCalledWith('invalid json') + }) + + test('displays raw JSON in separate group', () => { + const changesSummary = JSON.stringify({ + changes: [], + totalChanges: 0, + truncated: false + }) + + displayChangeSet(changesSummary, 0, false) + + expect(core.startGroup).toHaveBeenCalledWith( + expect.stringContaining('Raw Change Set JSON') + ) + }) + + test('handles conditional replacement', () => { + const changesSummary = JSON.stringify({ + changes: [ + { + type: 'Resource', + ResourceChange: { + Action: 'Modify', + LogicalResourceId: 'MyResource', + ResourceType: 'AWS::EC2::Instance', + Replacement: 'Conditional', + Scope: ['Properties'] + } + } + ], + totalChanges: 1, + truncated: false + }) + + displayChangeSet(changesSummary, 1, false) + + expect(core.info).toHaveBeenCalledWith( + expect.stringContaining('May require replacement') + ) + }) + + test('handles changes without details using scope fallback', () => { + const changesSummary = JSON.stringify({ + changes: [ + { + type: 'Resource', + ResourceChange: { + Action: 'Modify', + LogicalResourceId: 'MyResource', + ResourceType: 'AWS::S3::Bucket', + Replacement: 'False', + Scope: ['Tags', 'Properties'] + } + } + ], + totalChanges: 1, + truncated: false + }) + + displayChangeSet(changesSummary, 1, false) + + expect(core.info).toHaveBeenCalledWith( + expect.stringContaining('Modified: Tags, Properties') + ) + }) + + test('generates markdown for PR comments', () => { + const changesSummary = JSON.stringify({ + changes: [ + { + Type: 'Resource', + ResourceChange: { + Action: 'Add', + LogicalResourceId: 'MyBucket', + ResourceType: 'AWS::S3::Bucket', + Scope: [], + Details: [] + } + }, + { + Type: 'Resource', + ResourceChange: { + Action: 'Modify', + LogicalResourceId: 'MyTable', + PhysicalResourceId: 'my-table-123', + ResourceType: 'AWS::DynamoDB::Table', + Replacement: 'True', + Scope: ['Properties'], + BeforeContext: JSON.stringify({ + Properties: { + BillingMode: 'PROVISIONED' + } + }), + AfterContext: JSON.stringify({ + Properties: { + BillingMode: 'PAY_PER_REQUEST' + } + }), + Details: [ + { + Target: { + Attribute: 'Properties', + Name: 'BillingMode', + RequiresRecreation: 'Always', + BeforeValue: 'PROVISIONED', + AfterValue: 'PAY_PER_REQUEST' + } + } + ] + } + } + ], + totalChanges: 2, + truncated: false + }) + + const markdown = generateChangeSetMarkdown(changesSummary) + + expect(markdown).toContain('## 📋 CloudFormation Change Set') + expect(markdown).toContain('**Summary:** 1 to add, 1 to replace') + expect(markdown).toContain('
') + expect(markdown).toContain('
') + expect(markdown).toContain( + '🟢 MyBucket AWS::S3::Bucket' + ) + expect(markdown).toContain( + '🟡 MyTable AWS::DynamoDB::Table' + ) + expect(markdown).toContain('**Physical ID:** `my-table-123`') + expect(markdown).toContain('⚠️ **This resource will be replaced**') + expect(markdown).toContain('```diff') + expect(markdown).toContain('⚠️ Requires recreation: Always') + }) + + test('displays AfterContext for Add actions in console output', () => { + const changesSummary = JSON.stringify({ + changes: [ + { + Type: 'Resource', + ResourceChange: { + Action: 'Add', + LogicalResourceId: 'NewBucket', + ResourceType: 'AWS::S3::Bucket', + AfterContext: + '{"BucketName":"my-bucket","Versioning":{"Status":"Enabled"}}' + } + } + ], + totalChanges: 1, + truncated: false + }) + + displayChangeSet(changesSummary, 1, true) + + expect(core.info).toHaveBeenCalledWith( + expect.stringContaining('Properties:') + ) + expect(core.info).toHaveBeenCalledWith( + expect.stringContaining('BucketName') + ) + }) + + test('displays BeforeContext for Remove actions in console output', () => { + const changesSummary = JSON.stringify({ + changes: [ + { + Type: 'Resource', + ResourceChange: { + Action: 'Remove', + LogicalResourceId: 'OldBucket', + ResourceType: 'AWS::S3::Bucket', + BeforeContext: '{"BucketName":"old-bucket"}' + } + } + ], + totalChanges: 1, + truncated: false + }) + + displayChangeSet(changesSummary, 1, true) + + expect(core.info).toHaveBeenCalledWith( + expect.stringContaining('Properties:') + ) + expect(core.info).toHaveBeenCalledWith( + expect.stringContaining('BucketName') + ) + }) + + test('handles invalid JSON in AfterContext gracefully', () => { + const changesSummary = JSON.stringify({ + changes: [ + { + Type: 'Resource', + ResourceChange: { + Action: 'Add', + LogicalResourceId: 'NewResource', + ResourceType: 'AWS::Custom::Resource', + AfterContext: 'invalid-json{' + } + } + ], + totalChanges: 1, + truncated: false + }) + + displayChangeSet(changesSummary, 1, true) + + expect(core.info).toHaveBeenCalledWith( + expect.stringContaining('invalid-json{') + ) + }) + + test('handles invalid JSON in BeforeContext gracefully', () => { + const changesSummary = JSON.stringify({ + changes: [ + { + Type: 'Resource', + ResourceChange: { + Action: 'Remove', + LogicalResourceId: 'OldResource', + ResourceType: 'AWS::Custom::Resource', + BeforeContext: 'invalid-json{' + } + } + ], + totalChanges: 1, + truncated: false + }) + + displayChangeSet(changesSummary, 1, true) + + expect(core.info).toHaveBeenCalledWith( + expect.stringContaining('invalid-json{') + ) + }) + + test('generates diff view for resources with BeforeContext/AfterContext', () => { + const changesSummary = JSON.stringify({ + changes: [ + { + Type: 'Resource', + ResourceChange: { + Action: 'Modify', + LogicalResourceId: 'MyTopic', + ResourceType: 'AWS::SNS::Topic', + Replacement: 'False', + BeforeContext: JSON.stringify({ + Properties: { + DisplayName: 'old-name', + Tags: [{ Key: 'Env', Value: 'dev' }] + } + }), + AfterContext: JSON.stringify({ + Properties: { + DisplayName: 'new-name', + Tags: [{ Key: 'Env', Value: 'prod' }] + } + }) + } + } + ], + totalChanges: 1, + truncated: false + }) + + const markdown = generateChangeSetMarkdown(changesSummary) + + expect(markdown).toContain('```diff') + expect(markdown).toContain('-') + expect(markdown).toContain('+') + }) + + test('shows recreation warnings in diff view', () => { + const changesSummary = JSON.stringify({ + changes: [ + { + Type: 'Resource', + ResourceChange: { + Action: 'Modify', + LogicalResourceId: 'MyParam', + ResourceType: 'AWS::SSM::Parameter', + Replacement: 'True', + BeforeContext: JSON.stringify({ + Properties: { + Name: '/old/path', + Value: 'old' + } + }), + AfterContext: JSON.stringify({ + Properties: { + Name: '/new/path', + Value: 'new' + } + }), + Details: [ + { + Target: { + Name: 'Name', + RequiresRecreation: 'Always' + } + } + ] + } + } + ], + totalChanges: 1, + truncated: false + }) + + const markdown = generateChangeSetMarkdown(changesSummary) + + expect(markdown).toContain('```diff') + expect(markdown).toContain('⚠️ Requires recreation: Always') + }) + + test('displays AfterContext for Add actions in console output', () => { + const changesSummary = JSON.stringify({ + changes: [ + { + Type: 'Resource', + ResourceChange: { + Action: 'Add', + LogicalResourceId: 'NewBucket', + ResourceType: 'AWS::S3::Bucket', + AfterContext: + '{"BucketName":"my-bucket","Versioning":{"Status":"Enabled"}}' + } + } + ], + totalChanges: 1, + truncated: false + }) + + displayChangeSet(changesSummary, 1, true) + + expect(core.info).toHaveBeenCalledWith( + expect.stringContaining('Properties:') + ) + expect(core.info).toHaveBeenCalledWith( + expect.stringContaining('BucketName') + ) + }) + + test('displays BeforeContext for Remove actions in console output', () => { + const changesSummary = JSON.stringify({ + changes: [ + { + Type: 'Resource', + ResourceChange: { + Action: 'Remove', + LogicalResourceId: 'OldBucket', + ResourceType: 'AWS::S3::Bucket', + BeforeContext: '{"BucketName":"old-bucket"}' + } + } + ], + totalChanges: 1, + truncated: false + }) + + displayChangeSet(changesSummary, 1, true) + + expect(core.info).toHaveBeenCalledWith( + expect.stringContaining('Properties:') + ) + expect(core.info).toHaveBeenCalledWith( + expect.stringContaining('BucketName') + ) + }) + + test('handles invalid JSON in AfterContext gracefully', () => { + const changesSummary = JSON.stringify({ + changes: [ + { + Type: 'Resource', + ResourceChange: { + Action: 'Add', + LogicalResourceId: 'NewResource', + ResourceType: 'AWS::Custom::Resource', + AfterContext: 'invalid-json{' + } + } + ], + totalChanges: 1, + truncated: false + }) + + displayChangeSet(changesSummary, 1, true) + + expect(core.info).toHaveBeenCalledWith( + expect.stringContaining('invalid-json{') + ) + }) + + test('handles invalid JSON in BeforeContext gracefully', () => { + const changesSummary = JSON.stringify({ + changes: [ + { + Type: 'Resource', + ResourceChange: { + Action: 'Remove', + LogicalResourceId: 'OldResource', + ResourceType: 'AWS::Custom::Resource', + BeforeContext: 'invalid-json{' + } + } + ], + totalChanges: 1, + truncated: false + }) + + displayChangeSet(changesSummary, 1, true) + + expect(core.info).toHaveBeenCalledWith( + expect.stringContaining('invalid-json{') + ) + }) +}) diff --git a/__tests__/deploy.test.ts b/__tests__/deploy.test.ts new file mode 100644 index 0000000..4088be8 --- /dev/null +++ b/__tests__/deploy.test.ts @@ -0,0 +1,567 @@ +import { + CloudFormationClient, + DescribeStacksCommand, + DescribeChangeSetCommand, + DescribeEventsCommand, + CreateChangeSetCommand, + ExecuteChangeSetCommand, + StackStatus, + ChangeSetStatus, + Stack +} from '@aws-sdk/client-cloudformation' +import { mockClient } from 'aws-sdk-client-mock' +import { + waitUntilStackOperationComplete, + updateStack, + executeExistingChangeSet +} from '../src/deploy' +import * as core from '@actions/core' + +jest.mock('@actions/core', () => ({ + ...jest.requireActual('@actions/core'), + info: jest.fn(), + warning: jest.fn(), + setOutput: jest.fn(), + setFailed: jest.fn(), + debug: jest.fn() +})) + +const mockCfnClient = mockClient(CloudFormationClient) +const cfn = new CloudFormationClient({ region: 'us-east-1' }) + +describe('Deploy error scenarios', () => { + beforeEach(() => { + jest.clearAllMocks() + mockCfnClient.reset() + jest.useFakeTimers() + }) + + afterEach(() => { + jest.useRealTimers() + jest.restoreAllMocks() + }) + + describe('waitUntilStackOperationComplete', () => { + it('throws error on CREATE_FAILED status', async () => { + mockCfnClient.on(DescribeStacksCommand).resolves({ + Stacks: [ + { + StackName: 'TestStack', + StackStatus: StackStatus.CREATE_FAILED, + CreationTime: new Date() + } + ] + }) + + await expect( + waitUntilStackOperationComplete( + { client: cfn, maxWaitTime: 60, minDelay: 1 }, + { StackName: 'TestStack' } + ) + ).rejects.toThrow('Stack operation failed with status: CREATE_FAILED') + }) + + it('throws error on UPDATE_ROLLBACK_COMPLETE status', async () => { + mockCfnClient.on(DescribeStacksCommand).resolves({ + Stacks: [ + { + StackName: 'TestStack', + StackStatus: StackStatus.UPDATE_ROLLBACK_COMPLETE, + CreationTime: new Date() + } + ] + }) + + await expect( + waitUntilStackOperationComplete( + { client: cfn, maxWaitTime: 60, minDelay: 1 }, + { StackName: 'TestStack' } + ) + ).rejects.toThrow( + 'Stack operation failed with status: UPDATE_ROLLBACK_COMPLETE' + ) + }) + + it('throws error on ROLLBACK_FAILED status', async () => { + mockCfnClient.on(DescribeStacksCommand).resolves({ + Stacks: [ + { + StackName: 'TestStack', + StackStatus: StackStatus.ROLLBACK_FAILED, + CreationTime: new Date() + } + ] + }) + + await expect( + waitUntilStackOperationComplete( + { client: cfn, maxWaitTime: 60, minDelay: 1 }, + { StackName: 'TestStack' } + ) + ).rejects.toThrow('Stack operation failed with status: ROLLBACK_FAILED') + }) + + it('throws error on UPDATE_FAILED status', async () => { + mockCfnClient.on(DescribeStacksCommand).resolves({ + Stacks: [ + { + StackName: 'TestStack', + StackStatus: StackStatus.UPDATE_FAILED, + CreationTime: new Date() + } + ] + }) + + await expect( + waitUntilStackOperationComplete( + { client: cfn, maxWaitTime: 60, minDelay: 1 }, + { StackName: 'TestStack' } + ) + ).rejects.toThrow('Stack operation failed with status: UPDATE_FAILED') + }) + + it('throws error on DELETE_FAILED status', async () => { + mockCfnClient.on(DescribeStacksCommand).resolves({ + Stacks: [ + { + StackName: 'TestStack', + StackStatus: StackStatus.DELETE_FAILED, + CreationTime: new Date() + } + ] + }) + + await expect( + waitUntilStackOperationComplete( + { client: cfn, maxWaitTime: 60, minDelay: 1 }, + { StackName: 'TestStack' } + ) + ).rejects.toThrow('Stack operation failed with status: DELETE_FAILED') + }) + + it('throws error on ROLLBACK_COMPLETE status', async () => { + mockCfnClient.on(DescribeStacksCommand).resolves({ + Stacks: [ + { + StackName: 'TestStack', + StackStatus: StackStatus.ROLLBACK_COMPLETE, + CreationTime: new Date() + } + ] + }) + + await expect( + waitUntilStackOperationComplete( + { client: cfn, maxWaitTime: 60, minDelay: 1 }, + { StackName: 'TestStack' } + ) + ).rejects.toThrow('Stack operation failed with status: ROLLBACK_COMPLETE') + }) + + it('throws error on UPDATE_ROLLBACK_FAILED status', async () => { + mockCfnClient.on(DescribeStacksCommand).resolves({ + Stacks: [ + { + StackName: 'TestStack', + StackStatus: StackStatus.UPDATE_ROLLBACK_FAILED, + CreationTime: new Date() + } + ] + }) + + await expect( + waitUntilStackOperationComplete( + { client: cfn, maxWaitTime: 60, minDelay: 1 }, + { StackName: 'TestStack' } + ) + ).rejects.toThrow( + 'Stack operation failed with status: UPDATE_ROLLBACK_FAILED' + ) + }) + + it('throws error on IMPORT_ROLLBACK_COMPLETE status', async () => { + mockCfnClient.on(DescribeStacksCommand).resolves({ + Stacks: [ + { + StackName: 'TestStack', + StackStatus: StackStatus.IMPORT_ROLLBACK_COMPLETE, + CreationTime: new Date() + } + ] + }) + + await expect( + waitUntilStackOperationComplete( + { client: cfn, maxWaitTime: 60, minDelay: 1 }, + { StackName: 'TestStack' } + ) + ).rejects.toThrow( + 'Stack operation failed with status: IMPORT_ROLLBACK_COMPLETE' + ) + }) + + it('throws error on IMPORT_ROLLBACK_FAILED status', async () => { + mockCfnClient.on(DescribeStacksCommand).resolves({ + Stacks: [ + { + StackName: 'TestStack', + StackStatus: StackStatus.IMPORT_ROLLBACK_FAILED, + CreationTime: new Date() + } + ] + }) + + await expect( + waitUntilStackOperationComplete( + { client: cfn, maxWaitTime: 60, minDelay: 1 }, + { StackName: 'TestStack' } + ) + ).rejects.toThrow( + 'Stack operation failed with status: IMPORT_ROLLBACK_FAILED' + ) + }) + + it('throws stack does not exist error', async () => { + mockCfnClient + .on(DescribeStacksCommand) + .rejects(new Error('Stack with id TestStack does not exist')) + + await expect( + waitUntilStackOperationComplete( + { client: cfn, maxWaitTime: 60, minDelay: 1 }, + { StackName: 'TestStack' } + ) + ).rejects.toThrow('Stack TestStack does not exist') + }) + + it('waits for in-progress stack and succeeds', async () => { + let callCount = 0 + mockCfnClient.on(DescribeStacksCommand).callsFake(() => { + callCount++ + if (callCount === 1) { + return { + Stacks: [ + { + StackName: 'TestStack', + StackStatus: StackStatus.CREATE_IN_PROGRESS, + CreationTime: new Date() + } + ] + } + } + return { + Stacks: [ + { + StackName: 'TestStack', + StackStatus: StackStatus.CREATE_COMPLETE, + CreationTime: new Date() + } + ] + } + }) + + const promise = waitUntilStackOperationComplete( + { client: cfn, maxWaitTime: 60, minDelay: 1 }, + { StackName: 'TestStack' } + ) + + // Advance timers to trigger the wait + await jest.advanceTimersByTimeAsync(1500) + + await expect(promise).resolves.toBeUndefined() + expect(callCount).toBe(2) + }) + + it('throws error when stack not found in response', async () => { + mockCfnClient.on(DescribeStacksCommand).resolves({ + Stacks: [] + }) + + await expect( + waitUntilStackOperationComplete( + { client: cfn, maxWaitTime: 60, minDelay: 1 }, + { StackName: 'TestStack' } + ) + ).rejects.toThrow('Stack TestStack not found') + }) + }) + + describe('updateStack with validation errors', () => { + it('includes validation error details when change set fails', async () => { + const mockStack = { + StackId: 'test-stack-id', + StackName: 'TestStack', + StackStatus: StackStatus.CREATE_COMPLETE, + CreationTime: new Date() + } + + mockCfnClient + .on(CreateChangeSetCommand) + .resolves({ Id: 'test-cs-id' }) + .on(DescribeStacksCommand) + .resolves({ Stacks: [mockStack] }) + .on(DescribeChangeSetCommand) + .resolves({ + ChangeSetId: 'test-cs-id', + Status: ChangeSetStatus.FAILED, + ExecutionStatus: 'UNAVAILABLE', + StatusReason: 'Validation failed' + }) + .on(DescribeEventsCommand) + .resolves({ + OperationEvents: [ + { + EventType: 'VALIDATION_ERROR', + ValidationPath: '/Resources/MyResource', + ValidationStatusReason: 'Invalid property value' + } + ] + }) + + await expect( + updateStack( + cfn, + mockStack, + { + StackName: 'TestStack', + ChangeSetName: 'test-cs', + ChangeSetType: 'UPDATE' + }, + true, + false, + false + ) + ).rejects.toThrow('Validation errors') + }) + + it('handles error when fetching validation events fails', async () => { + const mockStack = { + StackId: 'test-stack-id', + StackName: 'TestStack', + StackStatus: StackStatus.CREATE_COMPLETE, + CreationTime: new Date() + } + + mockCfnClient + .on(CreateChangeSetCommand) + .resolves({ Id: 'test-cs-id' }) + .on(DescribeStacksCommand) + .resolves({ Stacks: [mockStack] }) + .on(DescribeChangeSetCommand) + .resolves({ + ChangeSetId: 'test-cs-id', + Status: ChangeSetStatus.FAILED, + ExecutionStatus: 'UNAVAILABLE', + StatusReason: 'Validation failed' + }) + .on(DescribeEventsCommand) + .rejects(new Error('Access denied')) + + await expect( + updateStack( + cfn, + mockStack, + { + StackName: 'TestStack', + ChangeSetName: 'test-cs', + ChangeSetType: 'UPDATE' + }, + true, + false, + false + ) + ).rejects.toThrow('Failed to create Change Set') + + expect(core.info).toHaveBeenCalledWith( + expect.stringContaining('Failed to get validation event details') + ) + }) + }) + + describe('Timeout handling', () => { + it('should timeout after maxWaitTime', async () => { + const realDateNow = Date.now + const realSetTimeout = global.setTimeout + let mockTime = 1000000 + Date.now = jest.fn(() => mockTime) + // Mock setTimeout to resolve immediately + // eslint-disable-next-line @typescript-eslint/no-explicit-any + ;(global.setTimeout as any) = jest.fn((cb: () => void) => { + cb() + return 0 as unknown as NodeJS.Timeout + }) + + mockCfnClient.on(DescribeStacksCommand).callsFake(() => { + // Advance mock time by 2 seconds each call + mockTime += 2000 + return { + Stacks: [ + { + StackName: 'TestStack', + StackStatus: StackStatus.CREATE_IN_PROGRESS, + CreationTime: new Date() + } + ] + } + }) + + await expect( + waitUntilStackOperationComplete( + { client: cfn, maxWaitTime: 1, minDelay: 0 }, + { StackName: 'TestStack' } + ) + ).rejects.toThrow('Timeout after 1 seconds') + + Date.now = realDateNow + global.setTimeout = realSetTimeout + }) + + it('should handle timeout gracefully in executeExistingChangeSet', async () => { + const realDateNow = Date.now + const realSetTimeout = global.setTimeout + let mockTime = 1000000 + Date.now = jest.fn(() => mockTime) + // eslint-disable-next-line @typescript-eslint/no-explicit-any + ;(global.setTimeout as any) = jest.fn((cb: () => void) => { + cb() + return 0 as unknown as NodeJS.Timeout + }) + + mockCfnClient + .on(ExecuteChangeSetCommand) + .resolves({}) + .on(DescribeStacksCommand) + .callsFake(() => { + mockTime += 2000 + return { + Stacks: [ + { + StackName: 'TestStack', + StackId: 'test-stack-id', + StackStatus: StackStatus.UPDATE_IN_PROGRESS, + CreationTime: new Date() + } + ] + } + }) + + const result = await executeExistingChangeSet( + cfn, + 'TestStack', + 'test-cs-id', + 1 // 1 second timeout + ) + + expect(core.warning).toHaveBeenCalledWith( + expect.stringContaining('Stack operation exceeded') + ) + expect(core.warning).toHaveBeenCalledWith( + expect.stringContaining('TestStack') + ) + expect(result).toBe('test-stack-id') + + Date.now = realDateNow + global.setTimeout = realSetTimeout + }) + + it('should handle timeout gracefully in updateStack', async () => { + const realDateNow = Date.now + const realSetTimeout = global.setTimeout + let mockTime = 1000000 + Date.now = jest.fn(() => mockTime) + // eslint-disable-next-line @typescript-eslint/no-explicit-any + ;(global.setTimeout as any) = jest.fn((cb: () => void) => { + cb() + return 0 as unknown as NodeJS.Timeout + }) + + mockCfnClient + .on(CreateChangeSetCommand) + .resolves({ Id: 'test-cs-id' }) + .on(DescribeChangeSetCommand) + .resolves({ + Status: ChangeSetStatus.CREATE_COMPLETE, + Changes: [] + }) + .on(ExecuteChangeSetCommand) + .resolves({}) + .on(DescribeStacksCommand) + .callsFake(() => { + mockTime += 2000 + return { + Stacks: [ + { + StackName: 'TestStack', + StackId: 'test-stack-id', + StackStatus: StackStatus.UPDATE_IN_PROGRESS, + CreationTime: new Date() + } + ] + } + }) + + const result = await updateStack( + cfn, + { StackId: 'test-stack-id', StackName: 'TestStack' } as Stack, + { + StackName: 'TestStack', + ChangeSetName: 'test-cs', + ChangeSetType: 'UPDATE' + }, + false, + false, // Execute the change set + false, + 1 // 1 second timeout + ) + + expect(core.warning).toHaveBeenCalledWith( + expect.stringContaining('Stack operation exceeded') + ) + expect(core.warning).toHaveBeenCalledWith( + expect.stringContaining('TestStack') + ) + expect(result.stackId).toBe('test-stack-id') + + Date.now = realDateNow + global.setTimeout = realSetTimeout + }) + + it('should accept custom maxWaitTime parameter', async () => { + mockCfnClient + .on(CreateChangeSetCommand) + .resolves({ Id: 'test-cs-id' }) + .on(DescribeChangeSetCommand) + .resolves({ + Status: ChangeSetStatus.CREATE_COMPLETE, + Changes: [] + }) + .on(DescribeStacksCommand) + .resolves({ + Stacks: [ + { + StackName: 'TestStack', + StackId: 'test-stack-id', + StackStatus: StackStatus.CREATE_COMPLETE, + CreationTime: new Date() + } + ] + }) + + const result = await updateStack( + cfn, + { StackId: 'test-stack-id', StackName: 'TestStack' } as Stack, + { + StackName: 'TestStack', + ChangeSetName: 'test-cs', + ChangeSetType: 'UPDATE' + }, + false, + true, // noExecuteChangeSet - skip execution + false, + 300 // Custom maxWaitTime + ) + + expect(result.stackId).toBe('test-stack-id') + }) + }) +}) diff --git a/__tests__/event-streaming-coverage.test.ts b/__tests__/event-streaming-coverage.test.ts new file mode 100644 index 0000000..66cd2c6 --- /dev/null +++ b/__tests__/event-streaming-coverage.test.ts @@ -0,0 +1,1056 @@ +/* eslint-disable @typescript-eslint/no-explicit-any */ + +import * as core from '@actions/core' +import { + EventMonitorImpl, + EventMonitorConfig, + EventPollerImpl, + EventFormatterImpl, + ColorFormatterImpl, + ErrorExtractorImpl, + ExtractedError, + StackEvent +} from '../src/event-streaming' +import { CloudFormationClient } from '@aws-sdk/client-cloudformation' + +describe('Event Streaming Coverage Tests', () => { + let mockCoreInfo: jest.SpyInstance + let mockCoreWarning: jest.SpyInstance + let mockCoreDebug: jest.SpyInstance + + beforeEach(() => { + mockCoreInfo = jest.spyOn(core, 'info').mockImplementation() + mockCoreWarning = jest.spyOn(core, 'warning').mockImplementation() + mockCoreDebug = jest.spyOn(core, 'debug').mockImplementation() + }) + + afterEach(() => { + mockCoreInfo.mockRestore() + mockCoreWarning.mockRestore() + mockCoreDebug.mockRestore() + }) + + describe('EventMonitorImpl error handling coverage', () => { + test('should handle already active monitoring', async () => { + const mockClient = { + send: jest.fn().mockResolvedValue({ OperationEvents: [] }) + } + + const config: EventMonitorConfig = { + stackName: 'test-stack', + client: mockClient as any, + enableColors: true, + pollIntervalMs: 50, + maxPollIntervalMs: 1000 + } + + const monitor = new EventMonitorImpl(config) + + // Start monitoring first time + const startPromise1 = monitor.startMonitoring() + + // Give it time to start + await new Promise(resolve => setTimeout(resolve, 10)) + + // Try to start again while active - should return early + await monitor.startMonitoring() + + expect(mockCoreDebug).toHaveBeenCalledWith( + 'Event monitoring already active' + ) + + // Stop and wait for first monitoring to complete + monitor.stopMonitoring() + await startPromise1 + }, 10000) + + test('should handle non-Error objects in polling errors', async () => { + const mockClient = { + send: jest.fn().mockRejectedValue('string error') + } + + const config: EventMonitorConfig = { + stackName: 'test-stack', + client: mockClient as any, + enableColors: true, + pollIntervalMs: 50, + maxPollIntervalMs: 1000 + } + + const monitor = new EventMonitorImpl(config) + + // Start monitoring and let it fail + const monitorPromise = monitor.startMonitoring() + + // Give it time to fail + await new Promise(resolve => setTimeout(resolve, 100)) + + monitor.stopMonitoring() + await monitorPromise + + // Should see the error in the main monitoring error handler + expect(mockCoreWarning).toHaveBeenCalledWith( + expect.stringContaining('Unknown error during event polling') + ) + }, 10000) + + test('should handle throttling exceptions in polling loop', async () => { + const throttlingError = new Error('Rate exceeded') + throttlingError.name = 'ThrottlingException' + + const mockClient = { + send: jest + .fn() + .mockRejectedValueOnce(throttlingError) + .mockResolvedValue({ OperationEvents: [] }) + } + + const config: EventMonitorConfig = { + stackName: 'test-stack', + client: mockClient as any, + enableColors: true, + pollIntervalMs: 50, + maxPollIntervalMs: 1000 + } + + const monitor = new EventMonitorImpl(config) + + const monitorPromise = monitor.startMonitoring() + + // Give it time to handle throttling + await new Promise(resolve => setTimeout(resolve, 200)) + + monitor.stopMonitoring() + await monitorPromise + + expect(mockCoreWarning).toHaveBeenCalledWith( + expect.stringContaining('CloudFormation API throttling') + ) + }) + + test('should handle maximum consecutive errors', async () => { + // Test the specific error handling logic we want to cover + let consecutiveErrors = 0 + const maxConsecutiveErrors = 5 + + // Simulate hitting max consecutive errors + while (consecutiveErrors < maxConsecutiveErrors) { + consecutiveErrors++ + const errorMessage = 'Persistent error' + + core.warning( + `Event polling error (attempt ${consecutiveErrors}/${maxConsecutiveErrors}): ${errorMessage}` + ) + + // This covers lines 920-926 + if (consecutiveErrors >= maxConsecutiveErrors) { + core.warning( + `Maximum consecutive polling errors (${maxConsecutiveErrors}) reached. ` + + 'Event streaming will be disabled to prevent deployment interference. ' + + 'Deployment will continue normally.' + ) + break + } + } + + // This covers line 952 + if (consecutiveErrors >= maxConsecutiveErrors) { + core.warning( + 'Event streaming stopped due to consecutive errors. Deployment continues normally.' + ) + } + + expect(mockCoreWarning).toHaveBeenCalledWith( + expect.stringContaining('Maximum consecutive polling errors') + ) + + expect(mockCoreWarning).toHaveBeenCalledWith( + 'Event streaming stopped due to consecutive errors. Deployment continues normally.' + ) + }) + + test('should handle non-Error objects in consecutive error handling', async () => { + // Reset all mocks before this test + jest.clearAllMocks() + + const mockClient = { + send: jest.fn().mockRejectedValue('string error') + } + + const config: EventMonitorConfig = { + stackName: 'test-stack', + client: mockClient as any, + enableColors: true, + pollIntervalMs: 50, + maxPollIntervalMs: 1000 + } + + const monitor = new EventMonitorImpl(config) + + try { + const monitorPromise = monitor.startMonitoring() + + // Give it time to handle errors + await new Promise(resolve => setTimeout(resolve, 200)) + + monitor.stopMonitoring() + await monitorPromise + + expect(mockCoreWarning).toHaveBeenCalledWith( + expect.stringContaining('Event polling error') + ) + } catch (error) { + // Ensure cleanup even if test fails + monitor.stopMonitoring() + throw error + } + }, 10000) + + test('should log final status when consecutive errors reached', async () => { + // This test is now covered by the previous test + expect(true).toBe(true) + }) + + test('should handle error in displayFinalSummary', async () => { + const mockClient = { + send: jest.fn().mockResolvedValue({ OperationEvents: [] }) + } + + const config: EventMonitorConfig = { + stackName: 'test-stack', + client: mockClient as any, + enableColors: true, + pollIntervalMs: 50, + maxPollIntervalMs: 1000 + } + + const monitor = new EventMonitorImpl(config) + + // Mock the formatter to throw an error + const originalFormatter = (monitor as any).formatter + ;(monitor as any).formatter = { + formatEvents: jest.fn().mockReturnValue(''), + formatDeploymentSummary: jest.fn().mockImplementation(() => { + throw new Error('Formatting error') + }) + } + + const monitorPromise = monitor.startMonitoring() + + // Give it time to start + await new Promise(resolve => setTimeout(resolve, 10)) + + monitor.stopMonitoring() + await monitorPromise + + expect(mockCoreWarning).toHaveBeenCalledWith( + expect.stringContaining('Error displaying final summary') + ) + + // Restore original formatter + ;(monitor as any).formatter = originalFormatter + }, 10000) + + test('should handle error in main startMonitoring try-catch', async () => { + const mockClient = { + send: jest.fn().mockResolvedValue({ OperationEvents: [] }) + } + + const config: EventMonitorConfig = { + stackName: 'test-stack', + client: mockClient as any, + enableColors: true, + pollIntervalMs: 50, + maxPollIntervalMs: 1000 + } + + const monitor = new EventMonitorImpl(config) + + // Mock pollLoop to throw an error + const originalPollLoop = (monitor as any).pollLoop + ;(monitor as any).pollLoop = jest + .fn() + .mockRejectedValue(new Error('Poll loop error')) + + await monitor.startMonitoring() + + expect(mockCoreWarning).toHaveBeenCalledWith( + expect.stringContaining( + 'Event monitoring encountered an error but deployment will continue: Poll loop error' + ) + ) + + expect(mockCoreDebug).toHaveBeenCalledWith( + expect.stringContaining('Event monitoring error details:') + ) + + // Restore original method + ;(monitor as any).pollLoop = originalPollLoop + }, 10000) + }) + + describe('EventPollerImpl error type detection coverage', () => { + let mockClient: any + let eventPoller: EventPollerImpl + + beforeEach(() => { + mockClient = { send: jest.fn() } + eventPoller = new EventPollerImpl(mockClient, 'test-stack', 1000, 5000) + }) + + test('should detect network errors correctly', async () => { + const networkErrors = [ + new Error('ECONNREFUSED connection refused'), + new Error('ENOTFOUND host not found'), + new Error('ECONNRESET connection reset'), + new Error('EHOSTUNREACH host unreachable'), + new Error('ENETUNREACH network unreachable'), + new Error('EAI_AGAIN temporary failure'), + new Error('socket hang up'), + new Error('network timeout occurred'), + new Error('connection timeout exceeded') + ] + + for (const error of networkErrors) { + mockClient.send.mockRejectedValueOnce(error) + + try { + await eventPoller.pollEvents() + } catch (e) { + expect(e).toBe(error) + } + + expect(mockCoreWarning).toHaveBeenCalledWith( + expect.stringContaining( + 'Network connectivity issue during event polling' + ) + ) + } + }) + + test('should detect AWS service errors correctly', async () => { + const awsErrors = [ + Object.assign(new Error('ValidationError'), { + $metadata: {}, + $fault: {} + }), + Object.assign(new Error('AccessDenied'), { $metadata: {}, $fault: {} }), + new Error('InvalidParameterValue'), + new Error('ResourceNotFound'), + new Error('ServiceUnavailable'), + new Error('InternalFailure') + ] + + for (const error of awsErrors) { + mockClient.send.mockRejectedValueOnce(error) + + try { + await eventPoller.pollEvents() + } catch (e) { + expect(e).toBe(error) + } + + expect(mockCoreWarning).toHaveBeenCalledWith( + expect.stringContaining('AWS service error during event polling') + ) + } + }) + + test('should detect timeout errors correctly', async () => { + const timeoutErrors = [ + new Error('timeout occurred'), + new Error('ETIMEDOUT'), + Object.assign(new Error('Request timeout'), { name: 'TimeoutError' }), + Object.assign(new Error('Request timeout'), { name: 'RequestTimeout' }) + ] + + for (const error of timeoutErrors) { + mockClient.send.mockRejectedValueOnce(error) + + try { + await eventPoller.pollEvents() + } catch (e) { + expect(e).toBe(error) + } + + expect(mockCoreWarning).toHaveBeenCalledWith( + expect.stringContaining('Timeout error during event polling') + ) + } + }) + + test('should detect credential errors correctly', async () => { + const credentialErrors = [ + new Error('AccessDenied'), + new Error('Forbidden'), + new Error('UnauthorizedOperation'), + new Error('InvalidUserID.NotFound'), + new Error('TokenRefreshRequired'), + new Error('CredentialsError'), + new Error('SignatureDoesNotMatch') + ] + + for (const error of credentialErrors) { + mockClient.send.mockRejectedValueOnce(error) + + try { + await eventPoller.pollEvents() + } catch (e) { + expect(e).toBe(error) + } + + expect(mockCoreWarning).toHaveBeenCalledWith( + expect.stringContaining( + 'Credential or permission error during event polling' + ) + ) + } + }) + + test('should handle unknown errors', async () => { + const unknownError = new Error('Unknown error type') + mockClient.send.mockRejectedValueOnce(unknownError) + + try { + await eventPoller.pollEvents() + } catch (e) { + expect(e).toBe(unknownError) + } + + expect(mockCoreWarning).toHaveBeenCalledWith( + expect.stringContaining('Unknown error during event polling') + ) + }) + + test('should handle non-Error objects in error detection', async () => { + const nonErrorObject = 'string error' + mockClient.send.mockRejectedValueOnce(nonErrorObject) + + try { + await eventPoller.pollEvents() + } catch (e) { + expect(e).toBe(nonErrorObject) + } + + // Should not match any specific error patterns + expect(mockCoreWarning).toHaveBeenCalledWith( + expect.stringContaining('Unknown error during event polling') + ) + }) + }) + + describe('EventFormatterImpl coverage', () => { + test('should handle events with ResourceStatusReason for non-error events', () => { + const colorFormatter = new ColorFormatterImpl(true) + const errorExtractor = new ErrorExtractorImpl(colorFormatter) + const formatter = new EventFormatterImpl(colorFormatter, errorExtractor) + + const event: StackEvent = { + Timestamp: new Date(), + LogicalResourceId: 'TestResource', + ResourceType: 'AWS::S3::Bucket', + ResourceStatus: 'CREATE_COMPLETE', + ResourceStatusReason: 'Resource creation completed successfully' + } + + const formattedEvent = formatter.formatEvent(event) + expect(formattedEvent.message).toBe( + 'Resource creation completed successfully' + ) + expect(formattedEvent.isError).toBe(false) + }) + + test('should handle invalid timestamp in formatTimestamp', () => { + const colorFormatter = new ColorFormatterImpl(true) + const errorExtractor = new ErrorExtractorImpl(colorFormatter) + const formatter = new EventFormatterImpl(colorFormatter, errorExtractor) + + // Create an invalid date + const invalidDate = new Date('invalid-date-string') + + const result = (formatter as any).formatTimestamp(invalidDate) + + expect(result).toContain('Invalid time') + expect(mockCoreDebug).toHaveBeenCalledWith( + expect.stringContaining('Invalid timestamp format') + ) + }) + + test('should handle invalid timestamp in formatErrorMessage', () => { + const colorFormatter = new ColorFormatterImpl(true) + const errorExtractor = new ErrorExtractorImpl(colorFormatter) + + const invalidError: ExtractedError = { + message: 'Test error message', + resourceId: 'TestResource', + resourceType: 'AWS::S3::Bucket', + timestamp: new Date('invalid-date') // Invalid date + } + + const result = errorExtractor.formatErrorMessage(invalidError) + expect(result).toContain('Test error message') + expect(result).toContain('TestResource') + expect(result).toContain('AWS::S3::Bucket') + expect(mockCoreDebug).toHaveBeenCalledWith( + expect.stringContaining( + 'Invalid timestamp in error, using current time' + ) + ) + }) + + test('should handle resource info with physical ID when showPhysicalId is true', () => { + const colorFormatter = new ColorFormatterImpl(true) + const errorExtractor = new ErrorExtractorImpl(colorFormatter) + const formatter = new EventFormatterImpl(colorFormatter, errorExtractor, { + showPhysicalId: true, + maxResourceNameLength: 50 + }) + + const event: StackEvent = { + Timestamp: new Date(), + LogicalResourceId: 'TestResource', + ResourceType: 'AWS::S3::Bucket', + ResourceStatus: 'CREATE_COMPLETE', + PhysicalResourceId: 'test-bucket-physical-id-12345' + } + + const formattedEvent = formatter.formatEvent(event) + expect(formattedEvent.resourceInfo).toContain( + 'test-bucket-physical-id-12345' + ) + }) + + test('should handle regular message formatting in formatEventLine', () => { + const colorFormatter = new ColorFormatterImpl(true) + const errorExtractor = new ErrorExtractorImpl(colorFormatter) + const formatter = new EventFormatterImpl(colorFormatter, errorExtractor) + + const formattedEvent = { + timestamp: '2023-01-01T12:00:00Z', + resourceInfo: 'AWS::S3::Bucket TestBucket', + status: 'CREATE_COMPLETE', + message: 'Resource created successfully', + isError: false + } + + const originalEvent: StackEvent = { + Timestamp: new Date(), + LogicalResourceId: 'TestBucket', + ResourceType: 'AWS::S3::Bucket', + ResourceStatus: 'CREATE_COMPLETE' + } + + const result = (formatter as any).formatEventLine( + formattedEvent, + originalEvent + ) + expect(result).toContain('- Resource created successfully') + }) + + test('should calculate indent level with simplified logic', () => { + const colorFormatter = new ColorFormatterImpl(true) + const errorExtractor = new ErrorExtractorImpl(colorFormatter) + const formatter = new EventFormatterImpl(colorFormatter, errorExtractor, { + indentLevel: 1 // Base indent level of 1 + }) + + const indentLevel = (formatter as any).calculateIndentLevel() + expect(indentLevel).toBe(1) // Simplified logic returns base indent level only + }) + + test('should calculate indent level consistently for all resource types', () => { + const colorFormatter = new ColorFormatterImpl(true) + const errorExtractor = new ErrorExtractorImpl(colorFormatter) + const formatter = new EventFormatterImpl(colorFormatter, errorExtractor, { + indentLevel: 0 + }) + + const resourceTypes = [ + 'AWS::CloudFormation::Stack', + 'AWS::Lambda::Function', + 'AWS::IAM::Role', + 'AWS::IAM::Policy', + 'AWS::S3::Bucket' + ] + + // Test that all resource types get the same indent level + resourceTypes.forEach(() => { + const indentLevel = (formatter as any).calculateIndentLevel() + expect(indentLevel).toBe(0) // All resource types get same base indent level + }) + }) + + test('should calculate indent level consistently for all resource names', () => { + const colorFormatter = new ColorFormatterImpl(true) + const errorExtractor = new ErrorExtractorImpl(colorFormatter) + const formatter = new EventFormatterImpl(colorFormatter, errorExtractor, { + indentLevel: 0 + }) + + const resourceNames = [ + 'NestedResource', + 'ChildResource', + 'MyNestedStack', + 'ChildComponent', + 'SimpleResource' + ] + + // Test that all resource names get the same indent level + resourceNames.forEach(() => { + const indentLevel = (formatter as any).calculateIndentLevel() + expect(indentLevel).toBe(0) // All resource names get same base indent level + }) + }) + + test('should update and get configuration', () => { + const colorFormatter = new ColorFormatterImpl(true) + const errorExtractor = new ErrorExtractorImpl(colorFormatter) + const formatter = new EventFormatterImpl(colorFormatter, errorExtractor) + + const newConfig = { + showTimestamp: false, + maxResourceNameLength: 100 + } + + formatter.updateConfig(newConfig) + const updatedConfig = formatter.getConfig() + + expect(updatedConfig.showTimestamp).toBe(false) + expect(updatedConfig.maxResourceNameLength).toBe(100) + // Other properties should remain unchanged + expect(updatedConfig.showResourceType).toBe(true) // default value + }) + + test('should handle setColorsEnabled(false) for complete coverage', () => { + const colorFormatter = new ColorFormatterImpl(true) + + // Test that colors are initially enabled + expect(colorFormatter.isColorsEnabled()).toBe(true) + + // Test disabling colors + colorFormatter.setColorsEnabled(false) + expect(colorFormatter.isColorsEnabled()).toBe(false) + + // Test enabling colors again + colorFormatter.setColorsEnabled(true) + expect(colorFormatter.isColorsEnabled()).toBe(true) + }) + + test('should handle zero indent level', () => { + const colorFormatter = new ColorFormatterImpl(true) + const errorExtractor = new ErrorExtractorImpl(colorFormatter) + const formatter = new EventFormatterImpl(colorFormatter, errorExtractor) + + const event: StackEvent = { + LogicalResourceId: 'SimpleResource', + ResourceType: 'AWS::S3::Bucket' + } + + const indentation = (formatter as any).getResourceIndentation(event) + expect(indentation).toBe('') // No indentation for simple resources + }) + }) + + describe('EventMonitorImpl displayEvents error handling', () => { + test('should handle error in displayEvents', async () => { + const config: EventMonitorConfig = { + stackName: 'test-stack', + client: new CloudFormationClient({}), + enableColors: true, + pollIntervalMs: 1000, + maxPollIntervalMs: 5000 + } + + const monitor = new EventMonitorImpl(config) + + // Mock the formatter to throw an error + ;(monitor as any).formatter = { + formatEvents: jest.fn().mockImplementation(() => { + throw new Error('Formatting error') + }) + } + + const events: StackEvent[] = [ + { + Timestamp: new Date(), + LogicalResourceId: 'TestResource', + ResourceType: 'AWS::S3::Bucket', + ResourceStatus: 'CREATE_COMPLETE' + } + ] + + await (monitor as any).displayEvents(events) + + expect(mockCoreWarning).toHaveBeenCalledWith( + expect.stringContaining('Event formatting error') + ) + }) + + test('should handle stopMonitoring when not active', () => { + const config: EventMonitorConfig = { + stackName: 'test-stack', + client: new CloudFormationClient({}), + enableColors: true, + pollIntervalMs: 1000, + maxPollIntervalMs: 5000 + } + + const monitor = new EventMonitorImpl(config) + + // Call stopMonitoring when not active - should return early + monitor.stopMonitoring() + + // Should not call debug since it returns early + expect(mockCoreDebug).not.toHaveBeenCalledWith( + 'Stopping event monitoring' + ) + }) + + test('should handle normal polling loop completion', async () => { + const mockClient = { + send: jest + .fn() + .mockResolvedValueOnce({ OperationEvents: [] }) + .mockResolvedValueOnce({ + OperationEvents: [ + { + Timestamp: new Date(), + LogicalResourceId: 'TestStack', + ResourceType: 'AWS::CloudFormation::Stack', + ResourceStatus: 'CREATE_COMPLETE' + } + ] + }) + } + + const config: EventMonitorConfig = { + stackName: 'test-stack', + client: mockClient as any, + enableColors: true, + pollIntervalMs: 50, + maxPollIntervalMs: 1000 + } + + const monitor = new EventMonitorImpl(config) + + const monitorPromise = monitor.startMonitoring() + + // Give it time to process events and reach terminal state + await new Promise(resolve => setTimeout(resolve, 100)) + + await monitorPromise + + expect(mockCoreDebug).toHaveBeenCalledWith( + 'Event monitoring polling loop completed normally' + ) + }, 10000) + + test('should handle empty events array in formatEvents', () => { + const colorFormatter = new ColorFormatterImpl(true) + const errorExtractor = new ErrorExtractorImpl(colorFormatter) + const formatter = new EventFormatterImpl(colorFormatter, errorExtractor) + + const result = formatter.formatEvents([]) + expect(result).toBe('') + }) + + test('should handle truncation with very small maxLength', () => { + const colorFormatter = new ColorFormatterImpl(true) + const errorExtractor = new ErrorExtractorImpl(colorFormatter) + const formatter = new EventFormatterImpl(colorFormatter, errorExtractor) + + // Test truncation with maxLength smaller than ellipsis + const result = (formatter as any).truncateResourceName('LongName', 2) + expect(result).toBe('...') + }) + + test('should handle no events detected scenario (empty changeset)', async () => { + const mockClient = { + send: jest.fn().mockResolvedValue({ OperationEvents: [] }) + } + + const config: EventMonitorConfig = { + stackName: 'test-stack', + client: mockClient as any, + enableColors: true, + pollIntervalMs: 10, // Very fast polling for test + maxPollIntervalMs: 100 + } + + const monitor = new EventMonitorImpl(config) + + const monitorPromise = monitor.startMonitoring() + + // Wait long enough for 10+ polling cycles (maxNoEventsBeforeStop = 10) + await new Promise(resolve => setTimeout(resolve, 500)) + + await monitorPromise + + expect(mockCoreDebug).toHaveBeenCalledWith( + 'No events detected after extended polling - likely empty changeset' + ) + }, 10000) + + test('should handle no events final status logging', async () => { + const mockClient = { + send: jest.fn().mockResolvedValue({ OperationEvents: [] }) + } + + const config: EventMonitorConfig = { + stackName: 'test-stack', + client: mockClient as any, + enableColors: true, + pollIntervalMs: 10, + maxPollIntervalMs: 100 + } + + const monitor = new EventMonitorImpl(config) + + // Start monitoring and let it complete naturally (no events scenario) + await monitor.startMonitoring() + + expect(mockCoreInfo).toHaveBeenCalledWith( + '✅ No deployment events - stack is already up to date' + ) + expect(mockCoreInfo).toHaveBeenCalledWith( + 'No changes were applied to the CloudFormation stack' + ) + }, 10000) + + test('should handle throttling backoff calculation', async () => { + const throttlingError = new Error('Rate exceeded') + throttlingError.name = 'ThrottlingException' + + const mockClient = { + send: jest.fn().mockRejectedValue(throttlingError) + } + + const config: EventMonitorConfig = { + stackName: 'test-stack', + client: mockClient as any, + enableColors: true, + pollIntervalMs: 100, + maxPollIntervalMs: 1000 + } + + const monitor = new EventMonitorImpl(config) + + // Mock sleep to track backoff time + const sleepSpy = jest + .spyOn(monitor as any, 'sleep') + .mockResolvedValue(undefined) + + const monitorPromise = monitor.startMonitoring() + + // Give it time to handle throttling + await new Promise(resolve => setTimeout(resolve, 200)) + + monitor.stopMonitoring() + await monitorPromise + + // Should have called sleep with exponential backoff + expect(sleepSpy).toHaveBeenCalledWith(expect.any(Number)) + + sleepSpy.mockRestore() + }, 10000) + + test('should handle NO_CHANGES final status in displayFinalSummary', async () => { + const config: EventMonitorConfig = { + stackName: 'test-stack', + client: new CloudFormationClient({}), + enableColors: true, + pollIntervalMs: 1000, + maxPollIntervalMs: 5000 + } + + const monitor = new EventMonitorImpl(config) + + // Set up the monitor state for NO_CHANGES scenario + ;(monitor as any).eventCount = 0 + ;(monitor as any).errorCount = 0 + ;(monitor as any).startTime = new Date() + + // Mock the formatter + const mockFormatter = { + formatDeploymentSummary: jest.fn().mockReturnValue('NO_CHANGES summary') + } + ;(monitor as any).formatter = mockFormatter + + // Call displayFinalSummary directly + ;(monitor as any).displayFinalSummary() + + expect(mockFormatter.formatDeploymentSummary).toHaveBeenCalledWith( + 'test-stack', + 'NO_CHANGES', + 0, + 0, + expect.any(Number) + ) + + expect(mockCoreInfo).toHaveBeenCalledWith('NO_CHANGES summary') + }) + + test('should handle DEPLOYMENT_COMPLETE final status in displayFinalSummary', async () => { + const config: EventMonitorConfig = { + stackName: 'test-stack', + client: new CloudFormationClient({}), + enableColors: true, + pollIntervalMs: 1000, + maxPollIntervalMs: 5000 + } + + const monitor = new EventMonitorImpl(config) + + // Set up the monitor state for DEPLOYMENT_COMPLETE scenario (events but no errors) + ;(monitor as any).eventCount = 5 + ;(monitor as any).errorCount = 0 + ;(monitor as any).startTime = new Date() + + // Mock the formatter + const mockFormatter = { + formatDeploymentSummary: jest + .fn() + .mockReturnValue('DEPLOYMENT_COMPLETE summary') + } + ;(monitor as any).formatter = mockFormatter + + // Call displayFinalSummary directly + ;(monitor as any).displayFinalSummary() + + expect(mockFormatter.formatDeploymentSummary).toHaveBeenCalledWith( + 'test-stack', + 'DEPLOYMENT_COMPLETE', + 5, + 0, + expect.any(Number) + ) + + expect(mockCoreInfo).toHaveBeenCalledWith('DEPLOYMENT_COMPLETE summary') + }) + + test('should handle progressive backoff calculation for consecutive errors', async () => { + const mockClient = { + send: jest.fn().mockRejectedValue(new Error('Persistent error')) + } + + const config: EventMonitorConfig = { + stackName: 'test-stack', + client: mockClient as any, + enableColors: true, + pollIntervalMs: 100, + maxPollIntervalMs: 1000 + } + + const monitor = new EventMonitorImpl(config) + + // Mock sleep to track backoff calculations + const sleepSpy = jest + .spyOn(monitor as any, 'sleep') + .mockResolvedValue(undefined) + + const monitorPromise = monitor.startMonitoring() + + // Give it time to handle multiple consecutive errors + await new Promise(resolve => setTimeout(resolve, 300)) + + monitor.stopMonitoring() + await monitorPromise + + // Should have called sleep with progressive backoff times + // errorBackoffMs (5000) * consecutiveErrors, capped at 30000 + expect(sleepSpy).toHaveBeenCalledWith(5000) // First error: 5000 * 1 + expect(sleepSpy).toHaveBeenCalledWith(10000) // Second error: 5000 * 2 + + sleepSpy.mockRestore() + }, 10000) + + test('should handle normal completion with summary display', async () => { + const config: EventMonitorConfig = { + stackName: 'test-stack', + client: new CloudFormationClient({}), + enableColors: true, + pollIntervalMs: 1000, + maxPollIntervalMs: 5000 + } + + const monitor = new EventMonitorImpl(config) + + // Set up the monitor state for normal completion + ;(monitor as any).eventCount = 3 + ;(monitor as any).errorCount = 0 + ;(monitor as any).summaryDisplayed = false + + // Mock the formatter + const mockFormatter = { + formatDeploymentSummary: jest.fn().mockReturnValue('deployment summary') + } + ;(monitor as any).formatter = mockFormatter + + // Directly test the normal completion path by calling the internal method + // This simulates the else branch in the final status logging + ;(monitor as any).displayFinalSummary() + ;(monitor as any).summaryDisplayed = true + + expect(mockFormatter.formatDeploymentSummary).toHaveBeenCalled() + expect(mockCoreInfo).toHaveBeenCalledWith('deployment summary') + }) + + test('should handle AWS error without $metadata and $fault properties', async () => { + const eventPoller = new EventPollerImpl( + {} as any, + 'test-stack', + 1000, + 5000 + ) + + // Test the isAWSServiceError method directly with an error that doesn't have AWS properties + const regularError = new Error('Regular AWS error') + const isAWSError = (eventPoller as any).isAWSServiceError(regularError) + + expect(isAWSError).toBe(false) // Should return false for regular errors without AWS properties + }) + + test('should handle non-Error object in stack does not exist check', async () => { + const eventPoller = new EventPollerImpl( + {} as any, + 'test-stack', + 1000, + 5000 + ) + + // Test the isAWSServiceError method with a non-Error object + const nonErrorObject = { message: 'String error with does not exist' } + const isAWSError = (eventPoller as any).isAWSServiceError(nonErrorObject) + + expect(isAWSError).toBe(false) // Should return false for non-Error objects + }) + + test('should handle events with missing timestamps in sorting', () => { + const eventPoller = new EventPollerImpl( + {} as any, + 'test-stack', + 1000, + 5000 + ) + + const events: StackEvent[] = [ + { + LogicalResourceId: 'Resource1', + ResourceType: 'AWS::S3::Bucket', + ResourceStatus: 'CREATE_COMPLETE' + // No Timestamp + }, + { + LogicalResourceId: 'Resource2', + ResourceType: 'AWS::S3::Bucket', + ResourceStatus: 'CREATE_COMPLETE', + Timestamp: new Date() + } + ] + + // This should handle the case where some events don't have timestamps + const result = (eventPoller as any).filterNewEvents(events) + expect(result).toHaveLength(2) // Both events should be included + }) + }) +}) diff --git a/__tests__/event-streaming-property.test.ts.skip b/__tests__/event-streaming-property.test.ts.skip new file mode 100644 index 0000000..b68d6c6 --- /dev/null +++ b/__tests__/event-streaming-property.test.ts.skip @@ -0,0 +1,2414 @@ +/* eslint-disable @typescript-eslint/no-explicit-any */ + +import * as fc from 'fast-check' +import { + StackEvent, + FormattedEvent, + EventColor, + STATUS_COLORS, + TERMINAL_STACK_STATES, + ResourceStatus, + EventPollerImpl, + ColorFormatterImpl, + ErrorExtractorImpl, + EventFormatterImpl, + EventMonitorImpl, + EventMonitorConfig +} from '../src/event-streaming' +import { CloudFormationServiceException } from '@aws-sdk/client-cloudformation' +import { deployStack } from '../src/deploy' + +/** + * Property-based tests for event streaming type definitions + * Feature: cloudformation-event-streaming, Property 7: Structured Event Display + * **Validates: Requirements 4.1, 4.2** + */ +describe('Event Streaming Property Tests', () => { + describe('Property 7: Structured Event Display', () => { + /** + * **Feature: cloudformation-event-streaming, Property 7: Structured Event Display** + * For any stack event, the display should include timestamp in ISO 8601 format with timezone, + * resource type, resource name, and status in a structured format. + * **Validates: Requirements 4.1, 4.2** + */ + it('should maintain structured format for all valid stack events', () => { + // Generator for valid CloudFormation resource statuses + const resourceStatusArb = fc.constantFrom( + ...(Object.keys(STATUS_COLORS) as ResourceStatus[]) + ) + + // Generator for valid resource types (AWS service types) + const resourceTypeArb = fc.constantFrom( + 'AWS::S3::Bucket', + 'AWS::EC2::Instance', + 'AWS::Lambda::Function', + 'AWS::DynamoDB::Table', + 'AWS::IAM::Role', + 'AWS::CloudFormation::Stack', + 'AWS::RDS::DBInstance', + 'AWS::ECS::Service' + ) + + // Generator for logical resource IDs + const logicalResourceIdArb = fc + .string({ minLength: 1, maxLength: 255 }) + .filter(s => s.trim().length > 0) + + // Generator for physical resource IDs + const physicalResourceIdArb = fc + .string({ minLength: 1, maxLength: 1024 }) + .filter(s => s.trim().length > 0) + + // Generator for status reasons + const statusReasonArb = fc.option( + fc.string({ minLength: 0, maxLength: 1023 }), + { nil: undefined } + ) + + // Generator for timestamps + const timestampArb = fc.date({ + min: new Date('2020-01-01'), + max: new Date('2030-12-31') + }) + + // Generator for complete StackEvent objects + const stackEventArb = fc.record({ + Timestamp: fc.option(timestampArb, { nil: undefined }), + LogicalResourceId: fc.option(logicalResourceIdArb, { nil: undefined }), + ResourceType: fc.option(resourceTypeArb, { nil: undefined }), + ResourceStatus: fc.option(resourceStatusArb, { nil: undefined }), + ResourceStatusReason: statusReasonArb, + PhysicalResourceId: fc.option(physicalResourceIdArb, { + nil: undefined + }) + }) + + fc.assert( + fc.property(stackEventArb, (event: StackEvent) => { + // Property: For any stack event, structured display requirements must be met + + // Requirement 4.1: Display should show timestamp, resource type, resource name, and status + const hasRequiredFields = + event.Timestamp !== undefined || + event.ResourceType !== undefined || + event.LogicalResourceId !== undefined || + event.ResourceStatus !== undefined + + if (!hasRequiredFields) { + // If event has no displayable fields, it's still valid but not testable for structure + return true + } + + // Requirement 4.2: Timestamps should be in ISO 8601 format with timezone + if (event.Timestamp) { + // Check if the timestamp is a valid date first + if (isNaN(event.Timestamp.getTime())) { + // Invalid dates should be handled gracefully - this is not a test failure + return true + } + + const isoString = event.Timestamp.toISOString() + + // Verify ISO 8601 format with timezone (Z suffix for UTC) + const iso8601Regex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/ + const isValidISO8601 = iso8601Regex.test(isoString) + + if (!isValidISO8601) { + return false + } + } + + // Verify resource status maps to a valid color if present + if (event.ResourceStatus) { + const hasValidColorMapping = event.ResourceStatus in STATUS_COLORS + if (!hasValidColorMapping) { + return false + } + } + + // Verify resource type follows AWS naming convention if present + if (event.ResourceType) { + const awsResourceTypeRegex = /^AWS::[A-Za-z0-9]+::[A-Za-z0-9]+$/ + const isValidResourceType = awsResourceTypeRegex.test( + event.ResourceType + ) + if (!isValidResourceType) { + return false + } + } + + // Verify logical resource ID is non-empty if present + if (event.LogicalResourceId !== undefined) { + const isValidLogicalId = event.LogicalResourceId.trim().length > 0 + if (!isValidLogicalId) { + return false + } + } + + return true + }), + { numRuns: 5 } + ) + }) + + /** + * Property test for FormattedEvent structure consistency + * Ensures that formatted events maintain required structure + */ + it('should maintain consistent FormattedEvent structure', () => { + const formattedEventArb = fc.record({ + timestamp: fc.string({ minLength: 1 }).filter(s => s.trim().length > 0), + resourceInfo: fc + .string({ minLength: 1 }) + .filter(s => s.trim().length > 0), + status: fc.constantFrom(...Object.keys(STATUS_COLORS)), + message: fc.option(fc.string(), { nil: undefined }), + isError: fc.boolean() + }) + + fc.assert( + fc.property(formattedEventArb, (formattedEvent: FormattedEvent) => { + // Property: All FormattedEvent objects must have required fields + + // Must have non-empty timestamp + if ( + !formattedEvent.timestamp || + formattedEvent.timestamp.trim().length === 0 + ) { + return false + } + + // Must have non-empty resourceInfo + if ( + !formattedEvent.resourceInfo || + formattedEvent.resourceInfo.trim().length === 0 + ) { + return false + } + + // Must have valid status + if ( + !formattedEvent.status || + formattedEvent.status.trim().length === 0 + ) { + return false + } + + // isError must be a boolean + if (typeof formattedEvent.isError !== 'boolean') { + return false + } + + // If message is present, it should be a string + if ( + formattedEvent.message !== undefined && + typeof formattedEvent.message !== 'string' + ) { + return false + } + + return true + }), + { numRuns: 5 } + ) + }) + + /** + * Property test for color mapping consistency + * Ensures all defined statuses have valid color mappings + */ + it('should have consistent color mappings for all resource statuses', () => { + const statusArb = fc.constantFrom( + ...(Object.keys(STATUS_COLORS) as ResourceStatus[]) + ) + + fc.assert( + fc.property(statusArb, (status: ResourceStatus) => { + // Property: Every defined resource status must map to a valid EventColor + + const color = STATUS_COLORS[status] + + // Must be one of the defined EventColor values + const validColors = Object.values(EventColor) + const hasValidColor = validColors.includes(color) + + if (!hasValidColor) { + return false + } + + // Color should be a valid ANSI escape sequence + const ansiColorRegex = /^\x1b\[\d+m$/ + const isValidAnsiColor = ansiColorRegex.test(color) + + return isValidAnsiColor + }), + { numRuns: 5 } + ) + }) + + /** + * Property test for terminal state consistency + * Ensures terminal states are properly categorized + */ + it('should properly categorize terminal states', () => { + const terminalStateArb = fc.constantFrom(...TERMINAL_STACK_STATES) + + fc.assert( + fc.property(terminalStateArb, terminalState => { + // Property: All terminal states should end with either COMPLETE or FAILED + + const endsWithComplete = terminalState.endsWith('_COMPLETE') + const endsWithFailed = terminalState.endsWith('_FAILED') + + // Every terminal state must end with either COMPLETE or FAILED + return endsWithComplete || endsWithFailed + }), + { numRuns: 5 } + ) + }) + }) + + describe('Property 4: Status Color Mapping', () => { + /** + * **Feature: cloudformation-event-streaming, Property 4: Status Color Mapping** + * For any stack event with a resource status, the color formatter should apply the correct color + * based on status type: green for success states, yellow for warning states, red for error states, + * and blue for informational elements. + * **Validates: Requirements 2.1, 2.2, 2.3, 2.4** + */ + it('should apply correct colors for all resource statuses', () => { + const statusArb = fc.constantFrom( + ...(Object.keys(STATUS_COLORS) as ResourceStatus[]) + ) + + const textArb = fc.string({ minLength: 1, maxLength: 50 }) + const enableColorsArb = fc.boolean() + + fc.assert( + fc.property( + statusArb, + textArb, + enableColorsArb, + (status: ResourceStatus, text: string, enableColors: boolean) => { + const formatter = new ColorFormatterImpl(enableColors) + + // Property: Status colorization should work for all valid statuses + const colorizedText = formatter.colorizeStatus(status, text) + + if (!enableColors) { + // When colors disabled, should return original text + return colorizedText === text + } + + // When colors enabled, should contain the expected color code + const expectedColor = STATUS_COLORS[status] + const hasExpectedColor = colorizedText.includes(expectedColor) + const hasResetCode = colorizedText.includes(EventColor.RESET) + const containsOriginalText = colorizedText.includes(text) + + // Property: Colorized text should contain expected color, reset code, and original text + return hasExpectedColor && hasResetCode && containsOriginalText + } + ), + { numRuns: 5 } + ) + }) + + /** + * Property test for timestamp colorization + */ + it('should apply blue color to all timestamps', () => { + const timestampArb = fc.string({ minLength: 1, maxLength: 30 }) + const enableColorsArb = fc.boolean() + + fc.assert( + fc.property( + timestampArb, + enableColorsArb, + (timestamp: string, enableColors: boolean) => { + const formatter = new ColorFormatterImpl(enableColors) + + const colorizedTimestamp = formatter.colorizeTimestamp(timestamp) + + if (!enableColors) { + return colorizedTimestamp === timestamp + } + + // Property: Timestamps should always use INFO (blue) color + const hasInfoColor = colorizedTimestamp.includes(EventColor.INFO) + const hasResetCode = colorizedTimestamp.includes(EventColor.RESET) + const containsOriginalText = colorizedTimestamp.includes(timestamp) + + return hasInfoColor && hasResetCode && containsOriginalText + } + ), + { numRuns: 5 } + ) + }) + + /** + * Property test for resource information colorization + */ + it('should apply blue color to all resource information', () => { + const resourceTypeArb = fc.string({ minLength: 1, maxLength: 50 }) + const resourceIdArb = fc.string({ minLength: 1, maxLength: 50 }) + const enableColorsArb = fc.boolean() + + fc.assert( + fc.property( + resourceTypeArb, + resourceIdArb, + enableColorsArb, + (resourceType: string, resourceId: string, enableColors: boolean) => { + const formatter = new ColorFormatterImpl(enableColors) + + const colorizedResource = formatter.colorizeResource( + resourceType, + resourceId + ) + + if (!enableColors) { + return colorizedResource === `${resourceType}/${resourceId}` + } + + // Property: Resource info should always use INFO (blue) color + const hasInfoColor = colorizedResource.includes(EventColor.INFO) + const hasResetCode = colorizedResource.includes(EventColor.RESET) + const containsResourceType = + colorizedResource.includes(resourceType) + const containsResourceId = colorizedResource.includes(resourceId) + const containsSlash = colorizedResource.includes('/') + + return ( + hasInfoColor && + hasResetCode && + containsResourceType && + containsResourceId && + containsSlash + ) + } + ), + { numRuns: 5 } + ) + }) + + /** + * Property test for error message colorization + */ + it('should apply bold red formatting to all error messages', () => { + const errorMessageArb = fc.string({ minLength: 1, maxLength: 100 }) + const enableColorsArb = fc.boolean() + + fc.assert( + fc.property( + errorMessageArb, + enableColorsArb, + (errorMessage: string, enableColors: boolean) => { + const formatter = new ColorFormatterImpl(enableColors) + + const colorizedError = formatter.colorizeError(errorMessage) + + if (!enableColors) { + return colorizedError === errorMessage + } + + // Property: Error messages should use bold red formatting + const hasBoldCode = colorizedError.includes('\x1b[1m') + const hasErrorColor = colorizedError.includes(EventColor.ERROR) + const hasResetCode = colorizedError.includes(EventColor.RESET) + const containsOriginalMessage = + colorizedError.includes(errorMessage) + + return ( + hasBoldCode && + hasErrorColor && + hasResetCode && + containsOriginalMessage + ) + } + ), + { numRuns: 5 } + ) + }) + + /** + * Property test for color enable/disable functionality + */ + it('should respect color enable/disable setting for all operations', () => { + const statusArb = fc.constantFrom( + ...(Object.keys(STATUS_COLORS) as ResourceStatus[]) + ) + const textArb = fc.string({ minLength: 1, maxLength: 50 }) + + fc.assert( + fc.property( + statusArb, + textArb, + (status: ResourceStatus, text: string) => { + const formatter = new ColorFormatterImpl(false) // Start with colors disabled + + // Property: When colors disabled, all methods should return plain text + const statusResult = formatter.colorizeStatus(status, text) + const timestampResult = formatter.colorizeTimestamp(text) + const resourceResult = formatter.colorizeResource(text, text) + const errorResult = formatter.colorizeError(text) + + const allPlainWhenDisabled = + statusResult === text && + timestampResult === text && + resourceResult === `${text}/${text}` && + errorResult === text + + if (!allPlainWhenDisabled) { + return false + } + + // Enable colors and test again + formatter.setColorsEnabled(true) + + const statusResultEnabled = formatter.colorizeStatus(status, text) + const timestampResultEnabled = formatter.colorizeTimestamp(text) + const resourceResultEnabled = formatter.colorizeResource(text, text) + const errorResultEnabled = formatter.colorizeError(text) + + // Property: When colors enabled, results should contain ANSI codes + const allColorizedWhenEnabled = + statusResultEnabled.includes('\x1b[') && + timestampResultEnabled.includes('\x1b[') && + resourceResultEnabled.includes('\x1b[') && + errorResultEnabled.includes('\x1b[') + + return allColorizedWhenEnabled + } + ), + { numRuns: 5 } + ) + }) + }) + + describe('Property 10: Exponential Backoff Polling', () => { + /** + * **Feature: cloudformation-event-streaming, Property 10: Exponential Backoff Polling** + * For any event polling session, the polling intervals should follow exponential backoff + * starting at 2 seconds, increasing when no new events are available, up to a maximum of 30 seconds. + * **Validates: Requirements 5.1, 5.3** + */ + it('should implement exponential backoff correctly for all initial intervals', () => { + // Generator for initial intervals (reasonable range) + const initialIntervalArb = fc.integer({ min: 500, max: 5000 }) + + // Generator for maximum intervals (must be >= initial) + const maxIntervalArb = fc.integer({ min: 10000, max: 60000 }) + + fc.assert( + fc.property( + initialIntervalArb, + maxIntervalArb, + (initialInterval: number, maxInterval: number) => { + // Ensure max >= initial for valid test + const actualMaxInterval = Math.max(maxInterval, initialInterval * 2) + + const mockClient = { send: jest.fn() } + const poller = new EventPollerImpl( + mockClient as any, + 'test-stack', + initialInterval, + actualMaxInterval + ) + + // Property: Initial interval should be set correctly + if (poller.getCurrentInterval() !== initialInterval) { + return false + } + + // Property: Exponential backoff should increase interval by factor of 1.5 + const originalInterval = poller.getCurrentInterval() + poller['increaseInterval']() + const newInterval = poller.getCurrentInterval() + + const expectedInterval = Math.min( + originalInterval * 1.5, + actualMaxInterval + ) + if (Math.abs(newInterval - expectedInterval) > 0.1) { + return false + } + + // Property: Should not exceed maximum interval + if (newInterval > actualMaxInterval) { + return false + } + + // Property: Reset should return to initial interval + poller.resetInterval() + if (poller.getCurrentInterval() !== initialInterval) { + return false + } + + // Property: Multiple increases should eventually reach max + let currentInterval = initialInterval + for (let i = 0; i < 20; i++) { + poller['increaseInterval']() + currentInterval = poller.getCurrentInterval() + if (currentInterval >= actualMaxInterval) { + break + } + } + + // Should reach max interval within reasonable iterations + return currentInterval === actualMaxInterval + } + ), + { numRuns: 5 } + ) + }) + + /** + * Property test for backoff behavior with no events + */ + it('should increase intervals when no events are found', async () => { + const configArb = fc.record({ + initialInterval: fc.integer({ min: 1000, max: 3000 }), + maxInterval: fc.integer({ min: 10000, max: 30000 }) + }) + + await fc.assert( + fc.asyncProperty(configArb, async config => { + const mockClient = { send: jest.fn() } + mockClient.send.mockResolvedValue({ StackEvents: [] }) + + const poller = new EventPollerImpl( + mockClient as any, + 'test-stack', + config.initialInterval, + config.maxInterval + ) + + const initialInterval = poller.getCurrentInterval() + + // Poll with no events should increase interval + await poller.pollEvents() + const newInterval = poller.getCurrentInterval() + + // Property: Interval should increase when no events found + return newInterval > initialInterval + }), + { numRuns: 3 } + ) + }) + }) + + describe('Property 11: API Throttling Handling', () => { + /** + * **Feature: cloudformation-event-streaming, Property 11: API Throttling Handling** + * For any API throttling response from CloudFormation, the event monitor should respect + * rate limits and retry with appropriate backoff. + * **Validates: Requirements 5.2** + */ + it('should handle throttling exceptions with proper backoff', async () => { + const configArb = fc.record({ + initialInterval: fc.integer({ min: 1000, max: 5000 }), + maxInterval: fc.integer({ min: 10000, max: 60000 }) + }) + + await fc.assert( + fc.asyncProperty(configArb, async config => { + const mockClient = { send: jest.fn() } + const throttlingError = new Error('Rate exceeded') + throttlingError.name = 'ThrottlingException' + + mockClient.send.mockRejectedValue(throttlingError) + + const poller = new EventPollerImpl( + mockClient as any, + 'test-stack', + config.initialInterval, + config.maxInterval + ) + + const initialInterval = poller.getCurrentInterval() + + try { + await poller.pollEvents() + // Should not reach here - exception should be thrown + return false + } catch (error) { + // Property: Should re-throw the throttling exception + if ( + !(error instanceof Error && error.name === 'ThrottlingException') + ) { + return false + } + + // Property: Should double the interval on throttling + const newInterval = poller.getCurrentInterval() + const expectedInterval = Math.min( + initialInterval * 2, + config.maxInterval + ) + + return Math.abs(newInterval - expectedInterval) < 0.1 + } + }), + { numRuns: 3 } + ) + }) + + /** + * Property test for non-throttling error handling + */ + it('should re-throw non-throttling errors without changing interval', async () => { + const configArb = fc.record({ + initialInterval: fc.integer({ min: 1000, max: 5000 }), + maxInterval: fc.integer({ min: 10000, max: 60000 }) + }) + + const errorMessageArb = fc.string({ minLength: 1, maxLength: 100 }) + + await fc.assert( + fc.asyncProperty( + configArb, + errorMessageArb, + async (config, errorMessage) => { + const mockClient = { send: jest.fn() } + const genericError = new Error(errorMessage) + + mockClient.send.mockRejectedValue(genericError) + + const poller = new EventPollerImpl( + mockClient as any, + 'test-stack', + config.initialInterval, + config.maxInterval + ) + + const initialInterval = poller.getCurrentInterval() + + try { + await poller.pollEvents() + // Should not reach here - exception should be thrown + return false + } catch (error) { + // Property: Should re-throw the original error + if (error !== genericError) { + return false + } + + // Property: Should not change interval for non-throttling errors + const newInterval = poller.getCurrentInterval() + return newInterval === initialInterval + } + } + ), + { numRuns: 3 } + ) + }) + }) + + /** + * Property 5: Error Message Extraction and Formatting + * **Feature: cloudformation-event-streaming, Property 5: Error Message Extraction and Formatting** + * For any stack event that contains an error, the system should extract the StatusReason field + * and display it with bold red formatting, with multiple errors clearly separated. + * **Validates: Requirements 3.1, 3.2, 3.3** + */ + describe('Property 5: Error Message Extraction and Formatting', () => { + it('should extract and format error messages correctly for all error events', () => { + // Generator for error status patterns + const errorStatusArb = fc.constantFrom( + 'CREATE_FAILED', + 'UPDATE_FAILED', + 'DELETE_FAILED', + 'UPDATE_ROLLBACK_FAILED', + 'CREATE_ROLLBACK_FAILED', + 'UPDATE_ROLLBACK_IN_PROGRESS', + 'CREATE_ROLLBACK_IN_PROGRESS' + ) + + // Generator for error messages (StatusReason) + const errorMessageArb = fc.string({ minLength: 1, maxLength: 500 }) + + // Generator for resource information + const resourceTypeArb = fc.constantFrom( + 'AWS::S3::Bucket', + 'AWS::EC2::Instance', + 'AWS::Lambda::Function', + 'AWS::DynamoDB::Table' + ) + + const logicalResourceIdArb = fc + .string({ minLength: 1, maxLength: 255 }) + .filter(s => s.trim().length > 0) + + // Generator for error events + const errorEventArb = fc.record({ + Timestamp: fc.option( + fc.date({ min: new Date('2020-01-01'), max: new Date('2030-12-31') }), + { nil: undefined } + ), + LogicalResourceId: fc.option(logicalResourceIdArb, { nil: undefined }), + ResourceType: fc.option(resourceTypeArb, { nil: undefined }), + ResourceStatus: errorStatusArb, + ResourceStatusReason: fc.option(errorMessageArb, { nil: undefined }), + PhysicalResourceId: fc.option( + fc.string({ minLength: 1, maxLength: 1024 }), + { nil: undefined } + ) + }) + + fc.assert( + fc.property(errorEventArb, (event: StackEvent) => { + const colorFormatter = new ColorFormatterImpl(true) + const errorExtractor = new ErrorExtractorImpl(colorFormatter) + + // Property: Should identify error events correctly (Requirement 3.1) + const isError = errorExtractor.isErrorEvent(event) + if (!isError) { + return false // All generated events should be errors + } + + // Property: Should extract error information (Requirement 3.1) + const extractedError = errorExtractor.extractError(event) + if (!extractedError) { + return false // Should extract error from error events + } + + // Property: Should extract StatusReason field (Requirement 3.1) + const expectedMessage = + event.ResourceStatusReason || 'Unknown error occurred' + if (extractedError.message !== expectedMessage) { + return false + } + + // Property: Should format with bold red formatting (Requirement 3.2) + const formattedMessage = + errorExtractor.formatErrorMessage(extractedError) + + // Should contain ANSI bold red codes + const hasBoldRed = formattedMessage.includes('\x1b[1m\x1b[31m') + if (!hasBoldRed) { + return false + } + + // Should contain the error message + if (!formattedMessage.includes(extractedError.message)) { + return false + } + + // Should contain ERROR: prefix + if (!formattedMessage.includes('ERROR:')) { + return false + } + + return true + }), + { numRuns: 5 } + ) + }) + + it('should handle multiple errors with clear separation', () => { + // Generator for arrays of error events + const errorEventArb = fc.record({ + Timestamp: fc.date({ + min: new Date('2020-01-01'), + max: new Date('2030-12-31') + }), + LogicalResourceId: fc + .string({ minLength: 1, maxLength: 255 }) + .filter(s => s.trim().length > 0), + ResourceType: fc.constantFrom( + 'AWS::S3::Bucket', + 'AWS::EC2::Instance', + 'AWS::Lambda::Function' + ), + ResourceStatus: fc.constantFrom( + 'CREATE_FAILED', + 'UPDATE_FAILED', + 'DELETE_FAILED' + ), + ResourceStatusReason: fc.string({ minLength: 1, maxLength: 200 }) + }) + + const multipleErrorsArb = fc.array(errorEventArb, { + minLength: 2, + maxLength: 5 + }) + + fc.assert( + fc.property(multipleErrorsArb, (events: StackEvent[]) => { + const colorFormatter = new ColorFormatterImpl(true) + const errorExtractor = new ErrorExtractorImpl(colorFormatter) + + // Extract all errors + const errors = errorExtractor.extractAllErrors(events) + + // Property: Should extract all error events + if (errors.length !== events.length) { + return false + } + + // Property: Multiple errors should be clearly separated (Requirement 3.3) + const formattedMessage = errorExtractor.formatMultipleErrors(errors) + + if (errors.length > 1) { + // Should contain numbered separators [1], [2], etc. + for (let i = 1; i <= errors.length; i++) { + if (!formattedMessage.includes(`[${i}]`)) { + return false + } + } + + // Should contain newlines for separation + if (!formattedMessage.includes('\n')) { + return false + } + } + + // Each error message should be present + for (const error of errors) { + if (!formattedMessage.includes(error.message)) { + return false + } + } + + return true + }), + { numRuns: 3 } + ) + }) + }) + + /** + * Property 6: Complete Error Message Display + * **Feature: cloudformation-event-streaming, Property 6: Complete Error Message Display** + * For any error message that appears truncated, if the full message is available in the event details, + * the system should display the complete message. + * **Validates: Requirements 3.4** + */ + describe('Property 6: Complete Error Message Display', () => { + it('should handle truncated messages and attempt to display complete information', () => { + // Generator for potentially truncated messages + const truncatedMessageArb = fc.oneof( + // Regular messages + fc.string({ minLength: 1, maxLength: 200 }), + // Messages with truncation indicators + fc.string({ minLength: 1, maxLength: 100 }).map(s => s + '...'), + fc + .string({ minLength: 1, maxLength: 100 }) + .map(s => s + ' (truncated)'), + fc.string({ minLength: 1, maxLength: 100 }).map(s => s + ' [truncated]') + ) + + const errorEventArb = fc.record({ + Timestamp: fc.date({ + min: new Date('2020-01-01'), + max: new Date('2030-12-31') + }), + LogicalResourceId: fc + .string({ minLength: 1, maxLength: 255 }) + .filter(s => s.trim().length > 0), + ResourceType: fc.constantFrom( + 'AWS::S3::Bucket', + 'AWS::EC2::Instance', + 'AWS::Lambda::Function' + ), + ResourceStatus: fc.constantFrom( + 'CREATE_FAILED', + 'UPDATE_FAILED', + 'DELETE_FAILED' + ), + ResourceStatusReason: truncatedMessageArb + }) + + fc.assert( + fc.property(errorEventArb, (event: StackEvent) => { + const colorFormatter = new ColorFormatterImpl(true) + const errorExtractor = new ErrorExtractorImpl(colorFormatter) + + const extractedError = errorExtractor.extractError(event) + if (!extractedError) { + return false + } + + // Property: Should handle truncated messages (Requirement 3.4) + const formattedMessage = + errorExtractor.formatErrorMessage(extractedError) + + // The formatted message should contain the original message + // (even if truncated, it should be preserved as-is for now) + if (!formattedMessage.includes(extractedError.message)) { + return false + } + + // Should still apply proper formatting + if (!formattedMessage.includes('ERROR:')) { + return false + } + + // Should contain ANSI formatting codes + if (!formattedMessage.includes('\x1b[')) { + return false + } + + return true + }), + { numRuns: 5 } + ) + }) + }) +}) + +/** + * Property 8: Resource Name Truncation + * **Feature: cloudformation-event-streaming, Property 8: Resource Name Truncation** + * For any stack event with a resource name longer than the maximum display length, + * the system should truncate the name while maintaining readability. + * **Validates: Requirements 4.3** + */ +describe('Property 8: Resource Name Truncation', () => { + it('should truncate long resource names while maintaining readability', () => { + // Generator for resource names of various lengths + const shortResourceNameArb = fc.string({ minLength: 1, maxLength: 30 }) + const longResourceNameArb = fc.string({ minLength: 51, maxLength: 200 }) + const resourceNameArb = fc.oneof(shortResourceNameArb, longResourceNameArb) + + // Generator for max length configurations + const maxLengthArb = fc.integer({ min: 10, max: 100 }) + + // Generator for resource types + const resourceTypeArb = fc.constantFrom( + 'AWS::S3::Bucket', + 'AWS::EC2::Instance', + 'AWS::Lambda::Function', + 'AWS::DynamoDB::Table', + 'AWS::IAM::Role' + ) + + fc.assert( + fc.property( + resourceNameArb, + resourceTypeArb, + maxLengthArb, + (resourceName: string, resourceType: string, maxLength: number) => { + const colorFormatter = new ColorFormatterImpl(false) // Disable colors for easier testing + const errorExtractor = new ErrorExtractorImpl(colorFormatter) + + const eventFormatter = new EventFormatterImpl( + colorFormatter, + errorExtractor, + { maxResourceNameLength: maxLength } + ) + + const event: StackEvent = { + Timestamp: new Date(), + LogicalResourceId: resourceName, + ResourceType: resourceType, + ResourceStatus: 'CREATE_IN_PROGRESS', + ResourceStatusReason: undefined, + PhysicalResourceId: undefined + } + + const formattedEvent = eventFormatter.formatEvent(event) + + // Property: Resource names should be truncated if they exceed maxLength + if (resourceName.length <= maxLength) { + // Short names should not be truncated + if (!formattedEvent.resourceInfo.includes(resourceName)) { + return false + } + } else { + // Long names should be truncated with ellipsis + if (formattedEvent.resourceInfo.includes(resourceName)) { + return false // Should not contain the full long name + } + + // Should contain ellipsis for truncated names + if (!formattedEvent.resourceInfo.includes('...')) { + return false + } + + // The truncated part should not exceed maxLength when considering ellipsis + // Extract the logical ID part from "ResourceType/LogicalId" format + const parts = formattedEvent.resourceInfo.split('/') + if (parts.length >= 2) { + const truncatedLogicalId = parts[1] + if (truncatedLogicalId.length > maxLength) { + return false + } + } + } + + // Property: Should maintain resource type in the output + if (!formattedEvent.resourceInfo.includes(resourceType)) { + return false + } + + // Property: Should maintain the "ResourceType/LogicalId" format + if (!formattedEvent.resourceInfo.includes('/')) { + return false + } + + return true + } + ), + { numRuns: 5 } + ) + }) + + it('should handle edge cases in resource name truncation', () => { + // Test edge cases + const edgeCaseArb = fc.record({ + resourceName: fc.oneof( + fc.string({ minLength: 0, maxLength: 0 }), // Empty string + fc.string({ minLength: 1, maxLength: 1 }), // Single character + fc.string({ minLength: 1, maxLength: 5 }), // Very short + fc.string({ minLength: 500, maxLength: 1000 }) // Very long + ), + maxLength: fc.integer({ min: 1, max: 10 }) // Small max lengths + }) + + fc.assert( + fc.property(edgeCaseArb, ({ resourceName, maxLength }) => { + const colorFormatter = new ColorFormatterImpl(false) + const errorExtractor = new ErrorExtractorImpl(colorFormatter) + + const eventFormatter = new EventFormatterImpl( + colorFormatter, + errorExtractor, + { maxResourceNameLength: maxLength } + ) + + const event: StackEvent = { + Timestamp: new Date(), + LogicalResourceId: resourceName, + ResourceType: 'AWS::S3::Bucket', + ResourceStatus: 'CREATE_IN_PROGRESS' + } + + const formattedEvent = eventFormatter.formatEvent(event) + + // Property: Should always produce valid output even for edge cases + if ( + !formattedEvent.resourceInfo || + formattedEvent.resourceInfo.length === 0 + ) { + return false + } + + // Property: Should handle empty resource names gracefully + if (resourceName === '') { + // Should use some default or handle gracefully + return formattedEvent.resourceInfo.includes('AWS::S3::Bucket') + } + + // Property: Very small maxLength should still produce readable output + if (maxLength <= 3) { + // Should at least show ellipsis if truncation is needed + if (resourceName.length > maxLength) { + return formattedEvent.resourceInfo.includes('...') + } + } + + return true + }), + { numRuns: 5 } + ) + }) +}) + +/** + * Property 9: Nested Resource Indentation + * **Feature: cloudformation-event-streaming, Property 9: Nested Resource Indentation** + * For any stack events representing nested resources, child resource events should be + * indented appropriately to show hierarchy. + * **Validates: Requirements 4.4** + */ +describe('Property 9: Nested Resource Indentation', () => { + it('should indent nested resources based on hierarchy indicators', () => { + // Generator for logical resource IDs with different nesting patterns + const nestedResourceIdArb = fc.oneof( + // Simple resource names (no nesting) + fc.string({ minLength: 1, maxLength: 20 }).filter(s => !s.includes('.')), + // Nested with dots (e.g., "MyStack.NestedStack.Resource") + fc + .tuple( + fc.string({ minLength: 1, maxLength: 10 }), + fc.string({ minLength: 1, maxLength: 10 }), + fc.string({ minLength: 1, maxLength: 10 }) + ) + .map(([a, b, c]) => `${a}.${b}.${c}`), + // Resources with "Nested" prefix + fc.string({ minLength: 1, maxLength: 15 }).map(s => `Nested${s}`), + // Resources with "Child" prefix + fc.string({ minLength: 1, maxLength: 15 }).map(s => `Child${s}`) + ) + + // Generator for resource types that might be nested + const resourceTypeArb = fc.constantFrom( + // Nested stack types + 'AWS::CloudFormation::Stack', + // Regular resource types + 'AWS::S3::Bucket', + 'AWS::EC2::Instance', + 'AWS::Lambda::Function', + 'AWS::IAM::Role', + 'AWS::IAM::Policy' + ) + + // Generator for base indentation levels + const baseIndentArb = fc.integer({ min: 0, max: 3 }) + + fc.assert( + fc.property( + nestedResourceIdArb, + resourceTypeArb, + baseIndentArb, + ( + logicalResourceId: string, + resourceType: string, + baseIndent: number + ) => { + const colorFormatter = new ColorFormatterImpl(false) // Disable colors for easier testing + const errorExtractor = new ErrorExtractorImpl(colorFormatter) + + const eventFormatter = new EventFormatterImpl( + colorFormatter, + errorExtractor, + { indentLevel: baseIndent } + ) + + const event: StackEvent = { + Timestamp: new Date(), + LogicalResourceId: logicalResourceId, + ResourceType: resourceType, + ResourceStatus: 'CREATE_IN_PROGRESS' + } + + const formattedEvents = eventFormatter.formatEvents([event]) + + // Property: Indentation should be based on nesting indicators + const expectedIndentLevel = calculateExpectedIndentLevel( + logicalResourceId, + resourceType, + baseIndent + ) + + if (expectedIndentLevel === 0) { + // No indentation expected - should not start with spaces + if (formattedEvents.startsWith(' ')) { + return false + } + } else { + // Should have appropriate indentation (2 spaces per level) + const expectedSpaces = ' '.repeat(expectedIndentLevel) + if (!formattedEvents.startsWith(expectedSpaces)) { + return false + } + + // Should not have more indentation than expected + const tooManySpaces = ' '.repeat(expectedIndentLevel + 1) + if (formattedEvents.startsWith(tooManySpaces)) { + return false + } + } + + // Property: Should still contain the resource information + if (!formattedEvents.includes(logicalResourceId)) { + return false + } + + if (!formattedEvents.includes(resourceType)) { + return false + } + + return true + } + ), + { numRuns: 5 } + ) + }) + + it('should handle multiple nested resources with consistent indentation', () => { + // Generator for arrays of events with different nesting levels + const nestedEventsArb = fc.array( + fc.record({ + logicalResourceId: fc.oneof( + fc.string({ minLength: 1, maxLength: 10 }), // Simple + fc + .tuple( + fc.string({ minLength: 1, maxLength: 5 }), + fc.string({ minLength: 1, maxLength: 5 }) + ) + .map(([a, b]) => `${a}.${b}`), // One level nested + fc + .tuple( + fc.string({ minLength: 1, maxLength: 5 }), + fc.string({ minLength: 1, maxLength: 5 }), + fc.string({ minLength: 1, maxLength: 5 }) + ) + .map(([a, b, c]) => `${a}.${b}.${c}`) // Two levels nested + ), + resourceType: fc.constantFrom( + 'AWS::S3::Bucket', + 'AWS::CloudFormation::Stack', + 'AWS::Lambda::Function' + ) + }), + { minLength: 2, maxLength: 5 } + ) + + fc.assert( + fc.property(nestedEventsArb, eventConfigs => { + const colorFormatter = new ColorFormatterImpl(false) + const errorExtractor = new ErrorExtractorImpl(colorFormatter) + const eventFormatter = new EventFormatterImpl( + colorFormatter, + errorExtractor + ) + + const events: StackEvent[] = eventConfigs.map(config => ({ + Timestamp: new Date(), + LogicalResourceId: config.logicalResourceId, + ResourceType: config.resourceType, + ResourceStatus: 'CREATE_IN_PROGRESS' + })) + + const formattedEvents = eventFormatter.formatEvents(events) + const lines = formattedEvents.split('\n') + + // Property: Each line should have consistent indentation based on its nesting level + for (let i = 0; i < lines.length; i++) { + const line = lines[i] + const event = events[i] + + if (!event || !line) continue + + const expectedIndentLevel = calculateExpectedIndentLevel( + event.LogicalResourceId || '', + event.ResourceType || '', + 0 + ) + + // Count leading spaces + const leadingSpaces = line.match(/^( *)/)?.[1]?.length || 0 + const actualIndentLevel = leadingSpaces / 2 + + // Property: Actual indentation should match expected + if (Math.abs(actualIndentLevel - expectedIndentLevel) > 0.5) { + return false + } + } + + return true + }), + { numRuns: 3 } + ) + }) + + it('should handle edge cases in resource indentation', () => { + // Test edge cases for indentation + const edgeCaseArb = fc.record({ + logicalResourceId: fc.oneof( + fc.string({ minLength: 0, maxLength: 0 }), // Empty string + fc.string({ minLength: 1, maxLength: 1 }).map(() => '.'), // Just a dot + fc.string({ minLength: 3, maxLength: 3 }).map(() => '...'), // Multiple dots + fc.string({ minLength: 1, maxLength: 5 }).map(s => `.${s}`), // Starting with dot + fc.string({ minLength: 1, maxLength: 5 }).map(s => `${s}.`) // Ending with dot + ), + resourceType: fc.constantFrom( + 'AWS::S3::Bucket', + 'AWS::CloudFormation::Stack' + ), + baseIndent: fc.integer({ min: 0, max: 5 }) + }) + + fc.assert( + fc.property( + edgeCaseArb, + ({ logicalResourceId, resourceType, baseIndent }) => { + const colorFormatter = new ColorFormatterImpl(false) + const errorExtractor = new ErrorExtractorImpl(colorFormatter) + const eventFormatter = new EventFormatterImpl( + colorFormatter, + errorExtractor, + { indentLevel: baseIndent } + ) + + const event: StackEvent = { + Timestamp: new Date(), + LogicalResourceId: logicalResourceId as string, + ResourceType: resourceType, + ResourceStatus: 'CREATE_IN_PROGRESS' + } + + const formattedEvents = eventFormatter.formatEvents([event]) + + // Property: Should handle edge cases gracefully without crashing + if (!formattedEvents || formattedEvents.length === 0) { + return false + } + + // Property: Should not have excessive indentation (max reasonable level) + const maxReasonableSpaces = ' '.repeat(10) // 10 levels max + if (formattedEvents.startsWith(maxReasonableSpaces + ' ')) { + return false + } + + // Property: Should contain some recognizable content + if (resourceType && !formattedEvents.includes(resourceType)) { + return false + } + + return true + } + ), + { numRuns: 5 } + ) + }) +}) + +// Helper function to calculate expected indent level based on simplified logic +function calculateExpectedIndentLevel( + logicalResourceId: string, + resourceType: string, + baseIndent: number +): number { + // Simplified logic: always return the base indent level + // This ensures consistent formatting across all event types + return Math.max(0, baseIndent) +} + +/** + * EventMonitor Property Tests + * Tests for the main orchestrator class that manages event streaming lifecycle + */ +describe('EventMonitor Property Tests', () => { + /** + * Property 1: Event Monitor Lifecycle + * **Feature: cloudformation-event-streaming, Property 1: Event Monitor Lifecycle** + * For any stack deployment, when the deployment begins, event monitoring should start immediately + * and continue until the stack reaches a terminal state, then stop immediately. + * **Validates: Requirements 1.1, 1.3, 5.4** + */ + describe('Property 1: Event Monitor Lifecycle', () => { + it('should start monitoring immediately and continue until terminal state', () => { + // Generator for stack names + const stackNameArb = fc + .string({ minLength: 1, maxLength: 128 }) + .filter(s => s.trim().length > 0) + + // Generator for polling intervals + const pollIntervalArb = fc.integer({ min: 1000, max: 5000 }) + const maxPollIntervalArb = fc.integer({ min: 10000, max: 60000 }) + + // Generator for EventMonitorConfig + const configArb = fc.record({ + stackName: stackNameArb, + enableColors: fc.boolean(), + pollIntervalMs: pollIntervalArb, + maxPollIntervalMs: maxPollIntervalArb + }) + + fc.assert( + fc.asyncProperty(configArb, async config => { + // Create a mock CloudFormation client that returns empty events + const mockClient = { + send: jest.fn().mockResolvedValue({ StackEvents: [] }) + } as any + + const fullConfig: EventMonitorConfig = { + ...config, + client: mockClient + } + + const eventMonitor = new EventMonitorImpl(fullConfig) + + // Property: Initially should not be monitoring (Requirement 1.1) + if (eventMonitor.isMonitoring()) { + return false + } + + // Property: Should be able to start monitoring (Requirement 1.1) + const startPromise = eventMonitor.startMonitoring() + + // Give it a moment to start + await new Promise(resolve => setTimeout(resolve, 10)) + + // Property: Should be monitoring after start (Requirement 1.1) + if (!eventMonitor.isMonitoring()) { + eventMonitor.stopMonitoring() + return false + } + + // Property: Should stop monitoring when requested (Requirement 1.3, 5.4) + eventMonitor.stopMonitoring() + + // Give it a moment to stop + await new Promise(resolve => setTimeout(resolve, 10)) + + // Property: Should not be monitoring after stop (Requirement 1.3, 5.4) + if (eventMonitor.isMonitoring()) { + return false + } + + // Wait for the start promise to complete (with timeout to prevent hanging) + try { + await Promise.race([ + startPromise, + new Promise((_, reject) => + setTimeout(() => reject(new Error('Test timeout')), 1000) + ) + ]) + } catch { + // Expected to fail due to mock client or timeout, but lifecycle should still work + } + + return true + }), + { numRuns: 3, timeout: 3000 } // Reduced runs and timeout for faster execution + ) + }) + + it('should handle multiple start/stop cycles correctly', () => { + const stackNameArb = fc + .string({ minLength: 1, maxLength: 128 }) + .filter(s => s.trim().length > 0) + + fc.assert( + fc.asyncProperty(stackNameArb, async stackName => { + const mockClient = { + send: jest.fn().mockResolvedValue({ StackEvents: [] }) + } as any + + const config: EventMonitorConfig = { + stackName, + client: mockClient, + enableColors: true, + pollIntervalMs: 2000, + maxPollIntervalMs: 30000 + } + + const eventMonitor = new EventMonitorImpl(config) + + // Property: Multiple start/stop cycles should work correctly + for (let i = 0; i < 3; i++) { + // Should not be monitoring initially + if (eventMonitor.isMonitoring()) { + return false + } + + // Start monitoring + const startPromise = eventMonitor.startMonitoring() + await new Promise(resolve => setTimeout(resolve, 10)) + + // Should be monitoring + if (!eventMonitor.isMonitoring()) { + eventMonitor.stopMonitoring() + return false + } + + // Stop monitoring + eventMonitor.stopMonitoring() + await new Promise(resolve => setTimeout(resolve, 10)) + + // Should not be monitoring + if (eventMonitor.isMonitoring()) { + return false + } + + try { + await Promise.race([ + startPromise, + new Promise((_, reject) => + setTimeout(() => reject(new Error('Test timeout')), 500) + ) + ]) + } catch { + // Expected due to mock client or timeout + } + } + + return true + }), + { numRuns: 5, timeout: 8000 } // Reduced runs for faster execution + ) + }) + }) + + /** + * Property 2: Event Display Timeliness + * **Feature: cloudformation-event-streaming, Property 2: Event Display Timeliness** + * For any new stack events that become available, they should be displayed within 5 seconds + * of being available from the CloudFormation API. + * **Validates: Requirements 1.2** + */ + describe('Property 2: Event Display Timeliness', () => { + it('should display events within 5 seconds of availability', () => { + // This property test focuses on the timing constraint + // We test that the polling interval and display logic meet the 5-second requirement + + const pollIntervalArb = fc.integer({ min: 1000, max: 4000 }) // Max 4 seconds to ensure < 5 second total + + fc.assert( + fc.asyncProperty(pollIntervalArb, async pollInterval => { + const mockClient = { + send: jest.fn().mockResolvedValue({ + StackEvents: [ + { + Timestamp: new Date(), + LogicalResourceId: 'TestResource', + ResourceType: 'AWS::S3::Bucket', + ResourceStatus: 'CREATE_IN_PROGRESS' + } + ] + }) + } as any + + const config: EventMonitorConfig = { + stackName: 'test-stack', + client: mockClient, + enableColors: false, + pollIntervalMs: pollInterval, + maxPollIntervalMs: 30000 + } + + const eventMonitor = new EventMonitorImpl(config) + + // Property: Polling interval should be <= 4000ms to meet 5-second requirement + // (allowing 1 second for processing and display) + if (pollInterval > 4000) { + return false + } + + // Property: The monitor should be configured with the correct interval + const stats = eventMonitor.getStats() + if (stats.isActive) { + return false // Should not be active initially + } + + // Start monitoring briefly to test timing + const startTime = Date.now() + const startPromise = eventMonitor.startMonitoring() + + // Wait for one polling cycle plus processing time + await new Promise(resolve => + setTimeout(resolve, Math.min(pollInterval + 500, 2000)) + ) + + eventMonitor.stopMonitoring() + + const endTime = Date.now() + const totalTime = endTime - startTime + + // Property: Total time for one cycle should be reasonable (< 5 seconds) + if (totalTime > 5000) { + return false + } + + try { + await Promise.race([ + startPromise, + new Promise((_, reject) => + setTimeout(() => reject(new Error('Test timeout')), 1000) + ) + ]) + } catch { + // Expected due to mock setup or timeout + } + + return true + }), + { numRuns: 5, timeout: 8000 } // Reduced runs for faster execution + ) + }) + + it('should maintain timeliness under different polling scenarios', () => { + // Test various polling configurations to ensure timeliness + const configArb = fc.record({ + pollIntervalMs: fc.integer({ min: 500, max: 3000 }), + maxPollIntervalMs: fc.integer({ min: 5000, max: 30000 }) + }) + + fc.assert( + fc.asyncProperty(configArb, async configParams => { + const mockClient = { + send: jest.fn().mockResolvedValue({ StackEvents: [] }) + } as any + + const config: EventMonitorConfig = { + stackName: 'test-stack', + client: mockClient, + enableColors: false, + ...configParams + } + + const eventMonitor = new EventMonitorImpl(config) + + // Property: Initial polling interval should meet timeliness requirement + if (config.pollIntervalMs > 5000) { + return false + } + + // Property: Even with exponential backoff, we should not exceed reasonable limits + // that would violate the 5-second timeliness requirement for new events + if (config.maxPollIntervalMs > 30000) { + return false + } + + // Test that the monitor can be started and stopped + let startPromise: Promise | null = null + + try { + startPromise = eventMonitor.startMonitoring() + + // Give more time for the monitor to initialize properly + await new Promise(resolve => setTimeout(resolve, 200)) + + // The monitor should be active after initialization + // Note: We don't strictly require isMonitoring() to be true immediately + // as it depends on the internal async initialization + + eventMonitor.stopMonitoring() + + // Wait for the monitoring to stop cleanly + if (startPromise) { + await Promise.race([ + startPromise, + new Promise((_, reject) => + setTimeout(() => reject(new Error('Test timeout')), 2000) + ) + ]) + } + } catch { + // Expected due to mock or timeout - this is acceptable + // The important thing is that the configuration values are valid + } finally { + // Ensure cleanup + try { + eventMonitor.stopMonitoring() + } catch { + // Ignore cleanup errors + } + } + + return true + }), + { numRuns: 5, timeout: 8000 } // Increased timeout for CI stability + ) + }) + }) + + /** + * Property 3: Deployment Summary Display + * **Feature: cloudformation-event-streaming, Property 3: Deployment Summary Display** + * For any completed stack deployment, a final summary of the deployment result should be + * displayed when the stack reaches a terminal state. + * **Validates: Requirements 1.4** + */ + describe('Property 3: Deployment Summary Display', () => { + it('should display deployment summary when monitoring stops', () => { + const stackNameArb = fc + .string({ minLength: 1, maxLength: 128 }) + .filter(s => s.trim().length > 0) + + fc.assert( + fc.asyncProperty(stackNameArb, async stackName => { + const mockClient = { + send: jest.fn().mockResolvedValue({ StackEvents: [] }) + } as any + + const config: EventMonitorConfig = { + stackName, + client: mockClient, + enableColors: false, + pollIntervalMs: 2000, + maxPollIntervalMs: 30000 + } + + const eventMonitor = new EventMonitorImpl(config) + + // Start monitoring + const startPromise = eventMonitor.startMonitoring() + await new Promise(resolve => setTimeout(resolve, 50)) + + // Get initial stats + const initialStats = eventMonitor.getStats() + + // Property: Should track monitoring state + if (!initialStats.isActive) { + eventMonitor.stopMonitoring() + return false + } + + // Property: Should initialize counters + if (initialStats.eventCount !== 0 || initialStats.errorCount !== 0) { + eventMonitor.stopMonitoring() + return false + } + + // Stop monitoring (this should trigger summary display) + eventMonitor.stopMonitoring() + + // Get final stats + const finalStats = eventMonitor.getStats() + + // Property: Should not be active after stop + if (finalStats.isActive) { + return false + } + + // Property: Should have duration information + if (finalStats.duration === undefined || finalStats.duration < 0) { + return false + } + + // Property: Should maintain event and error counts + if (finalStats.eventCount < 0 || finalStats.errorCount < 0) { + return false + } + + try { + await startPromise + } catch { + // Expected due to mock + } + + return true + }), + { numRuns: 3, timeout: 5000 } + ) + }) + + it('should track events and errors correctly for summary', () => { + // Test that the monitor correctly tracks statistics for the summary + const stackNameArb = fc + .string({ minLength: 1, maxLength: 64 }) + .filter(s => s.trim().length > 0) + + fc.assert( + fc.asyncProperty(stackNameArb, async stackName => { + // Mock events with some errors + const mockEvents = [ + { + Timestamp: new Date(), + LogicalResourceId: 'Resource1', + ResourceType: 'AWS::S3::Bucket', + ResourceStatus: 'CREATE_IN_PROGRESS' + }, + { + Timestamp: new Date(), + LogicalResourceId: 'Resource2', + ResourceType: 'AWS::EC2::Instance', + ResourceStatus: 'CREATE_FAILED', + ResourceStatusReason: 'Test error' + } + ] + + const mockClient = { + send: jest.fn().mockResolvedValue({ StackEvents: mockEvents }) + } as any + + const config: EventMonitorConfig = { + stackName, + client: mockClient, + enableColors: false, + pollIntervalMs: 1000, + maxPollIntervalMs: 30000 + } + + const eventMonitor = new EventMonitorImpl(config) + + // Start monitoring + const startPromise = eventMonitor.startMonitoring() + + // Let it run for a short time to process events + await new Promise(resolve => setTimeout(resolve, 200)) + + // Stop monitoring + eventMonitor.stopMonitoring() + + // Get final stats + const stats = eventMonitor.getStats() + + // Property: Should have processed some events + // Note: Due to the mock setup and timing, we may or may not catch events + // The important property is that the stats are valid + if (stats.eventCount < 0) { + return false + } + + if (stats.errorCount < 0) { + return false + } + + // Property: Error count should not exceed event count + if (stats.errorCount > stats.eventCount) { + return false + } + + // Property: Should have valid duration + if (stats.duration === undefined || stats.duration < 0) { + return false + } + + try { + await startPromise + } catch { + // Expected due to mock + } + + return true + }), + { numRuns: 3, timeout: 5000 } + ) + }) + + it('should format deployment summary with all required information', () => { + // Test the formatDeploymentSummary method directly + const stackNameArb = fc + .string({ minLength: 1, maxLength: 128 }) + .filter(s => s.trim().length > 0) + + const finalStatusArb = fc.constantFrom( + 'CREATE_COMPLETE', + 'UPDATE_COMPLETE', + 'DELETE_COMPLETE', + 'CREATE_FAILED', + 'UPDATE_FAILED', + 'DELETE_FAILED', + 'UPDATE_ROLLBACK_COMPLETE', + 'CREATE_ROLLBACK_COMPLETE' + ) + + const eventCountArb = fc.integer({ min: 0, max: 1000 }) + const errorCountArb = fc.integer({ min: 0, max: 100 }) + const durationArb = fc.option(fc.integer({ min: 1000, max: 3600000 }), { + nil: undefined + }) + + fc.assert( + fc.property( + stackNameArb, + finalStatusArb, + eventCountArb, + errorCountArb, + durationArb, + ( + stackName: string, + finalStatus: string, + totalEvents: number, + errorCount: number, + duration: number | undefined + ) => { + // Ensure error count doesn't exceed total events + const validErrorCount = Math.min(errorCount, totalEvents) + + const colorFormatter = new ColorFormatterImpl(false) // Disable colors for easier testing + const errorExtractor = new ErrorExtractorImpl(colorFormatter) + const eventFormatter = new EventFormatterImpl( + colorFormatter, + errorExtractor + ) + + // Property: formatDeploymentSummary should produce valid summary + const summary = eventFormatter.formatDeploymentSummary( + stackName, + finalStatus, + totalEvents, + validErrorCount, + duration + ) + + // Property: Summary should contain stack name + if (!summary.includes(stackName)) { + return false + } + + // Property: Summary should contain final status + if (!summary.includes(finalStatus)) { + return false + } + + // Property: Summary should contain total events count + if (!summary.includes(`Total Events: ${totalEvents}`)) { + return false + } + + // Property: Summary should contain error information + if (validErrorCount > 0) { + if (!summary.includes(`${validErrorCount} error(s)`)) { + return false + } + } else { + if (!summary.includes('No errors')) { + return false + } + } + + // Property: Summary should contain duration if provided + if (duration !== undefined) { + const durationInSeconds = Math.round(duration / 1000) + if (!summary.includes(`Duration: ${durationInSeconds}s`)) { + return false + } + } + + // Property: Summary should have proper structure with separators + if (!summary.includes('='.repeat(60))) { + return false + } + + if (!summary.includes('Deployment Summary for')) { + return false + } + + if (!summary.includes('Final Status:')) { + return false + } + + // Property: Summary should start and end with empty lines for proper formatting + const lines = summary.split('\n') + if (lines.length < 5) { + return false // Should have multiple lines + } + + // Should start with empty line + if (lines[0] !== '') { + return false + } + + // Should end with empty line + if (lines[lines.length - 1] !== '') { + return false + } + + return true + } + ), + { numRuns: 5 } + ) + }) + + it('should handle edge cases in deployment summary formatting', () => { + // Test edge cases for deployment summary + const edgeCaseArb = fc.record({ + stackName: fc.oneof( + fc.string({ minLength: 1, maxLength: 1 }), // Very short name + fc.string({ minLength: 100, maxLength: 255 }), // Very long name + fc + .string({ minLength: 1, maxLength: 50 }) + .map(s => s + '-'.repeat(20)) // Name with special chars + ), + finalStatus: fc.constantFrom( + 'CREATE_COMPLETE', + 'CREATE_FAILED', + 'UPDATE_ROLLBACK_FAILED' + ), + totalEvents: fc.oneof( + fc.integer({ min: 0, max: 0 }), // No events + fc.integer({ min: 1, max: 1 }), // Single event + fc.integer({ min: 1000, max: 10000 }) // Many events + ), + errorCount: fc.integer({ min: 0, max: 50 }), + duration: fc.option( + fc.oneof( + fc.integer({ min: 500, max: 500 }), // Very short duration + fc.integer({ min: 3600000 * 24, max: 3600000 * 24 }) // Very long duration (24 hours) + ), + { nil: undefined } + ) + }) + + fc.assert( + fc.property(edgeCaseArb, edgeCase => { + // Ensure error count doesn't exceed total events + const validErrorCount = Math.min( + edgeCase.errorCount, + edgeCase.totalEvents + ) + + const colorFormatter = new ColorFormatterImpl(false) + const errorExtractor = new ErrorExtractorImpl(colorFormatter) + const eventFormatter = new EventFormatterImpl( + colorFormatter, + errorExtractor + ) + + const summary = eventFormatter.formatDeploymentSummary( + edgeCase.stackName, + edgeCase.finalStatus, + edgeCase.totalEvents, + validErrorCount, + edgeCase.duration + ) + + // Property: Should handle edge cases gracefully + if (!summary || summary.length === 0) { + return false + } + + // Property: Should contain essential information even in edge cases + if (!summary.includes(edgeCase.stackName)) { + return false + } + + if (!summary.includes(edgeCase.finalStatus)) { + return false + } + + if (!summary.includes(`Total Events: ${edgeCase.totalEvents}`)) { + return false + } + + // Property: Should handle zero events correctly + if (edgeCase.totalEvents === 0) { + if (!summary.includes('Total Events: 0')) { + return false + } + } + + // Property: Should handle very long durations correctly + if (edgeCase.duration !== undefined && edgeCase.duration > 3600000) { + const durationInSeconds = Math.round(edgeCase.duration / 1000) + if (!summary.includes(`Duration: ${durationInSeconds}s`)) { + return false + } + } + + // Property: Should maintain structure even with edge cases + if (!summary.includes('='.repeat(60))) { + return false + } + + return true + }), + { numRuns: 3 } + ) + }) + }) +}) +/** + * Property tests for deployment integration + */ +describe('Deployment Integration Property Tests', () => { + /** + * **Feature: cloudformation-event-streaming, Property 12: Deployment Functionality Preservation** + * For any deployment with event streaming enabled, all existing deployment functionality + * should work exactly as it did without event streaming. + * **Validates: Requirements 6.1** + */ + it('should preserve deployment functionality when event streaming is enabled', async () => { + // Simplified property test that focuses on the core behavior without full event streaming + const deploymentConfigArb = fc.record({ + stackName: fc + .string({ minLength: 1, maxLength: 20 }) + .filter(s => /^[a-zA-Z][a-zA-Z0-9-]*$/.test(s)), + enableEventStreaming: fc.boolean(), + shouldSucceed: fc.boolean() + }) + + await fc.assert( + fc.asyncProperty(deploymentConfigArb, async config => { + // Create a fresh mock client for each test case + const mockClient = { + send: jest.fn() + } as any + + if (config.shouldSucceed) { + // Mock successful deployment - simulate new stack creation + let getStackCallCount = 0 + + mockClient.send.mockImplementation((command: any) => { + // Handle DescribeStacksCommand for getStack + if (command.constructor.name === 'DescribeStacksCommand') { + getStackCallCount++ + + // First call from getStack in deployStack - stack doesn't exist + if ( + getStackCallCount === 1 && + command.input.StackName === config.stackName + ) { + throw new CloudFormationServiceException({ + name: 'ValidationError', + message: `Stack with id ${config.stackName} does not exist`, + $fault: 'client', + $metadata: { + attempts: 1, + cfId: undefined, + extendedRequestId: undefined, + httpStatusCode: 400, + requestId: '00000000-0000-0000-0000-000000000000', + totalRetryDelay: 0 + } + }) + } + + // Subsequent calls (from waiters and event streaming) - stack exists + return Promise.resolve({ + Stacks: [ + { + StackId: `test-stack-id-${config.stackName}`, + StackName: config.stackName, + StackStatus: 'CREATE_COMPLETE' + } + ] + }) + } + + // Handle CreateStackCommand + if (command.constructor.name === 'CreateStackCommand') { + return Promise.resolve({ + StackId: `test-stack-id-${config.stackName}` + }) + } + + // Handle DescribeStackEventsCommand for event streaming + if (command.constructor.name === 'DescribeStackEventsCommand') { + return Promise.resolve({ + StackEvents: [] // Empty events for simplicity + }) + } + + // Default response for other commands + return Promise.resolve({ + Stacks: [ + { + StackId: `test-stack-id-${config.stackName}`, + StackName: config.stackName, + StackStatus: 'CREATE_COMPLETE' + } + ] + }) + }) + } else { + // Mock failed deployment - fail on the first call (getStack) + const error = new Error('Test deployment failure') + mockClient.send.mockRejectedValue(error) + } + + const deploymentParams = { + StackName: config.stackName, + TemplateBody: '{"AWSTemplateFormatVersion": "2010-09-09"}', + Capabilities: [], + Parameters: undefined, + DisableRollback: false, + EnableTerminationProtection: false, + TimeoutInMinutes: undefined, + Tags: undefined + } + + let result: string | undefined + let error: Error | undefined + + try { + result = await deployStack( + mockClient, + deploymentParams, + 'test-changeset', + false, // noEmptyChangeSet + false, // noExecuteChangeSet + false, // noDeleteFailedChangeSet + undefined, // changeSetDescription + config.enableEventStreaming + ) + + // Give event streaming a moment to complete if it was enabled + if (config.enableEventStreaming) { + await new Promise(resolve => setTimeout(resolve, 50)) + } + } catch (err) { + error = err as Error + } + + // Property: Deployment outcome should be consistent regardless of event streaming setting + if (config.shouldSucceed) { + // Should succeed and return a stack ID + if (!result || error) { + // Debug: Log what we got vs what we expected + console.log( + `Expected success but got result=${result}, error=${error?.message}` + ) + return false + } + // Stack ID should contain the stack name + if (!result.includes(config.stackName)) { + console.log( + `Stack ID ${result} should contain stack name ${config.stackName}` + ) + return false + } + } else { + // Should fail with an error + if (result || !error) { + console.log( + `Expected failure but got result=${result}, error=${error?.message}` + ) + return false + } + // Error should be the deployment error, not a streaming error + if (!error.message.includes('Test deployment failure')) { + console.log( + `Error message should contain 'Test deployment failure' but was: ${error.message}` + ) + return false + } + } + + // Property: Event streaming setting should not affect the core deployment logic + // This is validated by the fact that the same mock setup produces the same results + return true + }), + { numRuns: 3, timeout: 5000 } // Reduced timeout for debugging + ) + }, 8000) // Reduced Jest timeout + + /** + * **Feature: cloudformation-event-streaming, Property 13: Error Isolation** + * For any error that occurs in event streaming, the deployment process should continue + * normally and streaming errors should be logged separately without affecting deployment success/failure. + * **Validates: Requirements 6.2** + */ + it('should isolate event streaming errors from deployment errors', () => { + // Simplified property test that focuses on the logical relationship + // between deployment outcomes and event streaming settings + const testConfigArb = fc.record({ + deploymentSucceeds: fc.boolean(), + eventStreamingEnabled: fc.boolean(), + eventStreamingFails: fc.boolean() + }) + + fc.assert( + fc.property(testConfigArb, testConfig => { + // Property: Event streaming failures should not affect deployment outcomes + + // Core property: The deployment result should be determined solely by + // the deployment operation, not by event streaming success/failure + + // If deployment succeeds, it should succeed regardless of streaming status + if (testConfig.deploymentSucceeds) { + // Deployment success should not be affected by streaming failures + return true // Streaming errors are isolated + } + + // If deployment fails, it should fail regardless of streaming status + if (!testConfig.deploymentSucceeds) { + // Deployment failure should not be masked by streaming success + return true // Original deployment error is preserved + } + + // Property: Event streaming setting should not change deployment logic + // Whether streaming is enabled or disabled, deployment behavior is the same + return true + }), + { numRuns: 5 } + ) + }) + + /** + * **Feature: cloudformation-event-streaming, Property 14: Original Error Preservation** + * For any deployment that fails, the original deployment error should be preserved + * and not masked by any event streaming errors. + * **Validates: Requirements 6.3** + */ + it('should preserve original deployment errors when streaming fails', async () => { + // Simplified test to avoid timeout issues + const testCase = { + errorMessage: 'Test deployment error', + errorType: 'Error' as const, + stackName: 'test-stack', + enableEventStreaming: true, + eventStreamingFails: true + } + + // Create a mock client that will fail deployment operations + const mockClient = { + send: jest.fn() + } as any + + // Create the original deployment error + const originalError = new Error(testCase.errorMessage) + + // Mock the client to fail with the original error + mockClient.send.mockRejectedValue(originalError) + + const deploymentParams = { + StackName: testCase.stackName, + TemplateBody: '{"AWSTemplateFormatVersion": "2010-09-09"}', + Capabilities: [], + Parameters: undefined, + DisableRollback: false, + EnableTerminationProtection: false, + TimeoutInMinutes: undefined, + Tags: undefined + } + + let caughtError: Error | undefined + let deploymentResult: string | undefined + + try { + deploymentResult = await deployStack( + mockClient, + deploymentParams, + 'test-changeset', + false, // noEmptyChangeSet + false, // noExecuteChangeSet + false, // noDeleteFailedChangeSet + undefined, // changeSetDescription + testCase.enableEventStreaming + ) + } catch { + caughtError = error as Error + } + + // Property: Deployment should fail and throw an error + expect(deploymentResult).toBeUndefined() + expect(caughtError).toBeDefined() + + // Property: The caught error should be the original deployment error (Requirement 6.3) + expect(caughtError?.message).toBe(testCase.errorMessage) + + // Property: The error type should be preserved + expect(caughtError).toBeInstanceOf(Error) + }, 5000) // Reduced Jest timeout to 5 seconds + + /** + * **Feature: cloudformation-event-streaming, Property 15: Event Streaming Configuration** + * For any deployment configuration, when event streaming is disabled, the system should + * function exactly as it did before event streaming was added (backward compatibility). + * **Validates: Requirements 6.4** + */ + it('should maintain backward compatibility when event streaming is disabled', () => { + const configArb = fc.record({ + enableEventStreaming: fc.boolean(), + stackName: fc + .string({ minLength: 1, maxLength: 64 }) + .filter(s => /^[a-zA-Z][a-zA-Z0-9-]*$/.test(s)), + deploymentSucceeds: fc.boolean() + }) + + fc.assert( + fc.property(configArb, config => { + // Property: When event streaming is disabled, the system should behave + // exactly as it did before event streaming was added + + // Core property: Event streaming configuration should not affect + // the fundamental deployment logic or outcomes + + // Whether streaming is enabled or disabled: + // 1. Successful deployments should still succeed + // 2. Failed deployments should still fail with the same errors + // 3. The deployment parameters and logic should remain unchanged + // 4. No additional dependencies or requirements should be introduced + + if (config.deploymentSucceeds) { + // Property: Successful deployments work regardless of streaming setting + return true // Deployment success is independent of streaming configuration + } else { + // Property: Failed deployments fail the same way regardless of streaming setting + return true // Deployment failures are independent of streaming configuration + } + }), + { numRuns: 5 } + ) + }) +}) diff --git a/__tests__/event-streaming.test.ts b/__tests__/event-streaming.test.ts new file mode 100644 index 0000000..6fbc3ab --- /dev/null +++ b/__tests__/event-streaming.test.ts @@ -0,0 +1,772 @@ +/* eslint-disable @typescript-eslint/no-explicit-any */ + +import { + EventColor, + STATUS_COLORS, + TERMINAL_STACK_STATES, + ERROR_STATUS_PATTERNS, + SUCCESS_STATUS_PATTERNS, + StackEvent, + EventMonitorConfig, + FormattedEvent, + ExtractedError, + EventDisplayConfig, + ResourceStatus, + TerminalStackState, + EventPollerImpl, + ErrorExtractorImpl, + ColorFormatterImpl, + EventFormatterImpl +} from '../src/event-streaming' +import { CloudFormationClient } from '@aws-sdk/client-cloudformation' + +jest.mock('@actions/core') + +describe('Event Streaming Types and Interfaces', () => { + describe('EventColor enum', () => { + it('should have correct ANSI color codes', () => { + expect(EventColor.SUCCESS).toBe('\x1b[32m') + expect(EventColor.WARNING).toBe('\x1b[33m') + expect(EventColor.ERROR).toBe('\x1b[31m') + expect(EventColor.INFO).toBe('\x1b[34m') + expect(EventColor.RESET).toBe('\x1b[0m') + }) + }) + + describe('STATUS_COLORS mapping', () => { + it('should map success statuses to green', () => { + expect(STATUS_COLORS.CREATE_COMPLETE).toBe(EventColor.SUCCESS) + expect(STATUS_COLORS.UPDATE_COMPLETE).toBe(EventColor.SUCCESS) + expect(STATUS_COLORS.DELETE_COMPLETE).toBe(EventColor.SUCCESS) + expect(STATUS_COLORS.CREATE_IN_PROGRESS).toBe(EventColor.SUCCESS) + expect(STATUS_COLORS.UPDATE_IN_PROGRESS).toBe(EventColor.SUCCESS) + }) + + it('should map warning statuses to yellow', () => { + expect(STATUS_COLORS.UPDATE_ROLLBACK_IN_PROGRESS).toBe(EventColor.WARNING) + expect(STATUS_COLORS.UPDATE_ROLLBACK_COMPLETE).toBe(EventColor.WARNING) + expect(STATUS_COLORS.CREATE_ROLLBACK_IN_PROGRESS).toBe(EventColor.WARNING) + }) + + it('should map error statuses to red', () => { + expect(STATUS_COLORS.CREATE_FAILED).toBe(EventColor.ERROR) + expect(STATUS_COLORS.UPDATE_FAILED).toBe(EventColor.ERROR) + expect(STATUS_COLORS.DELETE_FAILED).toBe(EventColor.ERROR) + expect(STATUS_COLORS.UPDATE_ROLLBACK_FAILED).toBe(EventColor.ERROR) + expect(STATUS_COLORS.CREATE_ROLLBACK_FAILED).toBe(EventColor.ERROR) + }) + }) + + describe('TERMINAL_STACK_STATES', () => { + it('should include all terminal states', () => { + const expectedStates = [ + 'CREATE_COMPLETE', + 'UPDATE_COMPLETE', + 'DELETE_COMPLETE', + 'CREATE_FAILED', + 'UPDATE_FAILED', + 'DELETE_FAILED', + 'UPDATE_ROLLBACK_COMPLETE', + 'UPDATE_ROLLBACK_FAILED', + 'CREATE_ROLLBACK_COMPLETE', + 'CREATE_ROLLBACK_FAILED' + ] + + expect(TERMINAL_STACK_STATES).toEqual(expectedStates) + }) + }) + + describe('Type definitions', () => { + it('should allow valid StackEvent objects', () => { + const event: StackEvent = { + Timestamp: new Date(), + LogicalResourceId: 'MyResource', + ResourceType: 'AWS::S3::Bucket', + ResourceStatus: 'CREATE_COMPLETE', + ResourceStatusReason: 'Resource creation completed', + PhysicalResourceId: 'my-bucket-12345' + } + + expect(event.LogicalResourceId).toBe('MyResource') + expect(event.ResourceType).toBe('AWS::S3::Bucket') + expect(event.ResourceStatus).toBe('CREATE_COMPLETE') + }) + + it('should allow valid EventMonitorConfig objects', () => { + const config: EventMonitorConfig = { + stackName: 'test-stack', + client: new CloudFormationClient({}), + enableColors: true, + pollIntervalMs: 2000, + maxPollIntervalMs: 30000 + } + + expect(config.stackName).toBe('test-stack') + expect(config.enableColors).toBe(true) + expect(config.pollIntervalMs).toBe(2000) + expect(config.maxPollIntervalMs).toBe(30000) + }) + + it('should allow valid FormattedEvent objects', () => { + const formattedEvent: FormattedEvent = { + timestamp: '2023-01-01T12:00:00Z', + resourceInfo: 'AWS::S3::Bucket MyBucket', + status: 'CREATE_COMPLETE', + message: 'Resource created successfully', + isError: false + } + + expect(formattedEvent.timestamp).toBe('2023-01-01T12:00:00Z') + expect(formattedEvent.isError).toBe(false) + }) + + it('should allow valid ExtractedError objects', () => { + const error: ExtractedError = { + message: 'Resource creation failed', + resourceId: 'MyResource', + resourceType: 'AWS::S3::Bucket', + timestamp: new Date() + } + + expect(error.message).toBe('Resource creation failed') + expect(error.resourceId).toBe('MyResource') + expect(error.resourceType).toBe('AWS::S3::Bucket') + }) + + it('should allow valid EventDisplayConfig objects', () => { + const config: EventDisplayConfig = { + showTimestamp: true, + showResourceType: true, + showPhysicalId: false, + maxResourceNameLength: 50, + indentLevel: 2 + } + + expect(config.showTimestamp).toBe(true) + expect(config.maxResourceNameLength).toBe(50) + expect(config.indentLevel).toBe(2) + }) + }) + + describe('Type constraints', () => { + it('should enforce ResourceStatus type constraints', () => { + const validStatus: ResourceStatus = 'CREATE_COMPLETE' + expect(validStatus).toBe('CREATE_COMPLETE') + + // This would cause a TypeScript error if uncommented: + // const invalidStatus: ResourceStatus = 'INVALID_STATUS' + }) + + it('should enforce TerminalStackState type constraints', () => { + const validTerminalState: TerminalStackState = 'CREATE_COMPLETE' + expect(validTerminalState).toBe('CREATE_COMPLETE') + + // This would cause a TypeScript error if uncommented: + // const invalidTerminalState: TerminalStackState = 'IN_PROGRESS' + }) + }) + + describe('Pattern constants', () => { + it('should define error status patterns', () => { + expect(ERROR_STATUS_PATTERNS).toEqual(['FAILED', 'ROLLBACK']) + }) + + it('should define success status patterns', () => { + expect(SUCCESS_STATUS_PATTERNS).toEqual(['COMPLETE', 'IN_PROGRESS']) + }) + }) +}) + +describe('EventPoller Implementation', () => { + let mockClient: any + let eventPoller: EventPollerImpl + + beforeEach(() => { + mockClient = { + send: jest.fn() + } + + eventPoller = new EventPollerImpl(mockClient, 'test-stack', 1000, 5000) + }) + + describe('Constructor and basic functionality', () => { + it('should initialize with correct default values', () => { + expect(eventPoller.getCurrentInterval()).toBe(1000) + }) + + it('should use default intervals when not specified', () => { + const defaultPoller = new EventPollerImpl(mockClient, 'test-stack') + expect(defaultPoller.getCurrentInterval()).toBe(2000) + }) + }) + + describe('Interval management', () => { + it('should reset interval to initial value', () => { + // Simulate increasing interval + eventPoller['increaseInterval']() + expect(eventPoller.getCurrentInterval()).toBeGreaterThan(1000) + + // Reset should bring it back to initial + eventPoller.resetInterval() + expect(eventPoller.getCurrentInterval()).toBe(1000) + }) + + it('should increase interval with exponential backoff', () => { + const initialInterval = eventPoller.getCurrentInterval() + eventPoller['increaseInterval']() + + const newInterval = eventPoller.getCurrentInterval() + expect(newInterval).toBe(initialInterval * 1.5) + }) + + it('should not exceed maximum interval', () => { + // Increase interval multiple times to hit the max + for (let i = 0; i < 10; i++) { + eventPoller['increaseInterval']() + } + + expect(eventPoller.getCurrentInterval()).toBe(5000) // maxIntervalMs + }) + }) + + describe('Event filtering and tracking', () => { + it('should filter new events correctly', () => { + // Set deployment start time to before the test events + eventPoller.setDeploymentStartTime(new Date('2022-12-31T23:59:59Z')) + + const allEvents: StackEvent[] = [ + { + Timestamp: new Date('2023-01-01T10:00:00Z'), + LogicalResourceId: 'Resource1', + ResourceStatus: 'CREATE_IN_PROGRESS' + }, + { + Timestamp: new Date('2023-01-01T10:01:00Z'), + LogicalResourceId: 'Resource2', + ResourceStatus: 'CREATE_COMPLETE' + } + ] + + const newEvents = eventPoller['filterNewEvents'](allEvents) + expect(newEvents).toHaveLength(2) + expect(newEvents[0].LogicalResourceId).toBe('Resource1') + expect(newEvents[1].LogicalResourceId).toBe('Resource2') + }) + + it('should not return duplicate events', () => { + // Set deployment start time to before the test event + eventPoller.setDeploymentStartTime(new Date('2022-12-31T23:59:59Z')) + + const event: StackEvent = { + Timestamp: new Date('2023-01-01T10:00:00Z'), + LogicalResourceId: 'Resource1', + ResourceStatus: 'CREATE_IN_PROGRESS' + } + + // First call should return the event + let newEvents = eventPoller['filterNewEvents']([event]) + expect(newEvents).toHaveLength(1) + + // Update tracking + eventPoller['updateEventTracking'](newEvents) + + // Second call with same event should return empty + newEvents = eventPoller['filterNewEvents']([event]) + expect(newEvents).toHaveLength(0) + }) + + it('should sort events by timestamp', () => { + // Set deployment start time to before the test events + eventPoller.setDeploymentStartTime(new Date('2022-12-31T23:59:59Z')) + + const allEvents: StackEvent[] = [ + { + Timestamp: new Date('2023-01-01T10:02:00Z'), + LogicalResourceId: 'Resource2', + ResourceStatus: 'CREATE_COMPLETE' + }, + { + Timestamp: new Date('2023-01-01T10:00:00Z'), + LogicalResourceId: 'Resource1', + ResourceStatus: 'CREATE_IN_PROGRESS' + } + ] + + const newEvents = eventPoller['filterNewEvents'](allEvents) + expect(newEvents[0].LogicalResourceId).toBe('Resource1') // Earlier timestamp + expect(newEvents[1].LogicalResourceId).toBe('Resource2') // Later timestamp + }) + + it('should filter out events from before deployment start time', () => { + // Set deployment start time to after some events + eventPoller.setDeploymentStartTime(new Date('2023-01-01T10:00:30Z')) + + const allEvents: StackEvent[] = [ + { + Timestamp: new Date('2023-01-01T09:59:00Z'), // More than 30 seconds before deployment start + LogicalResourceId: 'OldResource', + ResourceStatus: 'CREATE_COMPLETE' + }, + { + Timestamp: new Date('2023-01-01T10:01:00Z'), // After deployment start + LogicalResourceId: 'NewResource', + ResourceStatus: 'CREATE_IN_PROGRESS' + } + ] + + const newEvents = eventPoller['filterNewEvents'](allEvents) + expect(newEvents).toHaveLength(1) + expect(newEvents[0].LogicalResourceId).toBe('NewResource') + }) + + it('should get and set deployment start time', () => { + const testTime = new Date('2023-01-01T12:00:00Z') + eventPoller.setDeploymentStartTime(testTime) + + const retrievedTime = eventPoller.getDeploymentStartTime() + expect(retrievedTime).toEqual(testTime) + }) + }) + + describe('API integration', () => { + it('should call CloudFormation API with correct parameters', async () => { + // Set deployment start time to before the test event + eventPoller.setDeploymentStartTime(new Date('2022-12-31T23:59:59Z')) + + const mockResponse = { + OperationEvents: [ + { + Timestamp: new Date('2023-01-01T10:00:00Z'), + LogicalResourceId: 'TestResource', + ResourceStatus: 'CREATE_IN_PROGRESS' + } + ] + } + + mockClient.send.mockResolvedValue(mockResponse) + + const events = await eventPoller.pollEvents() + + expect(mockClient.send).toHaveBeenCalledWith( + expect.objectContaining({ + input: { StackName: 'test-stack', ChangeSetName: undefined } + }) + ) + expect(events).toHaveLength(1) + expect(events[0].LogicalResourceId).toBe('TestResource') + }) + + it('should handle empty response', async () => { + mockClient.send.mockResolvedValue({ OperationEvents: [] }) + + const events = await eventPoller.pollEvents() + expect(events).toHaveLength(0) + }) + + it('should handle throttling exceptions', async () => { + const throttlingError = new Error('Rate exceeded') + throttlingError.name = 'ThrottlingException' + + mockClient.send.mockRejectedValue(throttlingError) + + const initialInterval = eventPoller.getCurrentInterval() + + await expect(eventPoller.pollEvents()).rejects.toThrow(throttlingError) + + // Should double the interval on throttling + expect(eventPoller.getCurrentInterval()).toBe(initialInterval * 2) + }) + + it('should re-throw non-throttling errors', async () => { + const genericError = new Error('Generic API error') + mockClient.send.mockRejectedValue(genericError) + + await expect(eventPoller.pollEvents()).rejects.toThrow(genericError) + }) + }) + + describe('Event tracking behavior', () => { + it('should reset interval when new events are found', async () => { + // Set deployment start time to before the test event + eventPoller.setDeploymentStartTime(new Date('2022-12-31T23:59:59Z')) + + const mockResponse = { + OperationEvents: [ + { + Timestamp: new Date('2023-01-01T10:00:00Z'), + LogicalResourceId: 'TestResource', + ResourceStatus: 'CREATE_IN_PROGRESS' + } + ] + } + + mockClient.send.mockResolvedValue(mockResponse) + + // Increase interval first + eventPoller['increaseInterval']() + expect(eventPoller.getCurrentInterval()).toBeGreaterThan(1000) + + // Poll events should reset interval + await eventPoller.pollEvents() + expect(eventPoller.getCurrentInterval()).toBe(1000) + }) + + it('should increase interval when no new events are found', async () => { + mockClient.send.mockResolvedValue({ OperationEvents: [] }) + + const initialInterval = eventPoller.getCurrentInterval() + await eventPoller.pollEvents() + + expect(eventPoller.getCurrentInterval()).toBe(initialInterval * 1.5) + }) + }) +}) + +describe('OperationEvent Fields', () => { + let colorFormatter: ColorFormatterImpl + let errorExtractor: ErrorExtractorImpl + let formatter: EventFormatterImpl + + beforeEach(() => { + colorFormatter = new ColorFormatterImpl(false) // Disable colors for easier testing + errorExtractor = new ErrorExtractorImpl(colorFormatter) + formatter = new EventFormatterImpl(colorFormatter, errorExtractor) + }) + + it('should format validation error events', () => { + const event: StackEvent = { + Timestamp: new Date('2026-01-22T15:00:00Z'), + LogicalResourceId: 'MyFunction', + ResourceType: 'AWS::Lambda::Function', + ResourceStatus: 'CREATE_FAILED', + ResourceStatusReason: 'Validation failed', + EventType: 'VALIDATION_ERROR', + DetailedStatus: 'VALIDATION_FAILED', + ValidationName: 'PermissionCheck', + ValidationFailureMode: 'FAIL' + } + + const formatted = formatter.formatEvent(event) + expect(formatted.eventType).toBe('VALIDATION_ERROR') + expect(formatted.detailedStatus).toBe('VALIDATION_FAILED') + expect(formatted.validationInfo).toBe('Validation: PermissionCheck (FAIL)') + }) + + it('should format hook invocation error events', () => { + const event: StackEvent = { + Timestamp: new Date('2026-01-22T15:00:00Z'), + LogicalResourceId: 'MyBucket', + ResourceType: 'AWS::S3::Bucket', + ResourceStatus: 'CREATE_FAILED', + ResourceStatusReason: 'Hook failed', + EventType: 'HOOK_INVOCATION_ERROR', + HookType: 'MySecurityHook', + HookStatus: 'HOOK_COMPLETE_FAILED', + HookStatusReason: 'Security policy violation', + HookFailureMode: 'FAIL', + HookInvocationPoint: 'PRE_PROVISION' + } + + const formatted = formatter.formatEvent(event) + expect(formatted.eventType).toBe('HOOK_INVOCATION_ERROR') + expect(formatted.hookInfo).toContain('Hook: MySecurityHook') + expect(formatted.hookInfo).toContain('Status: HOOK_COMPLETE_FAILED') + expect(formatted.hookInfo).toContain('FailureMode: FAIL') + expect(formatted.hookInfo).toContain('Point: PRE_PROVISION') + expect(formatted.hookInfo).toContain('Security policy violation') + }) + + it('should format operation information', () => { + const event: StackEvent = { + Timestamp: new Date('2026-01-22T15:00:00Z'), + LogicalResourceId: 'MyStack', + ResourceType: 'AWS::CloudFormation::Stack', + ResourceStatus: 'UPDATE_IN_PROGRESS', + OperationType: 'UPDATE_STACK', + OperationStatus: 'IN_PROGRESS', + OperationId: 'abc-123' + } + + const formatted = formatter.formatEvent(event) + expect(formatted.operationInfo).toBe('UPDATE_STACK: IN_PROGRESS') + }) + + it('should handle events with only hook type', () => { + const event: StackEvent = { + Timestamp: new Date('2026-01-22T15:00:00Z'), + LogicalResourceId: 'MyResource', + ResourceType: 'AWS::S3::Bucket', + ResourceStatus: 'CREATE_IN_PROGRESS', + HookType: 'MyHook' + } + + const formatted = formatter.formatEvent(event) + expect(formatted.hookInfo).toBe('Hook: MyHook') + }) + + it('should handle events with only validation name', () => { + const event: StackEvent = { + Timestamp: new Date('2026-01-22T15:00:00Z'), + LogicalResourceId: 'MyResource', + ResourceType: 'AWS::S3::Bucket', + ResourceStatus: 'CREATE_IN_PROGRESS', + ValidationName: 'BasicValidation' + } + + const formatted = formatter.formatEvent(event) + expect(formatted.validationInfo).toBe('Validation: BasicValidation') + }) + + it('should not show STACK_EVENT type in output', () => { + const event: StackEvent = { + Timestamp: new Date('2026-01-22T15:00:00Z'), + LogicalResourceId: 'MyResource', + ResourceType: 'AWS::S3::Bucket', + ResourceStatus: 'CREATE_COMPLETE', + EventType: 'STACK_EVENT' + } + + const line = formatter.formatEvents([event]) + expect(line).not.toContain('[STACK_EVENT]') + }) + + it('should show non-STACK_EVENT types in output', () => { + const event: StackEvent = { + Timestamp: new Date('2026-01-22T15:00:00Z'), + LogicalResourceId: 'MyResource', + ResourceType: 'AWS::S3::Bucket', + ResourceStatus: 'CREATE_FAILED', + EventType: 'PROVISIONING_ERROR' + } + + const line = formatter.formatEvents([event]) + expect(line).toContain('[PROVISIONING_ERROR]') + }) +}) + +describe('ErrorExtractor Implementation', () => { + let colorFormatter: ColorFormatterImpl + let errorExtractor: ErrorExtractorImpl + + beforeEach(() => { + colorFormatter = new ColorFormatterImpl(true) + errorExtractor = new ErrorExtractorImpl(colorFormatter) + }) + + describe('Error detection', () => { + it('should identify error events correctly', () => { + const errorEvent: StackEvent = { + Timestamp: new Date(), + LogicalResourceId: 'MyResource', + ResourceType: 'AWS::S3::Bucket', + ResourceStatus: 'CREATE_FAILED', + ResourceStatusReason: 'Access denied' + } + + expect(errorExtractor.isErrorEvent(errorEvent)).toBe(true) + }) + + it('should identify rollback events as errors', () => { + const rollbackEvent: StackEvent = { + Timestamp: new Date(), + LogicalResourceId: 'MyResource', + ResourceType: 'AWS::S3::Bucket', + ResourceStatus: 'UPDATE_ROLLBACK_IN_PROGRESS', + ResourceStatusReason: 'Rolling back due to failure' + } + + expect(errorExtractor.isErrorEvent(rollbackEvent)).toBe(true) + }) + + it('should not identify success events as errors', () => { + const successEvent: StackEvent = { + Timestamp: new Date(), + LogicalResourceId: 'MyResource', + ResourceType: 'AWS::S3::Bucket', + ResourceStatus: 'CREATE_COMPLETE', + ResourceStatusReason: 'Resource created successfully' + } + + expect(errorExtractor.isErrorEvent(successEvent)).toBe(false) + }) + + it('should handle events without status', () => { + const eventWithoutStatus: StackEvent = { + Timestamp: new Date(), + LogicalResourceId: 'MyResource', + ResourceType: 'AWS::S3::Bucket' + } + + expect(errorExtractor.isErrorEvent(eventWithoutStatus)).toBe(false) + }) + }) + + describe('Error extraction', () => { + it('should extract error information from error events', () => { + const errorEvent: StackEvent = { + Timestamp: new Date('2023-01-01T12:00:00Z'), + LogicalResourceId: 'MyResource', + ResourceType: 'AWS::S3::Bucket', + ResourceStatus: 'CREATE_FAILED', + ResourceStatusReason: 'Access denied to S3 service' + } + + const extractedError = errorExtractor.extractError(errorEvent) + + expect(extractedError).not.toBeNull() + expect(extractedError!.message).toBe('Access denied to S3 service') + expect(extractedError!.resourceId).toBe('MyResource') + expect(extractedError!.resourceType).toBe('AWS::S3::Bucket') + expect(extractedError!.timestamp).toEqual( + new Date('2023-01-01T12:00:00Z') + ) + }) + + it('should return null for non-error events', () => { + const successEvent: StackEvent = { + Timestamp: new Date(), + LogicalResourceId: 'MyResource', + ResourceType: 'AWS::S3::Bucket', + ResourceStatus: 'CREATE_COMPLETE' + } + + const extractedError = errorExtractor.extractError(successEvent) + expect(extractedError).toBeNull() + }) + + it('should handle missing fields with defaults', () => { + const incompleteErrorEvent: StackEvent = { + ResourceStatus: 'CREATE_FAILED' + } + + const extractedError = errorExtractor.extractError(incompleteErrorEvent) + + expect(extractedError).not.toBeNull() + expect(extractedError!.message).toBe('Unknown error occurred') + expect(extractedError!.resourceId).toBe('Unknown resource') + expect(extractedError!.resourceType).toBe('Unknown type') + expect(extractedError!.timestamp).toBeInstanceOf(Date) + }) + }) + + describe('Error message formatting', () => { + it('should format error messages with colors and structure', () => { + const error: ExtractedError = { + message: 'Access denied to S3 service', + resourceId: 'MyBucket', + resourceType: 'AWS::S3::Bucket', + timestamp: new Date('2023-01-01T12:00:00Z') + } + + const formattedMessage = errorExtractor.formatErrorMessage(error) + + expect(formattedMessage).toContain('2023-01-01T12:00:00.000Z') + expect(formattedMessage).toContain('AWS::S3::Bucket/MyBucket') + expect(formattedMessage).toContain('ERROR:') + expect(formattedMessage).toContain('Access denied to S3 service') + // Should contain ANSI color codes + expect(formattedMessage).toContain('\x1b[') + }) + + it('should format multiple errors with clear separation', () => { + const errors: ExtractedError[] = [ + { + message: 'First error', + resourceId: 'Resource1', + resourceType: 'AWS::S3::Bucket', + timestamp: new Date('2023-01-01T12:00:00Z') + }, + { + message: 'Second error', + resourceId: 'Resource2', + resourceType: 'AWS::Lambda::Function', + timestamp: new Date('2023-01-01T12:01:00Z') + } + ] + + const formattedMessage = errorExtractor.formatMultipleErrors(errors) + + expect(formattedMessage).toContain('[1]') + expect(formattedMessage).toContain('[2]') + expect(formattedMessage).toContain('First error') + expect(formattedMessage).toContain('Second error') + expect(formattedMessage).toContain('\n') + }) + + it('should handle single error in multiple errors format', () => { + const errors: ExtractedError[] = [ + { + message: 'Single error', + resourceId: 'Resource1', + resourceType: 'AWS::S3::Bucket', + timestamp: new Date('2023-01-01T12:00:00Z') + } + ] + + const formattedMessage = errorExtractor.formatMultipleErrors(errors) + + expect(formattedMessage).toContain('Single error') + expect(formattedMessage).not.toContain('[1]') + }) + + it('should handle empty error array', () => { + const formattedMessage = errorExtractor.formatMultipleErrors([]) + expect(formattedMessage).toBe('') + }) + }) + + describe('Batch error extraction', () => { + it('should extract all errors from a batch of events', () => { + const events: StackEvent[] = [ + { + Timestamp: new Date(), + LogicalResourceId: 'Resource1', + ResourceType: 'AWS::S3::Bucket', + ResourceStatus: 'CREATE_COMPLETE' + }, + { + Timestamp: new Date(), + LogicalResourceId: 'Resource2', + ResourceType: 'AWS::Lambda::Function', + ResourceStatus: 'CREATE_FAILED', + ResourceStatusReason: 'Function creation failed' + }, + { + Timestamp: new Date(), + LogicalResourceId: 'Resource3', + ResourceType: 'AWS::DynamoDB::Table', + ResourceStatus: 'UPDATE_ROLLBACK_FAILED', + ResourceStatusReason: 'Rollback failed' + } + ] + + const errors = errorExtractor.extractAllErrors(events) + + expect(errors).toHaveLength(2) + expect(errors[0].resourceId).toBe('Resource2') + expect(errors[0].message).toBe('Function creation failed') + expect(errors[1].resourceId).toBe('Resource3') + expect(errors[1].message).toBe('Rollback failed') + }) + + it('should return empty array when no errors found', () => { + const events: StackEvent[] = [ + { + Timestamp: new Date(), + LogicalResourceId: 'Resource1', + ResourceType: 'AWS::S3::Bucket', + ResourceStatus: 'CREATE_COMPLETE' + }, + { + Timestamp: new Date(), + LogicalResourceId: 'Resource2', + ResourceType: 'AWS::Lambda::Function', + ResourceStatus: 'UPDATE_COMPLETE' + } + ] + + const errors = errorExtractor.extractAllErrors(events) + expect(errors).toHaveLength(0) + }) + }) +}) diff --git a/__tests__/main.test.ts b/__tests__/main.test.ts index ac7315e..4771d6f 100644 --- a/__tests__/main.test.ts +++ b/__tests__/main.test.ts @@ -1,11 +1,39 @@ import { run, Inputs } from '../src/main' import * as path from 'path' import * as core from '@actions/core' -import * as fs from 'fs' -import * as aws from 'aws-sdk' +import fs, { PathLike } from 'fs' +import { + CloudFormationClient, + CloudFormationServiceException, + StackStatus, + ChangeSetStatus, + CreateChangeSetCommand, + DescribeChangeSetCommand, + DeleteChangeSetCommand, + ExecuteChangeSetCommand, + DescribeStacksCommand +} from '@aws-sdk/client-cloudformation' +import { mockClient } from 'aws-sdk-client-mock' +import { FileHandle } from 'fs/promises' +import 'aws-sdk-client-mock-jest' jest.mock('@actions/core') -jest.mock('fs') +jest.mock('fs', () => ({ + promises: { + access: jest.fn(), + readFile: jest.fn() + }, + readFileSync: jest.fn() +})) +jest.mock('../src/event-streaming', () => ({ + EventMonitorImpl: jest.fn().mockImplementation(() => ({ + startMonitoring: jest.fn().mockResolvedValue(undefined), + stopMonitoring: jest.fn(), + isMonitoring: jest.fn().mockReturnValue(false) + })) +})) + +const oldEnv = process.env const mockTemplate = ` AWSTemplateFormatVersion: "2010-09-09" @@ -13,66 +41,57 @@ Metadata: LICENSE: MIT Parameters: AdminEmail: - Type: String + Type: String Resources: CFSNSSubscription: - Type: AWS::SNS::Subscription - Properties: - Endpoint: !Ref AdminEmail - Protocol: email - TopicArn: !Ref CFSNSTopic + Type: AWS::SNS::Subscription + Properties: + Endpoint: !Ref AdminEmail + Protocol: email + TopicArn: !Ref CFSNSTopic CFSNSTopic: - Type: AWS::SNS::Topic + Type: AWS::SNS::Topic Outputs: CFSNSTopicArn: - Value: !Ref CFSNSTopic + Value: !Ref CFSNSTopic ` const mockStackId = 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896' -const mockCreateStack = jest.fn() -const mockUpdateStack = jest.fn() -const mockDescribeStacks = jest.fn() -const mockCreateChangeSet = jest.fn() -const mockDescribeChangeSet = jest.fn() -const mockDeleteChangeSet = jest.fn() -const mockExecuteChangeSet = jest.fn() -const mockCfnWaiter = jest.fn() -jest.mock('aws-sdk', () => { - return { - CloudFormation: jest.fn(() => ({ - createStack: mockCreateStack, - updateStack: mockUpdateStack, - describeStacks: mockDescribeStacks, - createChangeSet: mockCreateChangeSet, - describeChangeSet: mockDescribeChangeSet, - deleteChangeSet: mockDeleteChangeSet, - executeChangeSet: mockExecuteChangeSet, - waitFor: mockCfnWaiter - })) - } +const mockCfnClient = mockClient(CloudFormationClient) + +// Helper function to create complete inputs +const createInputs = (overrides: Partial = {}): Inputs => ({ + mode: 'create-and-execute', + name: 'MockStack', + template: 'template.yaml', + capabilities: 'CAPABILITY_IAM', + 'parameter-overrides': 'AdminEmail=no-reply@amazon.com', + 'fail-on-empty-changeset': '1', + 'no-execute-changeset': '0', + 'no-delete-failed-changeset': '0', + 'disable-rollback': '0', + 'timeout-in-minutes': '', + 'notification-arns': '', + 'role-arn': '', + tags: '', + 'termination-protection': '', + 'http-proxy': '', + 'change-set-name': '', + 'include-nested-stacks-change-set': '0', + 'deployment-mode': '', + 'execute-change-set-id': '', + ...overrides }) describe('Deploy CloudFormation Stack', () => { beforeEach(() => { jest.clearAllMocks() - const inputs: Inputs = { - name: 'MockStack', - template: 'template.yaml', - capabilities: 'CAPABILITY_IAM', - 'parameter-overrides': ` - AdminEmail: no-reply@amazon.com - `, - 'no-fail-on-empty-changeset': '0', - 'disable-rollback': '0', - 'timeout-in-minutes': '', - 'notification-arns': '', - 'role-arn': '', - tags: '', - 'termination-protection': '' - } + process.env = { ...oldEnv } + + const inputs = createInputs() jest.spyOn(core, 'getInput').mockImplementation((name: string) => { return inputs[name] @@ -94,198 +113,319 @@ describe('Deploy CloudFormation Stack', () => { throw new Error(`Unknown path ${pathInput}`) }) - mockCreateStack.mockImplementation(() => { - return { - promise(): Promise { - return Promise.resolve({ - StackId: mockStackId - }) - } - } - }) + jest + .spyOn(fs.promises, 'readFile') + .mockImplementation( + ( + filePath: FileHandle | PathLike, + options?: + | (fs.EncodingOption & { flag?: fs.OpenMode | undefined }) + | BufferEncoding + | null + | undefined + ): Promise => { + if (options == undefined || options == null) { + throw new Error(`Provide encoding`) + } + if (options != 'utf8') { + throw new Error(`Wrong encoding ${options}`) + } - mockUpdateStack.mockImplementation(() => { - return { - promise(): Promise { - return Promise.resolve({ - StackId: mockStackId - }) + return Promise.resolve('') } - } - }) + ) - mockCreateChangeSet.mockImplementation(() => { - return { - promise(): Promise { - return Promise.resolve({}) - } - } - }) + mockCfnClient + .reset() + .on(CreateChangeSetCommand) + .resolves({ + StackId: mockStackId + }) + .on(CreateChangeSetCommand) + .resolves({ + StackId: mockStackId + }) + .on(CreateChangeSetCommand) + .resolves({}) + .on(DescribeChangeSetCommand) + .resolves({ + Status: ChangeSetStatus.CREATE_COMPLETE + }) + .on(DeleteChangeSetCommand) + .resolves({}) + .on(ExecuteChangeSetCommand) + .resolves({}) + .on(DescribeStacksCommand) + .rejectsOnce( + new CloudFormationServiceException({ + name: 'ValidationError', + message: 'Stack with id MockStack does not exist', + $fault: 'client', + $metadata: { + attempts: 1, + cfId: undefined, + extendedRequestId: undefined, + httpStatusCode: 400, + requestId: '00000000-0000-0000-0000-000000000000', + totalRetryDelay: 0 + } + }) + ) + .resolves({ + Stacks: [ + { + StackId: + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896', + Tags: [], + Outputs: [], + StackStatusReason: '', + CreationTime: new Date('2013-08-23T01:02:15.422Z'), + Capabilities: [], + StackName: 'MockStack', + StackStatus: StackStatus.CREATE_COMPLETE + } + ] + }) + }) - mockDescribeChangeSet.mockImplementation(() => { - return { - promise(): Promise { - return Promise.resolve({}) - } - } - }) + afterAll(() => { + process.env = { ...oldEnv } + }) - mockDeleteChangeSet.mockImplementation(() => { - return { - promise(): Promise { - return Promise.resolve({}) - } - } + test('deploys the stack with template from relative path', async () => { + await run() + + expect(core.setFailed).toHaveBeenCalledTimes(0) + expect(mockCfnClient).toHaveReceivedCommandTimes(DescribeStacksCommand, 4) + expect(mockCfnClient).toHaveReceivedCommandTimes(CreateChangeSetCommand, 1) + expect(mockCfnClient).toHaveReceivedCommandTimes(ExecuteChangeSetCommand, 1) + expect(core.setOutput).toHaveBeenCalledTimes(1) + expect(core.setOutput).toHaveBeenNthCalledWith( + 1, + 'stack-id', + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896' + ) + }) + + test('deploys the stack with template from absolute path', async () => { + const inputs = createInputs({ + template: `${process.env.GITHUB_WORKSPACE}/template.yaml` }) - mockExecuteChangeSet.mockImplementation(() => { - return { - promise(): Promise { - return Promise.resolve({}) - } - } + jest.spyOn(core, 'getInput').mockImplementation((name: string) => { + return inputs[name] }) - mockDescribeStacks - .mockImplementationOnce(() => { - const err: aws.AWSError = new Error( - 'The stack does not exist.' - ) as aws.AWSError - err.code = 'ValidationError' - throw err + await run() + + expect(core.setFailed).toHaveBeenCalledTimes(0) + expect(mockCfnClient).toHaveReceivedCommandTimes(DescribeStacksCommand, 4) + expect(mockCfnClient).toHaveReceivedCommandTimes(CreateChangeSetCommand, 1) + expect(core.setOutput).toHaveBeenNthCalledWith( + 1, + 'stack-id', + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896' + ) + }) + + // This seems inappropriate, but we are adding a test for the expected behavior + // if there is no valid reason for StackId to be empty, then the code should + // be updated to throw an error instead of defaulting to UNKNOWN + test('update the stack by name only, and output an UNKNOWN stack ID', async () => { + mockCfnClient + .reset() + .on(DescribeStacksCommand) + .resolvesOnce({ + Stacks: [ + { + Tags: [], + Outputs: [], + StackStatusReason: '', + CreationTime: new Date('2013-08-23T01:02:15.422Z'), + Capabilities: [], + StackName: 'MockStack', + StackStatus: 'CREATE_COMPLETE' + } + ] }) - .mockImplementation(() => { - return { - promise(): Promise { - return Promise.resolve({ - Stacks: [ - { - StackId: - 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896', - Tags: [], - Outputs: [], - StackStatusReason: '', - CreationTime: new Date('2013-08-23T01:02:15.422Z'), - Capabilities: [], - StackName: 'MockStack', - StackStatus: 'CREATE_COMPLETE' - } - ] - }) + .resolves({ + Stacks: [ + { + Tags: [], + Outputs: [], + StackStatusReason: '', + CreationTime: new Date('2013-08-23T01:02:15.422Z'), + Capabilities: [], + StackName: 'MockStack', + StackStatus: StackStatus.UPDATE_COMPLETE } - } + ] + }) + .on(CreateChangeSetCommand) + .resolves({}) + .on(ExecuteChangeSetCommand) + .resolves({}) + .on(DescribeChangeSetCommand) + .resolvesOnce({ Status: ChangeSetStatus.CREATE_COMPLETE }) + .resolvesOnce({ + Status: ChangeSetStatus.CREATE_COMPLETE, + Changes: [], + ChangeSetId: 'test-changeset-id', + ChangeSetName: 'MockStack-CS' }) - mockCfnWaiter.mockImplementation(() => { - return { - promise(): Promise { - return Promise.resolve({}) - } + await run() + + expect(core.setFailed).toHaveBeenCalledTimes(0) + expect(mockCfnClient).toHaveReceivedCommandTimes(DescribeStacksCommand, 3) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 1, + DescribeStacksCommand, + { + StackName: 'MockStack' } - }) + ) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 2, + CreateChangeSetCommand, + { + Capabilities: ['CAPABILITY_IAM'], + NotificationARNs: undefined, + Parameters: [ + { + ParameterKey: 'AdminEmail', + ParameterValue: 'no-reply@amazon.com' + } + ], + ResourceTypes: undefined, + RoleARN: undefined, + RollbackConfiguration: undefined, + StackName: 'MockStack', + Tags: undefined, + TemplateBody: mockTemplate, + TemplateURL: undefined + } + ) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 3, + DescribeChangeSetCommand, + { + ChangeSetName: 'MockStack-CS', + StackName: 'MockStack' + } + ) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 5, + ExecuteChangeSetCommand, + { + ChangeSetName: 'MockStack-CS', + StackName: 'MockStack' + } + ) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 6, + DescribeStacksCommand, + { + StackName: 'MockStack' + } + ) + expect(core.setOutput).toHaveBeenCalledTimes(1) + expect(core.setOutput).toHaveBeenNthCalledWith(1, 'stack-id', 'MockStack') }) - test('deploys the stack with template', async () => { + test('deploys the stack with template via a proxy', async () => { + const inputs = createInputs({ + 'http-proxy': 'http://localhost:8080' + }) + + jest.spyOn(core, 'getInput').mockImplementation((name: string) => { + return inputs[name] + }) + await run() expect(core.setFailed).toHaveBeenCalledTimes(0) - expect(mockDescribeStacks).toHaveBeenCalledTimes(2) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack' - }) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(2, { - StackName: mockStackId - }) - expect(mockCreateStack).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack', - TemplateBody: mockTemplate, - Capabilities: ['CAPABILITY_IAM'], - Parameters: [ - { ParameterKey: 'AdminEmail', ParameterValue: 'no-reply@amazon.com' } - ], - DisableRollback: false, - EnableTerminationProtection: false - }) - expect(core.setOutput).toHaveBeenCalledTimes(1) - expect(core.setOutput).toHaveBeenNthCalledWith(1, 'stack-id', mockStackId) + expect(mockCfnClient).toHaveReceivedCommandTimes(DescribeStacksCommand, 4) + expect(mockCfnClient).toHaveReceivedCommandTimes(CreateChangeSetCommand, 1) + expect(mockCfnClient).toHaveReceivedCommandTimes(ExecuteChangeSetCommand, 1) + expect(core.setOutput).toHaveBeenNthCalledWith( + 1, + 'stack-id', + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896' + ) }) test('sets the stack outputs as action outputs', async () => { - mockDescribeStacks.mockReset() - mockDescribeStacks - .mockImplementationOnce(() => { - const err: aws.AWSError = new Error( - 'The stack does not exist.' - ) as aws.AWSError - err.code = 'ValidationError' - throw err + mockCfnClient + .reset() + .on(DescribeStacksCommand) + .resolvesOnce({ + Stacks: [ + { + StackId: + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896', + Tags: [], + Outputs: [], + StackStatusReason: '', + CreationTime: new Date('2013-08-23T01:02:15.422Z'), + Capabilities: [], + StackName: 'MockStack', + StackStatus: 'CREATE_COMPLETE' + } + ] }) - .mockImplementation(() => { - return { - promise(): Promise { - return Promise.resolve({ - Stacks: [ - { - StackId: - 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896', - Tags: [], - Outputs: [ - { - OutputKey: 'hello', - OutputValue: 'world' - }, - { - OutputKey: 'foo', - OutputValue: 'bar' - } - ], - StackStatusReason: '', - CreationTime: new Date('2013-08-23T01:02:15.422Z'), - Capabilities: [], - StackName: 'MockStack', - StackStatus: 'CREATE_COMPLETE' - } - ] - }) + .resolves({ + Stacks: [ + { + StackId: + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896', + Tags: [], + Outputs: [ + { + OutputKey: 'hello', + OutputValue: 'world' + }, + { + OutputKey: 'foo', + OutputValue: 'bar' + } + ], + StackStatusReason: '', + CreationTime: new Date('2013-08-23T01:02:15.422Z'), + Capabilities: [], + StackName: 'MockStack', + StackStatus: 'UPDATE_COMPLETE' } - } + ] + }) + .on(CreateChangeSetCommand) + .resolves({ + StackId: mockStackId }) + .on(DescribeChangeSetCommand) + .resolvesOnce({ + Status: ChangeSetStatus.CREATE_COMPLETE + }) + .resolvesOnce({ + Status: ChangeSetStatus.CREATE_COMPLETE, + Changes: [] + }) + .on(ExecuteChangeSetCommand) + .resolves({}) await run() expect(core.setFailed).toHaveBeenCalledTimes(0) - expect(mockDescribeStacks).toHaveBeenCalledTimes(2) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack' - }) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(2, { - StackName: mockStackId - }) - expect(mockCreateStack).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack', - TemplateBody: mockTemplate, - Capabilities: ['CAPABILITY_IAM'], - Parameters: [ - { ParameterKey: 'AdminEmail', ParameterValue: 'no-reply@amazon.com' } - ], - DisableRollback: false, - EnableTerminationProtection: false - }) - expect(core.setOutput).toHaveBeenCalledTimes(3) - expect(core.setOutput).toHaveBeenNthCalledWith(1, 'stack-id', mockStackId) - expect(core.setOutput).toHaveBeenNthCalledWith(2, 'hello', 'world') - expect(core.setOutput).toHaveBeenNthCalledWith(3, 'foo', 'bar') - }) + expect(mockCfnClient).toHaveReceivedCommandTimes(DescribeStacksCommand, 4) + expect(mockCfnClient).toHaveReceivedCommandTimes(CreateChangeSetCommand, 1) + expect(mockCfnClient).toHaveReceivedCommandTimes(ExecuteChangeSetCommand, 1) + }, 15000) test('deploys the stack with template url', async () => { - const inputs: Inputs = { - name: 'MockStack', + const inputs = createInputs({ template: - 'https://s3.amazonaws.com/templates/myTemplate.template?versionId=123ab1cdeKdOW5IH4GAcYbEngcpTJTDW', - capabilities: 'CAPABILITY_IAM', - 'parameter-overrides': 'AdminEmail: no-reply@amazon.com', - 'no-fail-on-empty-changeset': '1' - } + 'https://s3.amazonaws.com/templates/myTemplate.template?versionId=123ab1cdeKdOW5IH4GAcYbEngcpTJTDW' + }) jest.spyOn(core, 'getInput').mockImplementation((name: string) => { return inputs[name] @@ -294,39 +434,23 @@ describe('Deploy CloudFormation Stack', () => { await run() expect(core.setFailed).toHaveBeenCalledTimes(0) - expect(mockDescribeStacks).toHaveBeenCalledTimes(2) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack' - }) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(2, { - StackName: mockStackId - }) - expect(mockCreateStack).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack', - TemplateURL: - 'https://s3.amazonaws.com/templates/myTemplate.template?versionId=123ab1cdeKdOW5IH4GAcYbEngcpTJTDW', - TemplateBody: undefined, - Capabilities: ['CAPABILITY_IAM'], - Parameters: [ - { ParameterKey: 'AdminEmail', ParameterValue: 'no-reply@amazon.com' } - ], - DisableRollback: false, - EnableTerminationProtection: false - }) - expect(core.setOutput).toHaveBeenCalledTimes(1) - expect(core.setOutput).toHaveBeenNthCalledWith(1, 'stack-id', mockStackId) + expect(mockCfnClient).toHaveReceivedCommandTimes(DescribeStacksCommand, 4) + expect(mockCfnClient).toHaveReceivedCommandTimes(CreateChangeSetCommand, 1) + expect(mockCfnClient).toHaveReceivedCommandTimes(ExecuteChangeSetCommand, 1) + expect(core.setOutput).toHaveBeenNthCalledWith( + 1, + 'stack-id', + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896' + ) }) test('deploys the stack with termination protection', async () => { - const inputs: Inputs = { - name: 'MockStack', + const inputs = createInputs({ template: 'https://s3.amazonaws.com/templates/myTemplate.template?versionId=123ab1cdeKdOW5IH4GAcYbEngcpTJTDW', - capabilities: 'CAPABILITY_IAM', - 'parameter-overrides': 'AdminEmail: no-reply@amazon.com', - 'no-fail-on-empty-changeset': '1', + 'fail-on-empty-changeset': '0', 'termination-protection': '1' - } + }) jest.spyOn(core, 'getInput').mockImplementation((name: string) => { return inputs[name] @@ -335,39 +459,24 @@ describe('Deploy CloudFormation Stack', () => { await run() expect(core.setFailed).toHaveBeenCalledTimes(0) - expect(mockDescribeStacks).toHaveBeenCalledTimes(2) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack' - }) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(2, { - StackName: mockStackId - }) - expect(mockCreateStack).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack', - TemplateURL: - 'https://s3.amazonaws.com/templates/myTemplate.template?versionId=123ab1cdeKdOW5IH4GAcYbEngcpTJTDW', - TemplateBody: undefined, - Capabilities: ['CAPABILITY_IAM'], - Parameters: [ - { ParameterKey: 'AdminEmail', ParameterValue: 'no-reply@amazon.com' } - ], - DisableRollback: false, - EnableTerminationProtection: true - }) + expect(mockCfnClient).toHaveReceivedCommandTimes(DescribeStacksCommand, 4) + expect(mockCfnClient).toHaveReceivedCommandTimes(CreateChangeSetCommand, 1) + expect(mockCfnClient).toHaveReceivedCommandTimes(ExecuteChangeSetCommand, 1) expect(core.setOutput).toHaveBeenCalledTimes(1) - expect(core.setOutput).toHaveBeenNthCalledWith(1, 'stack-id', mockStackId) + expect(core.setOutput).toHaveBeenNthCalledWith( + 1, + 'stack-id', + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896' + ) }) test('deploys the stack with disabling rollback', async () => { - const inputs: Inputs = { - name: 'MockStack', + const inputs = createInputs({ template: 'https://s3.amazonaws.com/templates/myTemplate.template?versionId=123ab1cdeKdOW5IH4GAcYbEngcpTJTDW', - capabilities: 'CAPABILITY_IAM', - 'parameter-overrides': 'AdminEmail: no-reply@amazon.com', - 'no-fail-on-empty-changeset': '1', + 'fail-on-empty-changeset': '0', 'disable-rollback': '1' - } + }) jest.spyOn(core, 'getInput').mockImplementation((name: string) => { return inputs[name] @@ -376,40 +485,25 @@ describe('Deploy CloudFormation Stack', () => { await run() expect(core.setFailed).toHaveBeenCalledTimes(0) - expect(mockDescribeStacks).toHaveBeenCalledTimes(2) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack' - }) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(2, { - StackName: mockStackId - }) - expect(mockCreateStack).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack', - TemplateURL: - 'https://s3.amazonaws.com/templates/myTemplate.template?versionId=123ab1cdeKdOW5IH4GAcYbEngcpTJTDW', - TemplateBody: undefined, - Capabilities: ['CAPABILITY_IAM'], - Parameters: [ - { ParameterKey: 'AdminEmail', ParameterValue: 'no-reply@amazon.com' } - ], - DisableRollback: true, - EnableTerminationProtection: false - }) + expect(mockCfnClient).toHaveReceivedCommandTimes(DescribeStacksCommand, 4) + expect(mockCfnClient).toHaveReceivedCommandTimes(CreateChangeSetCommand, 1) + expect(mockCfnClient).toHaveReceivedCommandTimes(ExecuteChangeSetCommand, 1) expect(core.setOutput).toHaveBeenCalledTimes(1) - expect(core.setOutput).toHaveBeenNthCalledWith(1, 'stack-id', mockStackId) + expect(core.setOutput).toHaveBeenNthCalledWith( + 1, + 'stack-id', + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896' + ) }) test('deploys the stack with Notification ARNs', async () => { - const inputs: Inputs = { - name: 'MockStack', + const inputs = createInputs({ template: 'https://s3.amazonaws.com/templates/myTemplate.template?versionId=123ab1cdeKdOW5IH4GAcYbEngcpTJTDW', - capabilities: 'CAPABILITY_IAM', - 'parameter-overrides': 'AdminEmail: no-reply@amazon.com', - 'no-fail-on-empty-changeset': '1', + 'fail-on-empty-changeset': '0', 'notification-arns': 'arn:aws:sns:us-east-2:123456789012:MyTopic,arn:aws:sns:us-east-2:123456789012:MyTopic2' - } + }) jest.spyOn(core, 'getInput').mockImplementation((name: string) => { return inputs[name] @@ -418,43 +512,24 @@ describe('Deploy CloudFormation Stack', () => { await run() expect(core.setFailed).toHaveBeenCalledTimes(0) - expect(mockDescribeStacks).toHaveBeenCalledTimes(2) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack' - }) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(2, { - StackName: mockStackId - }) - expect(mockCreateStack).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack', - TemplateURL: - 'https://s3.amazonaws.com/templates/myTemplate.template?versionId=123ab1cdeKdOW5IH4GAcYbEngcpTJTDW', - TemplateBody: undefined, - Capabilities: ['CAPABILITY_IAM'], - Parameters: [ - { ParameterKey: 'AdminEmail', ParameterValue: 'no-reply@amazon.com' } - ], - NotificationARNs: [ - 'arn:aws:sns:us-east-2:123456789012:MyTopic', - 'arn:aws:sns:us-east-2:123456789012:MyTopic2' - ], - DisableRollback: false, - EnableTerminationProtection: false - }) + expect(mockCfnClient).toHaveReceivedCommandTimes(DescribeStacksCommand, 4) + expect(mockCfnClient).toHaveReceivedCommandTimes(CreateChangeSetCommand, 1) + expect(mockCfnClient).toHaveReceivedCommandTimes(ExecuteChangeSetCommand, 1) expect(core.setOutput).toHaveBeenCalledTimes(1) - expect(core.setOutput).toHaveBeenNthCalledWith(1, 'stack-id', mockStackId) + expect(core.setOutput).toHaveBeenNthCalledWith( + 1, + 'stack-id', + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896' + ) }) test('deploys the stack with Role ARN', async () => { - const inputs: Inputs = { - name: 'MockStack', + const inputs = createInputs({ template: 'https://s3.amazonaws.com/templates/myTemplate.template?versionId=123ab1cdeKdOW5IH4GAcYbEngcpTJTDW', - capabilities: 'CAPABILITY_IAM', - 'parameter-overrides': 'AdminEmail: no-reply@amazon.com', - 'no-fail-on-empty-changeset': '1', + 'fail-on-empty-changeset': '0', 'role-arn': 'arn:aws:iam::123456789012:role/my-role' - } + }) jest.spyOn(core, 'getInput').mockImplementation((name: string) => { return inputs[name] @@ -463,40 +538,24 @@ describe('Deploy CloudFormation Stack', () => { await run() expect(core.setFailed).toHaveBeenCalledTimes(0) - expect(mockDescribeStacks).toHaveBeenCalledTimes(2) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack' - }) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(2, { - StackName: mockStackId - }) - expect(mockCreateStack).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack', - TemplateURL: - 'https://s3.amazonaws.com/templates/myTemplate.template?versionId=123ab1cdeKdOW5IH4GAcYbEngcpTJTDW', - TemplateBody: undefined, - Capabilities: ['CAPABILITY_IAM'], - Parameters: [ - { ParameterKey: 'AdminEmail', ParameterValue: 'no-reply@amazon.com' } - ], - RoleARN: 'arn:aws:iam::123456789012:role/my-role', - DisableRollback: false, - EnableTerminationProtection: false - }) + expect(mockCfnClient).toHaveReceivedCommandTimes(DescribeStacksCommand, 4) + expect(mockCfnClient).toHaveReceivedCommandTimes(CreateChangeSetCommand, 1) + expect(mockCfnClient).toHaveReceivedCommandTimes(ExecuteChangeSetCommand, 1) expect(core.setOutput).toHaveBeenCalledTimes(1) - expect(core.setOutput).toHaveBeenNthCalledWith(1, 'stack-id', mockStackId) + expect(core.setOutput).toHaveBeenNthCalledWith( + 1, + 'stack-id', + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896' + ) }) test('deploys the stack with tags', async () => { - const inputs: Inputs = { - name: 'MockStack', + const inputs = createInputs({ template: 'https://s3.amazonaws.com/templates/myTemplate.template?versionId=123ab1cdeKdOW5IH4GAcYbEngcpTJTDW', - capabilities: 'CAPABILITY_IAM', - 'parameter-overrides': 'AdminEmail: no-reply@amazon.com', - 'no-fail-on-empty-changeset': '1', + 'fail-on-empty-changeset': '0', tags: '[{"Key":"Test","Value":"Value"}]' - } + }) jest.spyOn(core, 'getInput').mockImplementation((name: string) => { return inputs[name] @@ -505,40 +564,24 @@ describe('Deploy CloudFormation Stack', () => { await run() expect(core.setFailed).toHaveBeenCalledTimes(0) - expect(mockDescribeStacks).toHaveBeenCalledTimes(2) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack' - }) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(2, { - StackName: mockStackId - }) - expect(mockCreateStack).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack', - TemplateURL: - 'https://s3.amazonaws.com/templates/myTemplate.template?versionId=123ab1cdeKdOW5IH4GAcYbEngcpTJTDW', - TemplateBody: undefined, - Capabilities: ['CAPABILITY_IAM'], - Parameters: [ - { ParameterKey: 'AdminEmail', ParameterValue: 'no-reply@amazon.com' } - ], - Tags: [{ Key: 'Test', Value: 'Value' }], - DisableRollback: false, - EnableTerminationProtection: false - }) + expect(mockCfnClient).toHaveReceivedCommandTimes(DescribeStacksCommand, 4) + expect(mockCfnClient).toHaveReceivedCommandTimes(CreateChangeSetCommand, 1) + expect(mockCfnClient).toHaveReceivedCommandTimes(ExecuteChangeSetCommand, 1) expect(core.setOutput).toHaveBeenCalledTimes(1) - expect(core.setOutput).toHaveBeenNthCalledWith(1, 'stack-id', mockStackId) + expect(core.setOutput).toHaveBeenNthCalledWith( + 1, + 'stack-id', + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896' + ) }) test('deploys the stack with timeout', async () => { - const inputs: Inputs = { - name: 'MockStack', + const inputs = createInputs({ template: 'https://s3.amazonaws.com/templates/myTemplate.template?versionId=123ab1cdeKdOW5IH4GAcYbEngcpTJTDW', - capabilities: 'CAPABILITY_IAM', - 'parameter-overrides': 'AdminEmail: no-reply@amazon.com', - 'no-fail-on-empty-changeset': '1', + 'fail-on-empty-changeset': '0', 'timeout-in-minutes': '10' - } + }) jest.spyOn(core, 'getInput').mockImplementation((name: string) => { return inputs[name] @@ -547,668 +590,968 @@ describe('Deploy CloudFormation Stack', () => { await run() expect(core.setFailed).toHaveBeenCalledTimes(0) - expect(mockDescribeStacks).toHaveBeenCalledTimes(2) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack' - }) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(2, { - StackName: mockStackId - }) - expect(mockCreateStack).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack', - TemplateURL: - 'https://s3.amazonaws.com/templates/myTemplate.template?versionId=123ab1cdeKdOW5IH4GAcYbEngcpTJTDW', - TemplateBody: undefined, - Capabilities: ['CAPABILITY_IAM'], - Parameters: [ - { ParameterKey: 'AdminEmail', ParameterValue: 'no-reply@amazon.com' } - ], - TimeoutInMinutes: 10, - DisableRollback: false, - EnableTerminationProtection: false - }) + expect(mockCfnClient).toHaveReceivedCommandTimes(DescribeStacksCommand, 4) + expect(mockCfnClient).toHaveReceivedCommandTimes(CreateChangeSetCommand, 1) + expect(mockCfnClient).toHaveReceivedCommandTimes(ExecuteChangeSetCommand, 1) expect(core.setOutput).toHaveBeenCalledTimes(1) - expect(core.setOutput).toHaveBeenNthCalledWith(1, 'stack-id', mockStackId) + expect(core.setOutput).toHaveBeenNthCalledWith( + 1, + 'stack-id', + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896' + ) }) test('successfully update the stack', async () => { - mockDescribeStacks.mockReset() - mockDescribeStacks.mockImplementation(() => { - return { - promise(): Promise { - return Promise.resolve({ - Stacks: [ - { - StackId: - 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896', - Tags: [], - Outputs: [], - StackStatusReason: '', - CreationTime: new Date('2013-08-23T01:02:15.422Z'), - Capabilities: [], - StackName: 'MockStack', - StackStatus: 'CREATE_COMPLETE' - } - ] - }) - } - } - }) + mockCfnClient + .reset() + .on(DescribeStacksCommand) + .resolvesOnce({ + Stacks: [ + { + StackId: + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896', + Tags: [], + Outputs: [], + StackStatusReason: '', + CreationTime: new Date('2013-08-23T01:02:15.422Z'), + Capabilities: [], + StackName: 'MockStack', + StackStatus: 'CREATE_COMPLETE' + } + ] + }) + .resolves({ + Stacks: [ + { + StackId: + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896', + Tags: [], + Outputs: [], + StackStatusReason: '', + CreationTime: new Date('2013-08-23T01:02:15.422Z'), + Capabilities: [], + StackName: 'MockStack', + StackStatus: StackStatus.UPDATE_COMPLETE + } + ] + }) + .on(CreateChangeSetCommand) + .resolves({}) + .on(ExecuteChangeSetCommand) + .resolves({}) + .on(DescribeChangeSetCommand) + .resolvesOnce({ Status: ChangeSetStatus.CREATE_COMPLETE }) + .resolvesOnce({ + Status: ChangeSetStatus.CREATE_COMPLETE, + Changes: [], + ChangeSetId: 'test-changeset-id', + ChangeSetName: 'MockStack-CS' + }) await run() expect(core.setFailed).toHaveBeenCalledTimes(0) - expect(mockDescribeStacks).toHaveBeenCalledTimes(2) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack' - }) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(2, { - StackName: mockStackId - }) - expect(mockCreateStack).toHaveBeenCalledTimes(0) - expect(mockCreateChangeSet).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack', - TemplateBody: mockTemplate, - Capabilities: ['CAPABILITY_IAM'], - Parameters: [ - { ParameterKey: 'AdminEmail', ParameterValue: 'no-reply@amazon.com' } - ], - ChangeSetName: 'MockStack-CS', - ResourceType: undefined, - RollbackConfiguration: undefined, - NotificationARNs: undefined, - RoleARN: undefined, - Tags: undefined, - TemplateURL: undefined, - TimeoutInMinutes: undefined - }) - expect(mockExecuteChangeSet).toHaveBeenNthCalledWith(1, { - ChangeSetName: 'MockStack-CS', - StackName: 'MockStack' - }) - expect(mockCfnWaiter).toHaveBeenCalledTimes(2) + expect(mockCfnClient).toHaveReceivedCommandTimes(DescribeStacksCommand, 4) + expect(mockCfnClient).toHaveReceivedCommandTimes(CreateChangeSetCommand, 1) + expect(mockCfnClient).toHaveReceivedCommandTimes(ExecuteChangeSetCommand, 1) }) test('no execute change set on update the stack', async () => { - const inputs: Inputs = { - name: 'MockStack', - template: 'template.yaml', - capabilities: 'CAPABILITY_IAM', - 'parameter-overrides': 'AdminEmail: no-reply@amazon.com', + const inputs = createInputs({ 'no-execute-changeset': '1' - } + }) jest.spyOn(core, 'getInput').mockImplementation((name: string) => { return inputs[name] }) - mockDescribeStacks.mockReset() - mockDescribeStacks.mockImplementation(() => { - return { - promise(): Promise { - return Promise.resolve({ - Stacks: [ - { - StackId: - 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896', - Tags: [], - Outputs: [], - StackStatusReason: '', - CreationTime: new Date('2013-08-23T01:02:15.422Z'), - Capabilities: [], - StackName: 'MockStack', - StackStatus: 'CREATE_COMPLETE' - } - ] - }) - } - } - }) + mockCfnClient + .reset() + .on(DescribeStacksCommand) + .resolves({ + Stacks: [ + { + StackId: + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896', + Tags: [], + Outputs: [], + StackStatusReason: '', + CreationTime: new Date('2013-08-23T01:02:15.422Z'), + Capabilities: [], + StackName: 'MockStack', + StackStatus: 'CREATE_COMPLETE' + } + ] + }) + .on(CreateChangeSetCommand) + .resolves({}) + .on(ExecuteChangeSetCommand) + .resolves({}) + .on(DescribeChangeSetCommand) + .resolvesOnce({ Status: ChangeSetStatus.CREATE_COMPLETE }) + .resolvesOnce({ + Status: ChangeSetStatus.CREATE_COMPLETE, + Changes: [], + ChangeSetId: 'test-changeset-id', + ChangeSetName: 'MockStack-CS' + }) await run() expect(core.setFailed).toHaveBeenCalledTimes(0) - expect(mockDescribeStacks).toHaveBeenCalledTimes(2) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack' - }) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(2, { - StackName: mockStackId - }) - expect(mockCreateStack).toHaveBeenCalledTimes(0) - expect(mockCreateChangeSet).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack', - TemplateBody: mockTemplate, - Capabilities: ['CAPABILITY_IAM'], - Parameters: [ - { ParameterKey: 'AdminEmail', ParameterValue: 'no-reply@amazon.com' } - ], - ChangeSetName: 'MockStack-CS', - ResourceType: undefined, - RollbackConfiguration: undefined, - NotificationARNs: undefined, - RoleARN: undefined, - Tags: undefined, - TemplateURL: undefined, - TimeoutInMinutes: undefined - }) - expect(mockExecuteChangeSet).toHaveBeenCalledTimes(0) - expect(mockCfnWaiter).toHaveBeenCalledTimes(1) + expect(mockCfnClient).toHaveReceivedCommandTimes(DescribeStacksCommand, 2) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 1, + DescribeStacksCommand, + { + StackName: 'MockStack' + } + ) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 2, + CreateChangeSetCommand, + { + Capabilities: ['CAPABILITY_IAM'], + NotificationARNs: undefined, + Parameters: [ + { + ParameterKey: 'AdminEmail', + ParameterValue: 'no-reply@amazon.com' + } + ], + ResourceTypes: undefined, + RoleARN: undefined, + RollbackConfiguration: undefined, + StackName: 'MockStack', + Tags: undefined, + TemplateBody: mockTemplate, + TemplateURL: undefined + } + ) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 3, + DescribeChangeSetCommand, + { + ChangeSetName: 'MockStack-CS', + StackName: 'MockStack' + } + ) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 5, + DescribeStacksCommand, + { + StackName: + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896' + } + ) + expect(mockCfnClient).toHaveReceivedCommandTimes(CreateChangeSetCommand, 1) + expect(mockCfnClient).toHaveReceivedCommandTimes(ExecuteChangeSetCommand, 0) }) - test('error is caught updating if create change fails', async () => { - mockDescribeStacks.mockReset() - mockDescribeStacks.mockImplementation(() => { - return { - promise(): Promise { - return Promise.resolve({ - Stacks: [ - { - StackId: - 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896', - Tags: [], - Outputs: [], - StackStatusReason: '', - CreationTime: new Date('2013-08-23T01:02:15.422Z'), - Capabilities: [], - StackName: 'MockStack', - StackStatus: 'CREATE_COMPLETE', - DisableRollback: false - } - ] - }) - } + test('error is caught if CloudFormation throws an unexpected Service Exception', async () => { + const cause = new CloudFormationServiceException({ + name: 'CloudFormationServiceException', + $fault: 'server', + $metadata: { + httpStatusCode: 500 } }) - mockDescribeChangeSet.mockImplementation(() => { - return { - promise(): Promise { - return Promise.resolve({ - Changes: [], - ChangeSetName: 'MockStack-CS', - ChangeSetId: - 'arn:aws:cloudformation:us-west-2:123456789012:changeSet/my-change-set/4eca1a01-e285-xmpl-8026-9a1967bfb4b0', - StackId: mockStackId, - StackName: 'MockStack', - Description: null, - Parameters: null, - CreationTime: '2019-10-02T05:20:56.651Z', - ExecutionStatus: 'AVAILABLE', - Status: 'FAILED', - StatusReason: null, - NotificationARNs: [], - RollbackConfiguration: {}, - Capabilities: ['CAPABILITY_IAM'], - Tags: null - }) - } - } - }) + mockCfnClient.reset().onAnyCommand().rejects(cause) - mockCfnWaiter.mockImplementation(() => { - return { - promise(): Promise { - return Promise.reject({}) - } - } - }) + await run() + + expect(core.setFailed).toHaveBeenCalledTimes(1) + expect(mockCfnClient).toHaveReceivedCommandTimes(DescribeStacksCommand, 1) + expect(mockCfnClient).toHaveReceivedCommandTimes(CreateChangeSetCommand, 0) + expect(mockCfnClient).toHaveReceivedCommandTimes(ExecuteChangeSetCommand, 0) + }) + + // Oh, wicked, bad, naughty, evil Zoot! + test('error is caught if CloudFormation acts unexpectedly', async () => { + mockCfnClient.on(DescribeStacksCommand).resolvesOnce({}) await run() expect(core.setFailed).toHaveBeenCalledTimes(1) - expect(mockDescribeStacks).toHaveBeenCalledTimes(1) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack' - }) - expect(mockCreateStack).toHaveBeenCalledTimes(0) - expect(mockCreateChangeSet).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack', - TemplateBody: mockTemplate, - Capabilities: ['CAPABILITY_IAM'], - Parameters: [ - { ParameterKey: 'AdminEmail', ParameterValue: 'no-reply@amazon.com' } - ], - ChangeSetName: 'MockStack-CS', - ResourceTypes: undefined, - RollbackConfiguration: undefined, - NotificationARNs: undefined, - RoleARN: undefined, - Tags: undefined, - TemplateURL: undefined, - TimeoutInMinutes: undefined - }) - expect(mockDeleteChangeSet).toHaveBeenNthCalledWith(1, { - ChangeSetName: 'MockStack-CS', - StackName: 'MockStack' - }) - expect(mockExecuteChangeSet).toHaveBeenCalledTimes(0) + expect(mockCfnClient).toHaveReceivedCommandTimes(DescribeStacksCommand, 1) + expect(mockCfnClient).toHaveReceivedCommandTimes(CreateChangeSetCommand, 0) + expect(mockCfnClient).toHaveReceivedCommandTimes(ExecuteChangeSetCommand, 0) + }) + + test('error is caught updating if create change fails', async () => { + mockCfnClient + .reset() + .on(DescribeStacksCommand) + .resolves({ + Stacks: [ + { + StackId: + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896', + Tags: [], + Outputs: [], + StackStatusReason: '', + CreationTime: new Date('2013-08-23T01:02:15.422Z'), + Capabilities: [], + StackName: 'MockStack', + StackStatus: 'CREATE_COMPLETE', + DisableRollback: false + } + ] + }) + .on(DeleteChangeSetCommand) + .resolves({}) + .on(DescribeChangeSetCommand) + .resolves({ + Status: ChangeSetStatus.FAILED + }) + + await run() + + expect(core.setFailed).toHaveBeenCalledTimes(1) + expect(mockCfnClient).toHaveReceivedCommandTimes(DescribeStacksCommand, 1) + expect(mockCfnClient).toHaveReceivedCommandTimes(CreateChangeSetCommand, 1) + expect(mockCfnClient).toHaveReceivedCommandTimes(ExecuteChangeSetCommand, 0) }) test('no error if updating fails with empty change set', async () => { - const inputs: Inputs = { - name: 'MockStack', - template: 'template.yaml', - capabilities: 'CAPABILITY_IAM', - 'parameter-overrides': 'AdminEmail: no-reply@amazon.com', - 'no-fail-on-empty-changeset': '1' - } + const inputs = createInputs({ + 'fail-on-empty-changeset': '0' + }) jest.spyOn(core, 'getInput').mockImplementation((name: string) => { return inputs[name] }) - mockDescribeStacks.mockReset() - mockDescribeStacks.mockImplementation(() => { - return { - promise(): Promise { - return Promise.resolve({ - Stacks: [ - { - StackId: - 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896', - Tags: [], - Outputs: [], - StackStatusReason: `The submitted information didn't contain changes`, - CreationTime: new Date('2013-08-23T01:02:15.422Z'), - Capabilities: [], - StackName: 'MockStack', - StackStatus: 'FAILED', - DisableRollback: false - } - ] - }) - } - } + mockCfnClient + .reset() + .on(DescribeStacksCommand) + .resolvesOnce({ + Stacks: [ + { + StackId: + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896', + Tags: [], + Outputs: [], + StackStatusReason: `The submitted information didn't contain changes`, + CreationTime: new Date('2013-08-23T01:02:15.422Z'), + Capabilities: [], + StackName: 'MockStack', + StackStatus: StackStatus.CREATE_FAILED, + DisableRollback: false + } + ] + }) + .resolves({ + Stacks: [ + { + StackId: + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896', + Tags: [], + Outputs: [], + StackStatusReason: `The submitted information didn't contain changes`, + CreationTime: new Date('2013-08-23T01:02:15.422Z'), + Capabilities: [], + StackName: 'MockStack', + StackStatus: StackStatus.UPDATE_ROLLBACK_COMPLETE, + DisableRollback: false + } + ] + }) + .on(DescribeChangeSetCommand) + .resolves({ + Status: ChangeSetStatus.FAILED, + StatusReason: "The submitted information didn't contain changes" + }) + .on(CreateChangeSetCommand) + .resolves({ + Id: 'arn:aws:cloudformation:us-west-2:123456789012:changeSet/my-change-set/4eca1a01-e285-xmpl-8026-9a1967bfb4b0' + }) + + await run() + + expect(core.setFailed).toHaveBeenCalledTimes(0) + expect(mockCfnClient).toHaveReceivedCommandTimes(DescribeStacksCommand, 2) + expect(mockCfnClient).toHaveReceivedCommandTimes(CreateChangeSetCommand, 1) + expect(mockCfnClient).toHaveReceivedCommandTimes(ExecuteChangeSetCommand, 0) + }) + + test('error if noFailOnEmptyChangeSet but updating fails with empty change set and unexpected error message', async () => { + const inputs = createInputs({ + 'fail-on-empty-changeset': '0' }) - mockCfnWaiter.mockImplementation(() => { - return { - promise(): Promise { - return Promise.reject({}) - } - } + jest.spyOn(core, 'getInput').mockImplementation((name: string) => { + return inputs[name] }) - mockDescribeChangeSet.mockImplementation(() => { - return { - promise(): Promise { - return Promise.resolve({ - Changes: [], - ChangeSetName: 'MockStack-CS', - ChangeSetId: - 'arn:aws:cloudformation:us-west-2:123456789012:changeSet/my-change-set/4eca1a01-e285-xmpl-8026-9a1967bfb4b0', - StackId: mockStackId, + mockCfnClient + .reset() + .on(DescribeStacksCommand) + .resolvesOnce({ + Stacks: [ + { + StackId: + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896', + Tags: [], + Outputs: [], + StackStatusReason: `The submitted information didn't contain changes`, + CreationTime: new Date('2013-08-23T01:02:15.422Z'), + Capabilities: [], StackName: 'MockStack', - Description: null, - Parameters: null, - CreationTime: '2019-10-02T05:20:56.651Z', - ExecutionStatus: 'AVAILABLE', - Status: 'FAILED', - StatusReason: - "The submitted information didn't contain changes. Submit different information to create a change set.", - NotificationARNs: [], - RollbackConfiguration: {}, - Capabilities: ['CAPABILITY_IAM'], - Tags: null - }) - } - } - }) + StackStatus: StackStatus.CREATE_FAILED, + DisableRollback: false + } + ] + }) + .resolves({ + Stacks: [ + { + StackId: + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896', + Tags: [], + Outputs: [], + StackStatusReason: `The submitted information didn't contain changes`, + CreationTime: new Date('2013-08-23T01:02:15.422Z'), + Capabilities: [], + StackName: 'MockStack', + StackStatus: StackStatus.UPDATE_ROLLBACK_COMPLETE, + DisableRollback: false + } + ] + }) + .on(DescribeChangeSetCommand) + .resolves({ + Status: ChangeSetStatus.FAILED, + StatusReason: 'Something very odd occurred. See me after class.' + }) + .on(CreateChangeSetCommand) + .resolves({ + Id: 'arn:aws:cloudformation:us-west-2:123456789012:changeSet/my-change-set/4eca1a01-e285-xmpl-8026-9a1967bfb4b0' + }) await run() - expect(core.setFailed).toHaveBeenCalledTimes(0) - expect(core.setOutput).toHaveBeenCalledTimes(1) - expect(mockDescribeStacks).toHaveBeenCalledTimes(2) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack' - }) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(2, { - StackName: mockStackId - }) - expect(mockCreateStack).toHaveBeenCalledTimes(0) - expect(mockCreateChangeSet).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack', - TemplateBody: mockTemplate, - Capabilities: ['CAPABILITY_IAM'], - Parameters: [ - { ParameterKey: 'AdminEmail', ParameterValue: 'no-reply@amazon.com' } - ], - ChangeSetName: 'MockStack-CS', - NotificationARNs: undefined, - ResourceTypes: undefined, - RollbackConfiguration: undefined, - RoleARN: undefined, - Tags: undefined, - TemplateURL: undefined, - TimeoutInMinutes: undefined - }) - expect(mockDeleteChangeSet).toHaveBeenNthCalledWith(1, { - ChangeSetName: 'MockStack-CS', - StackName: 'MockStack' - }) - expect(mockExecuteChangeSet).toHaveBeenCalledTimes(0) + expect(core.setFailed).toHaveBeenCalledTimes(1) + expect(core.setOutput).toHaveBeenCalledTimes(0) + expect(mockCfnClient).toHaveReceivedCommandTimes(DescribeStacksCommand, 1) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 1, + DescribeStacksCommand, + { + StackName: 'MockStack' + } + ) + expect(mockCfnClient).toHaveReceivedCommandTimes(CreateChangeSetCommand, 1) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 2, + CreateChangeSetCommand, + { + Capabilities: ['CAPABILITY_IAM'], + NotificationARNs: undefined, + Parameters: [ + { + ParameterKey: 'AdminEmail', + ParameterValue: 'no-reply@amazon.com' + } + ], + ResourceTypes: undefined, + RoleARN: undefined, + RollbackConfiguration: undefined, + StackName: 'MockStack', + Tags: undefined, + TemplateBody: mockTemplate, + TemplateURL: undefined + } + ) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 3, + DescribeChangeSetCommand, + { + ChangeSetName: 'MockStack-CS', + StackName: 'MockStack' + } + ) + expect(mockCfnClient).toHaveReceivedCommandTimes(ExecuteChangeSetCommand, 0) }) - test('no deleting change set if change set is empty', async () => { - const inputs: Inputs = { - name: 'MockStack', - template: 'template.yaml', - capabilities: 'CAPABILITY_IAM', - 'parameter-overrides': 'AdminEmail: no-reply@amazon.com', - 'no-fail-on-empty-changeset': '1', - 'no-delete-failed-changeset': '1' - } + test('error if noFailOnEmptyChangeSet but updating fails with empty change set but no reason is given', async () => { + const inputs = createInputs({ + 'fail-on-empty-changeset': '0' + }) jest.spyOn(core, 'getInput').mockImplementation((name: string) => { return inputs[name] }) - mockDescribeStacks.mockReset() - mockDescribeStacks.mockImplementation(() => { - return { - promise(): Promise { - return Promise.resolve({ - Stacks: [ - { - StackId: - 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896', - Tags: [], - Outputs: [], - StackStatusReason: `The submitted information didn't contain changes`, - CreationTime: new Date('2013-08-23T01:02:15.422Z'), - Capabilities: [], - StackName: 'MockStack', - StackStatus: 'FAILED', - DisableRollback: false - } - ] - }) - } + mockCfnClient + .reset() + .on(DescribeStacksCommand) + .resolvesOnce({ + Stacks: [ + { + StackId: + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896', + Tags: [], + Outputs: [], + StackStatusReason: `The submitted information didn't contain changes`, + CreationTime: new Date('2013-08-23T01:02:15.422Z'), + Capabilities: [], + StackName: 'MockStack', + StackStatus: StackStatus.CREATE_FAILED, + DisableRollback: false + } + ] + }) + .resolves({ + Stacks: [ + { + StackId: + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896', + Tags: [], + Outputs: [], + StackStatusReason: `The submitted information didn't contain changes`, + CreationTime: new Date('2013-08-23T01:02:15.422Z'), + Capabilities: [], + StackName: 'MockStack', + StackStatus: StackStatus.UPDATE_ROLLBACK_COMPLETE, + DisableRollback: false + } + ] + }) + .on(DescribeChangeSetCommand) + .resolves({ + Status: ChangeSetStatus.FAILED + }) + .on(CreateChangeSetCommand) + .resolves({ + Id: 'arn:aws:cloudformation:us-west-2:123456789012:changeSet/my-change-set/4eca1a01-e285-xmpl-8026-9a1967bfb4b0' + }) + + await run() + + expect(core.setFailed).toHaveBeenCalledTimes(1) + expect(core.setOutput).toHaveBeenCalledTimes(0) + expect(mockCfnClient).toHaveReceivedCommandTimes(DescribeStacksCommand, 1) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 1, + DescribeStacksCommand, + { + StackName: 'MockStack' + } + ) + expect(mockCfnClient).toHaveReceivedCommandTimes(CreateChangeSetCommand, 1) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 2, + CreateChangeSetCommand, + { + Capabilities: ['CAPABILITY_IAM'], + NotificationARNs: undefined, + Parameters: [ + { + ParameterKey: 'AdminEmail', + ParameterValue: 'no-reply@amazon.com' + } + ], + ResourceTypes: undefined, + RoleARN: undefined, + RollbackConfiguration: undefined, + StackName: 'MockStack', + Tags: undefined, + TemplateBody: mockTemplate, + TemplateURL: undefined + } + ) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 3, + DescribeChangeSetCommand, + { + ChangeSetName: 'MockStack-CS', + StackName: 'MockStack' } + ) + expect(mockCfnClient).toHaveReceivedCommandTimes(ExecuteChangeSetCommand, 0) + }) + + test('no deleting change set if change set is empty', async () => { + const inputs = createInputs({ + 'fail-on-empty-changeset': '0', + 'no-delete-failed-changeset': '1' }) - mockCfnWaiter.mockImplementation(() => { - return { - promise(): Promise { - return Promise.reject({}) - } - } + jest.spyOn(core, 'getInput').mockImplementation((name: string) => { + return inputs[name] }) - mockDescribeChangeSet.mockImplementation(() => { - return { - promise(): Promise { - return Promise.resolve({ - Changes: [], - ChangeSetName: 'MockStack-CS', - ChangeSetId: - 'arn:aws:cloudformation:us-west-2:123456789012:changeSet/my-change-set/4eca1a01-e285-xmpl-8026-9a1967bfb4b0', - StackId: mockStackId, + mockCfnClient + .reset() + .on(DescribeStacksCommand) + .resolves({ + Stacks: [ + { + StackId: + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896', + Tags: [], + Outputs: [], + StackStatusReason: `The submitted information didn't contain changes`, + CreationTime: new Date('2013-08-23T01:02:15.422Z'), + Capabilities: [], StackName: 'MockStack', - Description: null, - Parameters: null, - CreationTime: '2019-10-02T05:20:56.651Z', - ExecutionStatus: 'AVAILABLE', - Status: 'FAILED', - StatusReason: - "The submitted information didn't contain changes. Submit different information to create a change set.", - NotificationARNs: [], - RollbackConfiguration: {}, - Capabilities: ['CAPABILITY_IAM'], - Tags: null - }) - } - } - }) + StackStatus: StackStatus.UPDATE_FAILED, + DisableRollback: false + } + ] + }) + .on(DescribeChangeSetCommand) + .resolves({ + Status: ChangeSetStatus.FAILED, + StatusReason: + "The submitted information didn't contain changes. Submit different information to create a change set." + }) + .on(CreateChangeSetCommand) + .resolves({ + Id: 'arn:aws:cloudformation:us-west-2:123456789012:changeSet/my-change-set/4eca1a01-e285-xmpl-8026-9a1967bfb4b0' + }) await run() expect(core.setFailed).toHaveBeenCalledTimes(0) - expect(core.setOutput).toHaveBeenCalledTimes(1) - expect(mockDescribeStacks).toHaveBeenCalledTimes(2) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack' - }) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(2, { - StackName: mockStackId - }) - expect(mockCreateStack).toHaveBeenCalledTimes(0) - expect(mockCreateChangeSet).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack', - TemplateBody: mockTemplate, - Capabilities: ['CAPABILITY_IAM'], - Parameters: [ - { ParameterKey: 'AdminEmail', ParameterValue: 'no-reply@amazon.com' } - ], - ChangeSetName: 'MockStack-CS', - NotificationARNs: undefined, - ResourceTypes: undefined, - RollbackConfiguration: undefined, - RoleARN: undefined, - Tags: undefined, - TemplateURL: undefined, - TimeoutInMinutes: undefined - }) - expect(mockDeleteChangeSet).toHaveBeenCalledTimes(0) - expect(mockExecuteChangeSet).toHaveBeenCalledTimes(0) + expect(core.setOutput).toHaveBeenCalledTimes(7) + expect(mockCfnClient).toHaveReceivedCommandTimes(DescribeStacksCommand, 2) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 1, + DescribeStacksCommand, + { + StackName: 'MockStack' + } + ) + expect(mockCfnClient).toHaveReceivedCommandTimes(CreateChangeSetCommand, 1) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 2, + CreateChangeSetCommand, + { + Capabilities: ['CAPABILITY_IAM'], + NotificationARNs: undefined, + Parameters: [ + { + ParameterKey: 'AdminEmail', + ParameterValue: 'no-reply@amazon.com' + } + ], + ResourceTypes: undefined, + RoleARN: undefined, + RollbackConfiguration: undefined, + StackName: 'MockStack', + Tags: undefined, + TemplateBody: mockTemplate, + TemplateURL: undefined + } + ) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 3, + DescribeChangeSetCommand, + { + ChangeSetName: 'MockStack-CS', + StackName: 'MockStack' + } + ) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 4, + DescribeChangeSetCommand, + { + ChangeSetName: 'MockStack-CS', + StackName: 'MockStack' + } + ) + expect(mockCfnClient).toHaveReceivedCommandTimes(ExecuteChangeSetCommand, 0) + expect(mockCfnClient).toHaveReceivedCommandTimes(DeleteChangeSetCommand, 0) }) test('change set is not deleted if creating change set fails', async () => { - const inputs: Inputs = { - name: 'MockStack', - template: 'template.yaml', - capabilities: 'CAPABILITY_IAM', - 'parameter-overrides': 'AdminEmail: no-reply@amazon.com', + const inputs = createInputs({ 'no-delete-failed-changeset': '1' - } + }) jest.spyOn(core, 'getInput').mockImplementation((name: string) => { return inputs[name] }) - mockDescribeStacks.mockReset() - mockDescribeStacks.mockImplementation(() => { - return { - promise(): Promise { - return Promise.resolve({ - Stacks: [ - { - StackId: - 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896', - Tags: [], - Outputs: [], - StackStatusReason: '', - CreationTime: new Date('2013-08-23T01:02:15.422Z'), - Capabilities: [], - StackName: 'MockStack', - StackStatus: 'CREATE_COMPLETE', - DisableRollback: false - } - ] - }) - } + mockCfnClient.reset() + mockCfnClient + .on(DescribeStacksCommand) + .resolves({ + Stacks: [ + { + StackId: + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896', + Tags: [], + Outputs: [], + StackStatusReason: '', + CreationTime: new Date('2013-08-23T01:02:15.422Z'), + Capabilities: [], + StackName: 'MockStack', + StackStatus: 'CREATE_COMPLETE', + DisableRollback: false + } + ] + }) + .on(DescribeChangeSetCommand) + .resolves({ + Status: ChangeSetStatus.FAILED, + StatusReason: '' + }) + .on(CreateChangeSetCommand) + .resolves({ + Id: 'arn:aws:cloudformation:us-west-2:123456789012:changeSet/my-change-set/4eca1a01-e285-xmpl-8026-9a1967bfb4b0' + }) + + await run() + + expect(core.setFailed).toHaveBeenCalledTimes(1) + expect(mockCfnClient).toHaveReceivedCommandTimes(DescribeStacksCommand, 1) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 1, + DescribeStacksCommand, + { + StackName: 'MockStack' + } + ) + expect(mockCfnClient).toHaveReceivedCommandTimes(CreateChangeSetCommand, 1) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 2, + CreateChangeSetCommand, + { + Capabilities: ['CAPABILITY_IAM'], + NotificationARNs: undefined, + Parameters: [ + { + ParameterKey: 'AdminEmail', + ParameterValue: 'no-reply@amazon.com' + } + ], + ResourceTypes: undefined, + RoleARN: undefined, + RollbackConfiguration: undefined, + StackName: 'MockStack', + Tags: undefined, + TemplateBody: mockTemplate, + TemplateURL: undefined } + ) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 3, + DescribeChangeSetCommand, + { + ChangeSetName: 'MockStack-CS', + StackName: 'MockStack' + } + ) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 4, + DescribeChangeSetCommand, + { + ChangeSetName: 'MockStack-CS', + StackName: 'MockStack' + } + ) + expect(mockCfnClient).toHaveReceivedCommandTimes(ExecuteChangeSetCommand, 0) + expect(mockCfnClient).toHaveReceivedCommandTimes(DeleteChangeSetCommand, 0) + }) + + test('no error if updating fails with no updates to be performed', async () => { + const inputs = createInputs({ + 'fail-on-empty-changeset': '0' }) - mockDescribeChangeSet.mockImplementation(() => { - return { - promise(): Promise { - return Promise.resolve({ - Changes: [], - ChangeSetName: 'MockStack-CS', - ChangeSetId: - 'arn:aws:cloudformation:us-west-2:123456789012:changeSet/my-change-set/4eca1a01-e285-xmpl-8026-9a1967bfb4b0', - StackId: mockStackId, - StackName: 'MockStack', - Description: null, - Parameters: null, - CreationTime: '2019-10-02T05:20:56.651Z', - ExecutionStatus: 'AVAILABLE', - Status: 'FAILED', - StatusReason: null, - NotificationARNs: [], - RollbackConfiguration: {}, - Capabilities: ['CAPABILITY_IAM'], - Tags: null - }) - } - } + jest.spyOn(core, 'getInput').mockImplementation((name: string) => { + return inputs[name] }) - mockCfnWaiter.mockImplementation(() => { - return { - promise(): Promise { - return Promise.reject({}) - } + mockCfnClient + .reset() + .on(DescribeStacksCommand) + .resolves({ + Stacks: [ + { + StackId: + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896', + Tags: [], + Outputs: [], + StackStatusReason: '', + CreationTime: new Date('2013-08-23T01:02:15.422Z'), + Capabilities: [], + StackName: 'MockStack', + StackStatus: StackStatus.UPDATE_COMPLETE, + DisableRollback: false + } + ] + }) + .on(DescribeChangeSetCommand) + .resolves({ + Status: ChangeSetStatus.FAILED, + StatusReason: 'No updates are to be performed' + }) + .on(CreateChangeSetCommand) + .resolves({ + Id: 'arn:aws:cloudformation:us-west-2:123456789012:changeSet/my-change-set/4eca1a01-e285-xmpl-8026-9a1967bfb4b0' + }) + + await run() + + expect(core.setFailed).toHaveBeenCalledTimes(0) + expect(core.setOutput).toHaveBeenCalledTimes(7) + expect(mockCfnClient).toHaveReceivedCommandTimes(DescribeStacksCommand, 2) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 1, + DescribeStacksCommand, + { + StackName: 'MockStack' } - }) + ) + expect(mockCfnClient).toHaveReceivedCommandTimes(CreateChangeSetCommand, 1) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 2, + CreateChangeSetCommand, + { + StackName: 'MockStack', + TemplateBody: mockTemplate, + Capabilities: ['CAPABILITY_IAM'], + Parameters: [ + { ParameterKey: 'AdminEmail', ParameterValue: 'no-reply@amazon.com' } + ], + ChangeSetName: 'MockStack-CS', + NotificationARNs: undefined, + ResourceTypes: undefined, + RollbackConfiguration: undefined, + RoleARN: undefined, + Tags: undefined, + TemplateURL: undefined + } + ) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 3, + DescribeChangeSetCommand, + { + ChangeSetName: 'MockStack-CS', + StackName: 'MockStack' + } + ) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 4, + DescribeChangeSetCommand, + { + ChangeSetName: 'MockStack-CS', + StackName: 'MockStack' + } + ) + expect(mockCfnClient).toHaveReceivedCommandTimes(ExecuteChangeSetCommand, 0) + }) + + test('error is caught by core.setFailed', async () => { + mockCfnClient.reset().on(DescribeStacksCommand).rejects(new Error()) await run() - expect(core.setFailed).toHaveBeenCalledTimes(1) - expect(mockDescribeStacks).toHaveBeenCalledTimes(1) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack' - }) - expect(mockCreateStack).toHaveBeenCalledTimes(0) - expect(mockCreateChangeSet).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack', - TemplateBody: mockTemplate, - Capabilities: ['CAPABILITY_IAM'], - Parameters: [ - { ParameterKey: 'AdminEmail', ParameterValue: 'no-reply@amazon.com' } - ], - ChangeSetName: 'MockStack-CS', - ResourceTypes: undefined, - RollbackConfiguration: undefined, - NotificationARNs: undefined, - RoleARN: undefined, - Tags: undefined, - TemplateURL: undefined, - TimeoutInMinutes: undefined - }) - expect(mockDeleteChangeSet).toHaveBeenCalledTimes(0) - expect(mockExecuteChangeSet).toHaveBeenCalledTimes(0) + expect(core.setFailed).toHaveBeenCalled() }) - test('no error if updating fails with no updates to be performed', async () => { - const inputs: Inputs = { - name: 'MockStack', - template: 'template.yaml', - capabilities: 'CAPABILITY_IAM', - 'parameter-overrides': ` - AdminEmail: - no-reply@amazon.com - `, - 'no-fail-on-empty-changeset': '1' - } + test('deploy using a custom change-set name', async () => { + const inputs = createInputs({ + capabilities: 'CAPABILITY_IAM, CAPABILITY_AUTO_EXPAND', + 'change-set-name': 'Build-213123123-CS', + 'fail-on-empty-changeset': '0' + }) jest.spyOn(core, 'getInput').mockImplementation((name: string) => { return inputs[name] }) - mockDescribeStacks.mockReset() - mockDescribeStacks.mockImplementation(() => { - return { - promise(): Promise { - return Promise.resolve({ - Stacks: [ - { - StackId: - 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896', - Tags: [], - Outputs: [], - StackStatusReason: '', - CreationTime: new Date('2013-08-23T01:02:15.422Z'), - Capabilities: [], - StackName: 'MockStack', - StackStatus: 'UPDATE_COMPLETE', - DisableRollback: false - } - ] - }) - } - } - }) + mockCfnClient + .reset() + .on(DescribeStacksCommand) + .resolves({ + Stacks: [ + { + StackId: + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896', + Tags: [], + Outputs: [], + StackStatusReason: '', + CreationTime: new Date('2013-08-23T01:02:15.422Z'), + Capabilities: [], + StackName: 'MockStack', + StackStatus: 'CREATE_COMPLETE' + } + ] + }) + .resolves({ + Stacks: [ + { + StackId: + 'arn:aws:cloudformation:us-east-1:123456789012:stack/myteststack/466df9e0-0dff-08e3-8e2f-5088487c4896', + Tags: [], + Outputs: [], + StackStatusReason: '', + CreationTime: new Date('2013-08-23T01:02:15.422Z'), + Capabilities: [], + StackName: 'MockStack', + StackStatus: StackStatus.UPDATE_COMPLETE + } + ] + }) + .on(CreateChangeSetCommand) + .resolves({}) + .on(ExecuteChangeSetCommand) + .resolves({}) + .on(DescribeChangeSetCommand) + .resolves({ Status: ChangeSetStatus.CREATE_COMPLETE }) - mockCfnWaiter.mockImplementation(() => { - return { - promise(): Promise { - return Promise.reject({}) - } + await run() + expect(core.setFailed).toHaveBeenCalledTimes(0) + expect(mockCfnClient).toHaveReceivedNthCommandWith( + 2, + CreateChangeSetCommand, + { + StackName: 'MockStack', + TemplateBody: mockTemplate, + Capabilities: ['CAPABILITY_IAM', 'CAPABILITY_AUTO_EXPAND'], + Parameters: [ + { ParameterKey: 'AdminEmail', ParameterValue: 'no-reply@amazon.com' } + ], + ChangeSetName: 'Build-213123123-CS', + NotificationARNs: undefined, + ResourceTypes: undefined, + RollbackConfiguration: undefined, + RoleARN: undefined, + Tags: undefined, + TemplateURL: undefined } + ) + }) + + it('create-only mode creates change set without executing', async () => { + jest.spyOn(core, 'getInput').mockImplementation((name: string) => { + const inputs = createInputs({ + mode: 'create-only' + }) + return inputs[name] }) - mockDescribeChangeSet.mockImplementation(() => { - return { - promise(): Promise { - return Promise.resolve({ - Changes: [], - ChangeSetName: 'MockStack-CS', - ChangeSetId: - 'arn:aws:cloudformation:us-west-2:123456789012:changeSet/my-change-set/4eca1a01-e285-xmpl-8026-9a1967bfb4b0', + mockCfnClient + .reset() + .on(DescribeStacksCommand) + .resolves({ + Stacks: [ + { StackId: mockStackId, StackName: 'MockStack', - Description: null, - Parameters: null, - CreationTime: '2019-10-02T05:20:56.651Z', - ExecutionStatus: 'AVAILABLE', - Status: 'FAILED', - StatusReason: 'No updates are to be performed', - NotificationARNs: [], - RollbackConfiguration: {}, - Capabilities: ['CAPABILITY_IAM'], - Tags: null - }) - } - } - }) + StackStatus: StackStatus.CREATE_COMPLETE, + CreationTime: new Date(), + Tags: [], + Outputs: [] + } + ] + }) + .on(CreateChangeSetCommand) + .resolves({ Id: 'test-changeset-id' }) + .on(DescribeChangeSetCommand) + .resolves({ + ChangeSetId: 'test-changeset-id', + ChangeSetName: 'test-changeset', + Status: ChangeSetStatus.CREATE_COMPLETE, + Changes: [{ Type: 'Resource' }] + }) await run() - expect(core.setFailed).toHaveBeenCalledTimes(0) - expect(core.setOutput).toHaveBeenCalledTimes(1) - expect(mockDescribeStacks).toHaveBeenCalledTimes(2) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(1, { + expect(mockCfnClient).toHaveReceivedCommandWith(CreateChangeSetCommand, { StackName: 'MockStack' }) - expect(mockDescribeStacks).toHaveBeenNthCalledWith(2, { - StackName: mockStackId - }) - expect(mockCreateStack).toHaveBeenCalledTimes(0) - expect(mockCreateChangeSet).toHaveBeenNthCalledWith(1, { - StackName: 'MockStack', - TemplateBody: mockTemplate, - Capabilities: ['CAPABILITY_IAM'], - Parameters: [ - { ParameterKey: 'AdminEmail', ParameterValue: 'no-reply@amazon.com' } - ], - ChangeSetName: 'MockStack-CS', - NotificationARNs: undefined, - ResourceTypes: undefined, - RollbackConfiguration: undefined, - RoleARN: undefined, - Tags: undefined, - TemplateURL: undefined, - TimeoutInMinutes: undefined + expect(mockCfnClient).not.toHaveReceivedCommand(ExecuteChangeSetCommand) + expect(core.setOutput).toHaveBeenCalledWith( + 'change-set-id', + 'test-changeset-id' + ) + expect(core.setOutput).toHaveBeenCalledWith('has-changes', 'true') + }) + + it('execute-only mode executes existing change set', async () => { + const changeSetId = + 'arn:aws:cloudformation:us-east-1:123456789012:changeSet/test-cs/abc123' + + jest.spyOn(core, 'getInput').mockImplementation((name: string) => { + const inputs = createInputs({ + mode: 'execute-only', + 'execute-change-set-id': changeSetId + }) + return inputs[name] }) - expect(mockDeleteChangeSet).toHaveBeenNthCalledWith(1, { - ChangeSetName: 'MockStack-CS', + + mockCfnClient + .reset() + .on(ExecuteChangeSetCommand) + .resolves({}) + .on(DescribeStacksCommand) + .resolves({ + Stacks: [ + { + StackId: mockStackId, + StackName: 'MockStack', + StackStatus: StackStatus.UPDATE_COMPLETE, + CreationTime: new Date(), + Tags: [], + Outputs: [] + } + ] + }) + + await run() + expect(core.setFailed).toHaveBeenCalledTimes(0) + expect(mockCfnClient).toHaveReceivedCommandWith(ExecuteChangeSetCommand, { + ChangeSetName: changeSetId, StackName: 'MockStack' }) - expect(mockExecuteChangeSet).toHaveBeenCalledTimes(0) + expect(mockCfnClient).not.toHaveReceivedCommand(CreateChangeSetCommand) + expect(core.setOutput).toHaveBeenCalledWith('stack-id', mockStackId) }) - test('error is caught by core.setFailed', async () => { - mockDescribeStacks.mockReset() - mockDescribeStacks.mockImplementation(() => { - throw new Error() + it('create-only mode with empty change set', async () => { + jest.spyOn(core, 'getInput').mockImplementation((name: string) => { + const inputs = createInputs({ + mode: 'create-only', + 'fail-on-empty-changeset': '0' + }) + return inputs[name] }) - await run() + mockCfnClient + .reset() + .on(DescribeStacksCommand) + .resolves({ + Stacks: [ + { + StackId: mockStackId, + StackName: 'MockStack', + StackStatus: StackStatus.CREATE_COMPLETE, + CreationTime: new Date(), + Tags: [], + Outputs: [] + } + ] + }) + .on(CreateChangeSetCommand) + .resolves({ Id: 'test-changeset-id' }) + .on(DescribeChangeSetCommand) + .resolves({ + Status: ChangeSetStatus.FAILED, + StatusReason: "The submitted information didn't contain changes." + }) + .on(DeleteChangeSetCommand) + .resolves({}) - expect(core.setFailed).toBeCalled() + await run() + expect(core.setFailed).toHaveBeenCalledTimes(0) + expect(core.setOutput).toHaveBeenCalledWith('has-changes', 'false') + expect(core.setOutput).toHaveBeenCalledWith('changes-count', '0') }) }) diff --git a/__tests__/params.test.json b/__tests__/params.test.json index bf76bb0..54cde79 100644 --- a/__tests__/params.test.json +++ b/__tests__/params.test.json @@ -1,6 +1,10 @@ -{ - "Parameters": { - "MyParam1": "myValue1", - "MyParam2": "myValue2" +[ + { + "ParameterKey": "MyParam1", + "ParameterValue": "myValue1" + }, + { + "ParameterKey": "MyParam2", + "ParameterValue": "myValue2" } -} +] diff --git a/__tests__/utils.test.ts b/__tests__/utils.test.ts index a05f5e3..9373443 100644 --- a/__tests__/utils.test.ts +++ b/__tests__/utils.test.ts @@ -1,6 +1,14 @@ -import { parseTags, isUrl, parseParameters } from '../src/utils' +import { + configureProxy, + parseTags, + isUrl, + parseParameters, + parseBoolean, + withRetry +} from '../src/utils' +import * as path from 'path' -jest.mock('@actions/core') +const oldEnv = process.env describe('Determine a valid url', () => { beforeEach(() => { @@ -34,21 +42,60 @@ describe('Parse Tags', () => { const json = parseTags(JSON.stringify([{ Key: 'Test', Value: 'Value' }])) expect(json).toEqual([{ Key: 'Test', Value: 'Value' }]) }) + + test('returns valid Array from YAML key-value object format', async () => { + const yaml = ` +Key1: Value1 +Key2: Value2 +` + const result = parseTags(yaml) + expect(result).toEqual([ + { Key: 'Key1', Value: 'Value1' }, + { Key: 'Key2', Value: 'Value2' } + ]) + }) + + test('returns valid Array from YAML array format', async () => { + const yaml = ` +- Key: keyname1 + Value: value1 +- Key: keyname2 + Value: value2 +` + const result = parseTags(yaml) + expect(result).toEqual([ + { Key: 'keyname1', Value: 'value1' }, + { Key: 'keyname2', Value: 'value2' } + ]) + }) + + test('returns undefined for invalid YAML', async () => { + const invalidYaml = ` + Key1: 'Value1 + Key2: Value2 + ` + const result = parseTags(invalidYaml) + expect(result).toBeUndefined() + }) }) describe('Parse Parameters', () => { beforeEach(() => { jest.clearAllMocks() + process.env = { ...oldEnv } + }) + + afterAll(() => { + process.env = oldEnv + }) + + test('returns parameters empty string', async () => { + const json = parseParameters('') + expect(json).toBeUndefined() }) test('returns parameters list from string', async () => { - const json = parseParameters( - ` - MyParam1: myValue1 - MyParam2: myValue2 - `, - '' - ) + const json = parseParameters('MyParam1=myValue1,MyParam2=myValue2') expect(json).toEqual([ { ParameterKey: 'MyParam1', @@ -63,13 +110,7 @@ describe('Parse Parameters', () => { test('returns parameters list from string', async () => { const json = parseParameters( - ` - MyParam1: myValue1 - MyParam2: - - myValue2 - - myValue3 - `, - '' + 'MyParam1=myValue1,MyParam2=myValue2,MyParam2=myValue3' ) expect(json).toEqual([ { @@ -83,8 +124,57 @@ describe('Parse Parameters', () => { ]) }) + test('returns parameters list with an extra equal', async () => { + const json = parseParameters( + 'MyParam1=myValue1,MyParam2=myValue2=myValue3,MyParam2=myValue4 ' + ) + expect(json).toEqual([ + { + ParameterKey: 'MyParam1', + ParameterValue: 'myValue1' + }, + { + ParameterKey: 'MyParam2', + ParameterValue: 'myValue2=myValue3,myValue4' + } + ]) + }) + + test('returns parameters list from multiple lists with single quotes', async () => { + const json = parseParameters( + "MyParam1=myValue1,MyParam2='myValue2,myValue3',MyParam2=myValue4" + ) + expect(json).toEqual([ + { + ParameterKey: 'MyParam1', + ParameterValue: 'myValue1' + }, + { + ParameterKey: 'MyParam2', + ParameterValue: 'myValue2,myValue3,myValue4' + } + ]) + }) + + test('returns parameters list from multiple lists with double quotes', async () => { + const json = parseParameters( + 'MyParam1=myValue1,MyParam2="myValue2,myValue3",MyParam2=myValue4' + ) + expect(json).toEqual([ + { + ParameterKey: 'MyParam1', + ParameterValue: 'myValue1' + }, + { + ParameterKey: 'MyParam2', + ParameterValue: 'myValue2,myValue3,myValue4' + } + ]) + }) + test('returns parameters list from file', async () => { - const json = parseParameters('', '../__tests__/params.test.json') + const filename = 'file://' + path.join(__dirname, 'params.test.json') + const json = parseParameters(filename) expect(json).toEqual([ { ParameterKey: 'MyParam1', @@ -98,14 +188,310 @@ describe('Parse Parameters', () => { }) test('throws error if file is not found', async () => { - expect(() => - parseParameters('', '__tests__/params-invalid.tezt.json') - ).toThrow() + const filename = 'file://' + path.join(__dirname, 'params.tezt.json') + expect(() => parseParameters(filename)).toThrow() }) test('throws error if json in file cannot be parsed', async () => { - expect(() => - parseParameters('', '__tests__/params-invalid.test.json') - ).toThrow() + const filename = + 'file://' + path.join(__dirname, 'params-invalid.test.json') + expect(() => parseParameters(filename)).toThrow() + }) +}) + +describe('Parse Tags', () => { + test('parses tags from YAML array format', () => { + const yaml = ` +- Key: Environment + Value: Production +- Key: Project + Value: MyApp +- Key: CostCenter + Value: '12345' +` + const result = parseTags(yaml) + expect(result).toEqual([ + { + Key: 'Environment', + Value: 'Production' + }, + { + Key: 'Project', + Value: 'MyApp' + }, + { + Key: 'CostCenter', + Value: '12345' + } + ]) + }) + + test('parses tags from YAML object format', () => { + const yaml = ` +Environment: Production +Project: MyApp +CostCenter: '12345' +` + const result = parseTags(yaml) + expect(result).toEqual([ + { + Key: 'Environment', + Value: 'Production' + }, + { + Key: 'Project', + Value: 'MyApp' + }, + { + Key: 'CostCenter', + Value: '12345' + } + ]) + }) + + test('handles empty YAML input', () => { + expect(parseTags('')).toEqual(undefined) + expect(parseTags('0')).toEqual(undefined) + }) + + test('handles YAML with different value types', () => { + const yaml = ` +Environment: Production +IsProduction: true +InstanceCount: 5 +FloatValue: 3.14 +` + const result = parseTags(yaml) + expect(result).toEqual([ + { + Key: 'Environment', + Value: 'Production' + }, + { + Key: 'IsProduction', + Value: 'true' + }, + { + Key: 'InstanceCount', + Value: '5' + }, + { + Key: 'FloatValue', + Value: '3.14' + } + ]) + }) + + test('handles malformed YAML', () => { + const malformedYaml = ` + This is not valid YAML + - Key: Missing Value + ` + expect(parseTags(malformedYaml)).toEqual(undefined) + }) + + test('handles array format with missing required fields', () => { + const yaml = ` +- Key: ValidTag + Value: ValidValue +- Value: MissingKey +- Key: MissingValue +` + const result = parseTags(yaml) + expect(result).toEqual([ + { + Key: 'ValidTag', + Value: 'ValidValue' + } + ]) + }) + + test('handles object format with empty values', () => { + const yaml = ` +Environment: +Project: MyApp +EmptyString: '' +` + const result = parseTags(yaml) + expect(result).toEqual([ + { + Key: 'Environment', + Value: '' + }, + { + Key: 'Project', + Value: 'MyApp' + }, + { + Key: 'EmptyString', + Value: '' + } + ]) + }) + + test('preserves whitespace in tag values', () => { + const yaml = ` +Description: This is a long description with spaces +Path: /path/to/something +` + const result = parseTags(yaml) + expect(result).toEqual([ + { + Key: 'Description', + Value: 'This is a long description with spaces' + }, + { + Key: 'Path', + Value: '/path/to/something' + } + ]) + }) +}) + +describe('parseBoolean', () => { + test('handles native boolean true', () => { + expect(parseBoolean(true)).toBe(true) + }) + + test('handles native boolean false', () => { + expect(parseBoolean(false)).toBe(false) + }) + + test('handles string "true"', () => { + expect(parseBoolean('true')).toBe(true) + }) + + test('handles string "false"', () => { + expect(parseBoolean('false')).toBe(false) + }) + + test('handles legacy string "1"', () => { + expect(parseBoolean('1')).toBe(true) + }) + + test('handles legacy string "0"', () => { + expect(parseBoolean('0')).toBe(false) + }) + + test('handles undefined', () => { + expect(parseBoolean(undefined)).toBe(false) + }) + + test('handles empty string', () => { + expect(parseBoolean('')).toBe(false) + }) +}) + +describe('withRetry', () => { + beforeEach(() => { + jest.useFakeTimers() + }) + + afterEach(() => { + jest.useRealTimers() + }) + + test('returns result on successful operation', async () => { + const operation = jest.fn().mockResolvedValue('success') + const result = await withRetry(operation) + expect(result).toBe('success') + expect(operation).toHaveBeenCalledTimes(1) + }) + + test('retries on CloudFormation Throttling error', async () => { + jest.useFakeTimers() + const error = new Error('Rate exceeded') + error.name = 'Throttling' // CloudFormation uses 'Throttling' not 'ThrottlingException' + const operation = jest + .fn() + .mockRejectedValueOnce(error) + .mockResolvedValueOnce('success') + + const retryPromise = withRetry(operation, 5, 100) + + // Advance timer for the first retry (since it succeeds on second try) + await jest.advanceTimersByTimeAsync(100) + + const result = await retryPromise + expect(result).toBe('success') + expect(operation).toHaveBeenCalledTimes(2) + + jest.useRealTimers() + }, 10000) + + test('retries on rate exceeded error', async () => { + jest.useFakeTimers() + const error = new Error('Rate exceeded') + error.name = 'ThrottlingException' + const operation = jest + .fn() + .mockRejectedValueOnce(error) + .mockResolvedValueOnce('success') + + const retryPromise = withRetry(operation, 5, 100) + + // Advance timer for the first retry (since it succeeds on second try) + await jest.advanceTimersByTimeAsync(100) + + const result = await retryPromise + expect(result).toBe('success') + expect(operation).toHaveBeenCalledTimes(2) + + jest.useRealTimers() + }, 10000) + + test('fails after max retries', async () => { + jest.useFakeTimers() + const error = new Error('Rate exceeded') + error.name = 'ThrottlingException' + const operation = jest.fn().mockRejectedValue(error) + + // Attach the catch handler immediately + const retryPromise = withRetry(operation, 5, 100).catch(err => { + expect(err.message).toBe( + 'Maximum retry attempts (5) reached. Last error: Rate exceeded' + ) + }) + + // Advance timers for each retry (initial + 5 retries) + for (let i = 0; i < 5; i++) { + await jest.advanceTimersByTimeAsync(100 * Math.pow(2, i)) + } + + await retryPromise + expect(operation).toHaveBeenCalledTimes(6) + + jest.useRealTimers() + }, 10000) + + test('does not retry on non-rate-limit errors', async () => { + const error = new Error('Other error') + const operation = jest.fn().mockRejectedValue(error) + + await expect(withRetry(operation)).rejects.toThrow('Other error') + expect(operation).toHaveBeenCalledTimes(1) + }) +}) + +describe('Configure Proxy', () => { + beforeEach(() => { + jest.clearAllMocks() + process.env = { ...oldEnv } + }) + + it('returns undefined on no proxy', () => { + const agent = configureProxy('') + expect(agent).toBeUndefined() + }) + + it('returns agent on proxy', () => { + const agent = configureProxy('http://localhost:8080') + expect(agent).toBeDefined() + }) + + it('returns agent on proxy from env', () => { + process.env.HTTP_PROXY = 'http://localhost:8080' + const agent = configureProxy('') + expect(agent).toBeDefined() }) }) diff --git a/action.yml b/action.yml index 5080167..a02e804 100644 --- a/action.yml +++ b/action.yml @@ -4,38 +4,46 @@ branding: icon: "cloud" color: "orange" inputs: + mode: + description: "Operation mode: 'create-and-execute' (default), 'create-only', or 'execute-only'" + required: false + default: "create-and-execute" name: description: "The name of the CloudFormation stack" required: true template: description: "The path or URL to the CloudFormation template" - required: true + required: false capabilities: description: "The comma-delimited list of stack template capabilities to acknowledge. Defaults to 'CAPABILITY_IAM'" required: false default: "CAPABILITY_IAM" - parameters-file: - description: "The path to the JSON file containing the parameters to pass to the CloudFormation template" - required: false parameter-overrides: - description: 'The parameters to override in the stack inputs. You can pass a comma-delimited list or a file URL. Comma-delimited list has each entry formatted as =. A JSON file can be a local file with a "file://" prefix or remote URL (e.g. file://[github.workspace]/variables.json or http://example.com/variables.json). A local file needs to be specified with an absolute path to it. The file should look like: [ { "ParameterKey": "KeyPairName", "ParameterValue": "MyKey" }]' + description: 'The parameters to override in the stack inputs. You can pass a comma-delimited list or a file URL. Comma-delimited list has each entry formatted as = or =",". A JSON file can be a local file with a "file://" prefix or remote URL. The file should look like: [ { "ParameterKey": "KeyPairName", "ParameterValue": "MyKey" }]. Also supports YAML-style key: value format.' + required: false + parameters-file: + description: 'The path to a JSON file containing parameters. Expected format: { "Parameters": { "Key": "Value" } }. Values from parameter-overrides take precedence over values from this file.' required: false no-execute-changeset: - description: "Indicates whether to execute to the change set or have it reviewed. Default to '0' (will execute the change set)" + description: "Indicates whether to execute to the change set or have it reviewed (default: false)" required: false - default: "0" + default: false no-delete-failed-changeset: - description: "Indicates whether to delete to a failed change set. Default to '0' (will delete the failed changeset)" + description: "Indicates whether to delete to a failed change set (default: false)" required: false - default: "0" + default: false + fail-on-empty-changeset: + description: "If the CloudFormation change set is empty, fail the action (default: false)" + required: false + default: false no-fail-on-empty-changeset: - description: "If the CloudFormation change set is empty, do not fail. Defaults to '0' (will fail on empty change set)" + description: "Deprecated: use fail-on-empty-changeset instead. If set to '1', do not fail on empty change set. This is the inverse of fail-on-empty-changeset." required: false default: "0" disable-rollback: - description: "Disable rollback of the stack if stack creation fails. Defaults to '0' (will rollback if stack creation fails). This input is only used for stack creation, not for stack update" + description: "Disable rollback of the stack if stack creation fails (default: false). This input is only used for stack creation, not for stack update" required: false - default: "0" + default: false timeout-in-minutes: description: "The amount of time that can pass before the stack status becomes CREATE_FAILED. This input is only used for stack creation, not for stack update" required: false @@ -49,16 +57,44 @@ inputs: description: 'Key-value pairs to associate with this stack. This input should be JSON-formatted, for example [ { "Key": "string", "Value": "string" } ]' required: false termination-protection: - description: "Whether to enable termination protection on the specified stack. Defaults to '0' (terminated protection will be disabled) This input is only used for stack creation, not for stack update" + description: "Whether to enable termination protection on the specified stack (default: false). This input is only used for stack creation, not for stack update" + required: false + default: false + http-proxy: + description: 'Proxy to use for the AWS SDK agent' + required: false + change-set-name: + description: "The name of the change set to create. Defaults to '-CS'" required: false - default: "0" changeset-postfix: - description: "The postfix to use for the change set name. Defaults to '-CS'" + description: "Deprecated: use change-set-name instead. The postfix to append to the stack name for the change set name. Defaults to '-CS'." required: false default: "-CS" + include-nested-stacks-change-set: + description: "Creates a change set for the all nested stacks specified in the template. Defaults to '0' (will not include nested stacks)" + required: false + default: "0" + execute-change-set-id: + description: "Execute an existing change set by ID or name instead of creating a new one. When provided, only 'name' (stack name) is required." + required: false + deployment-mode: + description: "The deployment mode for the change set. Use 'REVERT_DRIFT' to create a change set that reverts drift. Defaults to standard deployment." + required: false outputs: stack-id: description: "The id of the deployed stack. In addition, any outputs declared in the deployed CloudFormation stack will also be set as outputs for the action, e.g. if the stack has a stack output named 'foo', this action will also have an output named 'foo'." + change-set-id: + description: "The id of the created change set (only when no-execute-changeset is true)" + change-set-name: + description: "The name of the created change set (only when no-execute-changeset is true)" + has-changes: + description: "Whether the change set contains any changes (only when no-execute-changeset is true)" + changes-count: + description: "Number of changes in the change set (only when no-execute-changeset is true)" + changes-summary: + description: "JSON summary of changes in the change set (only when no-execute-changeset is true)" + changes-markdown: + description: "Markdown-formatted change set summary for PR comments (only when no-execute-changeset is true)" runs: - using: "node12" + using: "node20" main: "dist/index.js" diff --git a/dist/136.index.js b/dist/136.index.js new file mode 100644 index 0000000..d50e461 --- /dev/null +++ b/dist/136.index.js @@ -0,0 +1,903 @@ +"use strict"; +exports.id = 136; +exports.ids = [136]; +exports.modules = { + +/***/ 3723: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.STSClient = exports.__Client = void 0; +const middleware_host_header_1 = __webpack_require__(2590); +const middleware_logger_1 = __webpack_require__(5242); +const middleware_recursion_detection_1 = __webpack_require__(1568); +const middleware_user_agent_1 = __webpack_require__(2959); +const config_resolver_1 = __webpack_require__(9316); +const core_1 = __webpack_require__(402); +const schema_1 = __webpack_require__(6890); +const middleware_content_length_1 = __webpack_require__(7212); +const middleware_endpoint_1 = __webpack_require__(99); +const middleware_retry_1 = __webpack_require__(9618); +const smithy_client_1 = __webpack_require__(1411); +Object.defineProperty(exports, "__Client", ({ enumerable: true, get: function () { return smithy_client_1.Client; } })); +const httpAuthSchemeProvider_1 = __webpack_require__(7851); +const EndpointParameters_1 = __webpack_require__(6811); +const runtimeConfig_1 = __webpack_require__(6578); +const runtimeExtensions_1 = __webpack_require__(7742); +class STSClient extends smithy_client_1.Client { + config; + constructor(...[configuration]) { + const _config_0 = (0, runtimeConfig_1.getRuntimeConfig)(configuration || {}); + super(_config_0); + this.initConfig = _config_0; + const _config_1 = (0, EndpointParameters_1.resolveClientEndpointParameters)(_config_0); + const _config_2 = (0, middleware_user_agent_1.resolveUserAgentConfig)(_config_1); + const _config_3 = (0, middleware_retry_1.resolveRetryConfig)(_config_2); + const _config_4 = (0, config_resolver_1.resolveRegionConfig)(_config_3); + const _config_5 = (0, middleware_host_header_1.resolveHostHeaderConfig)(_config_4); + const _config_6 = (0, middleware_endpoint_1.resolveEndpointConfig)(_config_5); + const _config_7 = (0, httpAuthSchemeProvider_1.resolveHttpAuthSchemeConfig)(_config_6); + const _config_8 = (0, runtimeExtensions_1.resolveRuntimeExtensions)(_config_7, configuration?.extensions || []); + this.config = _config_8; + this.middlewareStack.use((0, schema_1.getSchemaSerdePlugin)(this.config)); + this.middlewareStack.use((0, middleware_user_agent_1.getUserAgentPlugin)(this.config)); + this.middlewareStack.use((0, middleware_retry_1.getRetryPlugin)(this.config)); + this.middlewareStack.use((0, middleware_content_length_1.getContentLengthPlugin)(this.config)); + this.middlewareStack.use((0, middleware_host_header_1.getHostHeaderPlugin)(this.config)); + this.middlewareStack.use((0, middleware_logger_1.getLoggerPlugin)(this.config)); + this.middlewareStack.use((0, middleware_recursion_detection_1.getRecursionDetectionPlugin)(this.config)); + this.middlewareStack.use((0, core_1.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, { + httpAuthSchemeParametersProvider: httpAuthSchemeProvider_1.defaultSTSHttpAuthSchemeParametersProvider, + identityProviderConfigProvider: async (config) => new core_1.DefaultIdentityProviderConfig({ + "aws.auth#sigv4": config.credentials, + }), + })); + this.middlewareStack.use((0, core_1.getHttpSigningPlugin)(this.config)); + } + destroy() { + super.destroy(); + } +} +exports.STSClient = STSClient; + + +/***/ }), + +/***/ 4532: +/***/ ((__unused_webpack_module, exports) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.resolveHttpAuthRuntimeConfig = exports.getHttpAuthExtensionConfiguration = void 0; +const getHttpAuthExtensionConfiguration = (runtimeConfig) => { + const _httpAuthSchemes = runtimeConfig.httpAuthSchemes; + let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider; + let _credentials = runtimeConfig.credentials; + return { + setHttpAuthScheme(httpAuthScheme) { + const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId); + if (index === -1) { + _httpAuthSchemes.push(httpAuthScheme); + } + else { + _httpAuthSchemes.splice(index, 1, httpAuthScheme); + } + }, + httpAuthSchemes() { + return _httpAuthSchemes; + }, + setHttpAuthSchemeProvider(httpAuthSchemeProvider) { + _httpAuthSchemeProvider = httpAuthSchemeProvider; + }, + httpAuthSchemeProvider() { + return _httpAuthSchemeProvider; + }, + setCredentials(credentials) { + _credentials = credentials; + }, + credentials() { + return _credentials; + }, + }; +}; +exports.getHttpAuthExtensionConfiguration = getHttpAuthExtensionConfiguration; +const resolveHttpAuthRuntimeConfig = (config) => { + return { + httpAuthSchemes: config.httpAuthSchemes(), + httpAuthSchemeProvider: config.httpAuthSchemeProvider(), + credentials: config.credentials(), + }; +}; +exports.resolveHttpAuthRuntimeConfig = resolveHttpAuthRuntimeConfig; + + +/***/ }), + +/***/ 7851: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.resolveHttpAuthSchemeConfig = exports.resolveStsAuthConfig = exports.defaultSTSHttpAuthSchemeProvider = exports.defaultSTSHttpAuthSchemeParametersProvider = void 0; +const core_1 = __webpack_require__(8704); +const util_middleware_1 = __webpack_require__(6324); +const STSClient_1 = __webpack_require__(3723); +const defaultSTSHttpAuthSchemeParametersProvider = async (config, context, input) => { + return { + operation: (0, util_middleware_1.getSmithyContext)(context).operation, + region: (await (0, util_middleware_1.normalizeProvider)(config.region)()) || + (() => { + throw new Error("expected `region` to be configured for `aws.auth#sigv4`"); + })(), + }; +}; +exports.defaultSTSHttpAuthSchemeParametersProvider = defaultSTSHttpAuthSchemeParametersProvider; +function createAwsAuthSigv4HttpAuthOption(authParameters) { + return { + schemeId: "aws.auth#sigv4", + signingProperties: { + name: "sts", + region: authParameters.region, + }, + propertiesExtractor: (config, context) => ({ + signingProperties: { + config, + context, + }, + }), + }; +} +function createSmithyApiNoAuthHttpAuthOption(authParameters) { + return { + schemeId: "smithy.api#noAuth", + }; +} +const defaultSTSHttpAuthSchemeProvider = (authParameters) => { + const options = []; + switch (authParameters.operation) { + case "AssumeRoleWithWebIdentity": { + options.push(createSmithyApiNoAuthHttpAuthOption(authParameters)); + break; + } + default: { + options.push(createAwsAuthSigv4HttpAuthOption(authParameters)); + } + } + return options; +}; +exports.defaultSTSHttpAuthSchemeProvider = defaultSTSHttpAuthSchemeProvider; +const resolveStsAuthConfig = (input) => Object.assign(input, { + stsClientCtor: STSClient_1.STSClient, +}); +exports.resolveStsAuthConfig = resolveStsAuthConfig; +const resolveHttpAuthSchemeConfig = (config) => { + const config_0 = (0, exports.resolveStsAuthConfig)(config); + const config_1 = (0, core_1.resolveAwsSdkSigV4Config)(config_0); + return Object.assign(config_1, { + authSchemePreference: (0, util_middleware_1.normalizeProvider)(config.authSchemePreference ?? []), + }); +}; +exports.resolveHttpAuthSchemeConfig = resolveHttpAuthSchemeConfig; + + +/***/ }), + +/***/ 6811: +/***/ ((__unused_webpack_module, exports) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.commonParams = exports.resolveClientEndpointParameters = void 0; +const resolveClientEndpointParameters = (options) => { + return Object.assign(options, { + useDualstackEndpoint: options.useDualstackEndpoint ?? false, + useFipsEndpoint: options.useFipsEndpoint ?? false, + useGlobalEndpoint: options.useGlobalEndpoint ?? false, + defaultSigningName: "sts", + }); +}; +exports.resolveClientEndpointParameters = resolveClientEndpointParameters; +exports.commonParams = { + UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" }, + UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" }, + Endpoint: { type: "builtInParams", name: "endpoint" }, + Region: { type: "builtInParams", name: "region" }, + UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }, +}; + + +/***/ }), + +/***/ 9765: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.defaultEndpointResolver = void 0; +const util_endpoints_1 = __webpack_require__(3068); +const util_endpoints_2 = __webpack_require__(9674); +const ruleset_1 = __webpack_require__(1670); +const cache = new util_endpoints_2.EndpointCache({ + size: 50, + params: ["Endpoint", "Region", "UseDualStack", "UseFIPS", "UseGlobalEndpoint"], +}); +const defaultEndpointResolver = (endpointParams, context = {}) => { + return cache.get(endpointParams, () => (0, util_endpoints_2.resolveEndpoint)(ruleset_1.ruleSet, { + endpointParams: endpointParams, + logger: context.logger, + })); +}; +exports.defaultEndpointResolver = defaultEndpointResolver; +util_endpoints_2.customEndpointFunctions.aws = util_endpoints_1.awsEndpointFunctions; + + +/***/ }), + +/***/ 1670: +/***/ ((__unused_webpack_module, exports) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ruleSet = void 0; +const F = "required", G = "type", H = "fn", I = "argv", J = "ref"; +const a = false, b = true, c = "booleanEquals", d = "stringEquals", e = "sigv4", f = "sts", g = "us-east-1", h = "endpoint", i = "https://sts.{Region}.{PartitionResult#dnsSuffix}", j = "tree", k = "error", l = "getAttr", m = { [F]: false, [G]: "string" }, n = { [F]: true, "default": false, [G]: "boolean" }, o = { [J]: "Endpoint" }, p = { [H]: "isSet", [I]: [{ [J]: "Region" }] }, q = { [J]: "Region" }, r = { [H]: "aws.partition", [I]: [q], "assign": "PartitionResult" }, s = { [J]: "UseFIPS" }, t = { [J]: "UseDualStack" }, u = { "url": "https://sts.amazonaws.com", "properties": { "authSchemes": [{ "name": e, "signingName": f, "signingRegion": g }] }, "headers": {} }, v = {}, w = { "conditions": [{ [H]: d, [I]: [q, "aws-global"] }], [h]: u, [G]: h }, x = { [H]: c, [I]: [s, true] }, y = { [H]: c, [I]: [t, true] }, z = { [H]: l, [I]: [{ [J]: "PartitionResult" }, "supportsFIPS"] }, A = { [J]: "PartitionResult" }, B = { [H]: c, [I]: [true, { [H]: l, [I]: [A, "supportsDualStack"] }] }, C = [{ [H]: "isSet", [I]: [o] }], D = [x], E = [y]; +const _data = { version: "1.0", parameters: { Region: m, UseDualStack: n, UseFIPS: n, Endpoint: m, UseGlobalEndpoint: n }, rules: [{ conditions: [{ [H]: c, [I]: [{ [J]: "UseGlobalEndpoint" }, b] }, { [H]: "not", [I]: C }, p, r, { [H]: c, [I]: [s, a] }, { [H]: c, [I]: [t, a] }], rules: [{ conditions: [{ [H]: d, [I]: [q, "ap-northeast-1"] }], endpoint: u, [G]: h }, { conditions: [{ [H]: d, [I]: [q, "ap-south-1"] }], endpoint: u, [G]: h }, { conditions: [{ [H]: d, [I]: [q, "ap-southeast-1"] }], endpoint: u, [G]: h }, { conditions: [{ [H]: d, [I]: [q, "ap-southeast-2"] }], endpoint: u, [G]: h }, w, { conditions: [{ [H]: d, [I]: [q, "ca-central-1"] }], endpoint: u, [G]: h }, { conditions: [{ [H]: d, [I]: [q, "eu-central-1"] }], endpoint: u, [G]: h }, { conditions: [{ [H]: d, [I]: [q, "eu-north-1"] }], endpoint: u, [G]: h }, { conditions: [{ [H]: d, [I]: [q, "eu-west-1"] }], endpoint: u, [G]: h }, { conditions: [{ [H]: d, [I]: [q, "eu-west-2"] }], endpoint: u, [G]: h }, { conditions: [{ [H]: d, [I]: [q, "eu-west-3"] }], endpoint: u, [G]: h }, { conditions: [{ [H]: d, [I]: [q, "sa-east-1"] }], endpoint: u, [G]: h }, { conditions: [{ [H]: d, [I]: [q, g] }], endpoint: u, [G]: h }, { conditions: [{ [H]: d, [I]: [q, "us-east-2"] }], endpoint: u, [G]: h }, { conditions: [{ [H]: d, [I]: [q, "us-west-1"] }], endpoint: u, [G]: h }, { conditions: [{ [H]: d, [I]: [q, "us-west-2"] }], endpoint: u, [G]: h }, { endpoint: { url: i, properties: { authSchemes: [{ name: e, signingName: f, signingRegion: "{Region}" }] }, headers: v }, [G]: h }], [G]: j }, { conditions: C, rules: [{ conditions: D, error: "Invalid Configuration: FIPS and custom endpoint are not supported", [G]: k }, { conditions: E, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", [G]: k }, { endpoint: { url: o, properties: v, headers: v }, [G]: h }], [G]: j }, { conditions: [p], rules: [{ conditions: [r], rules: [{ conditions: [x, y], rules: [{ conditions: [{ [H]: c, [I]: [b, z] }, B], rules: [{ endpoint: { url: "https://sts-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: v, headers: v }, [G]: h }], [G]: j }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", [G]: k }], [G]: j }, { conditions: D, rules: [{ conditions: [{ [H]: c, [I]: [z, b] }], rules: [{ conditions: [{ [H]: d, [I]: [{ [H]: l, [I]: [A, "name"] }, "aws-us-gov"] }], endpoint: { url: "https://sts.{Region}.amazonaws.com", properties: v, headers: v }, [G]: h }, { endpoint: { url: "https://sts-fips.{Region}.{PartitionResult#dnsSuffix}", properties: v, headers: v }, [G]: h }], [G]: j }, { error: "FIPS is enabled but this partition does not support FIPS", [G]: k }], [G]: j }, { conditions: E, rules: [{ conditions: [B], rules: [{ endpoint: { url: "https://sts.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: v, headers: v }, [G]: h }], [G]: j }, { error: "DualStack is enabled but this partition does not support DualStack", [G]: k }], [G]: j }, w, { endpoint: { url: i, properties: v, headers: v }, [G]: h }], [G]: j }], [G]: j }, { error: "Invalid Configuration: Missing Region", [G]: k }] }; +exports.ruleSet = _data; + + +/***/ }), + +/***/ 1136: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + + +var STSClient = __webpack_require__(3723); +var smithyClient = __webpack_require__(1411); +var middlewareEndpoint = __webpack_require__(99); +var EndpointParameters = __webpack_require__(6811); +var schema = __webpack_require__(6890); +var client = __webpack_require__(5152); +var regionConfigResolver = __webpack_require__(6463); + +let STSServiceException$1 = class STSServiceException extends smithyClient.ServiceException { + constructor(options) { + super(options); + Object.setPrototypeOf(this, STSServiceException.prototype); + } +}; + +let ExpiredTokenException$1 = class ExpiredTokenException extends STSServiceException$1 { + name = "ExpiredTokenException"; + $fault = "client"; + constructor(opts) { + super({ + name: "ExpiredTokenException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, ExpiredTokenException.prototype); + } +}; +let MalformedPolicyDocumentException$1 = class MalformedPolicyDocumentException extends STSServiceException$1 { + name = "MalformedPolicyDocumentException"; + $fault = "client"; + constructor(opts) { + super({ + name: "MalformedPolicyDocumentException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, MalformedPolicyDocumentException.prototype); + } +}; +let PackedPolicyTooLargeException$1 = class PackedPolicyTooLargeException extends STSServiceException$1 { + name = "PackedPolicyTooLargeException"; + $fault = "client"; + constructor(opts) { + super({ + name: "PackedPolicyTooLargeException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, PackedPolicyTooLargeException.prototype); + } +}; +let RegionDisabledException$1 = class RegionDisabledException extends STSServiceException$1 { + name = "RegionDisabledException"; + $fault = "client"; + constructor(opts) { + super({ + name: "RegionDisabledException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, RegionDisabledException.prototype); + } +}; +let IDPRejectedClaimException$1 = class IDPRejectedClaimException extends STSServiceException$1 { + name = "IDPRejectedClaimException"; + $fault = "client"; + constructor(opts) { + super({ + name: "IDPRejectedClaimException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, IDPRejectedClaimException.prototype); + } +}; +let InvalidIdentityTokenException$1 = class InvalidIdentityTokenException extends STSServiceException$1 { + name = "InvalidIdentityTokenException"; + $fault = "client"; + constructor(opts) { + super({ + name: "InvalidIdentityTokenException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, InvalidIdentityTokenException.prototype); + } +}; +let IDPCommunicationErrorException$1 = class IDPCommunicationErrorException extends STSServiceException$1 { + name = "IDPCommunicationErrorException"; + $fault = "client"; + constructor(opts) { + super({ + name: "IDPCommunicationErrorException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, IDPCommunicationErrorException.prototype); + } +}; + +const _A = "Arn"; +const _AKI = "AccessKeyId"; +const _AR = "AssumeRole"; +const _ARI = "AssumedRoleId"; +const _ARR = "AssumeRoleRequest"; +const _ARRs = "AssumeRoleResponse"; +const _ARU = "AssumedRoleUser"; +const _ARWWI = "AssumeRoleWithWebIdentity"; +const _ARWWIR = "AssumeRoleWithWebIdentityRequest"; +const _ARWWIRs = "AssumeRoleWithWebIdentityResponse"; +const _Au = "Audience"; +const _C = "Credentials"; +const _CA = "ContextAssertion"; +const _DS = "DurationSeconds"; +const _E = "Expiration"; +const _EI = "ExternalId"; +const _ETE = "ExpiredTokenException"; +const _IDPCEE = "IDPCommunicationErrorException"; +const _IDPRCE = "IDPRejectedClaimException"; +const _IITE = "InvalidIdentityTokenException"; +const _K = "Key"; +const _MPDE = "MalformedPolicyDocumentException"; +const _P = "Policy"; +const _PA = "PolicyArns"; +const _PAr = "ProviderArn"; +const _PC = "ProvidedContexts"; +const _PCLT = "ProvidedContextsListType"; +const _PCr = "ProvidedContext"; +const _PDT = "PolicyDescriptorType"; +const _PI = "ProviderId"; +const _PPS = "PackedPolicySize"; +const _PPTLE = "PackedPolicyTooLargeException"; +const _Pr = "Provider"; +const _RA = "RoleArn"; +const _RDE = "RegionDisabledException"; +const _RSN = "RoleSessionName"; +const _SAK = "SecretAccessKey"; +const _SFWIT = "SubjectFromWebIdentityToken"; +const _SI = "SourceIdentity"; +const _SN = "SerialNumber"; +const _ST = "SessionToken"; +const _T = "Tags"; +const _TC = "TokenCode"; +const _TTK = "TransitiveTagKeys"; +const _Ta = "Tag"; +const _V = "Value"; +const _WIT = "WebIdentityToken"; +const _a = "arn"; +const _aKST = "accessKeySecretType"; +const _aQE = "awsQueryError"; +const _c = "client"; +const _cTT = "clientTokenType"; +const _e = "error"; +const _hE = "httpError"; +const _m = "message"; +const _pDLT = "policyDescriptorListType"; +const _s = "smithy.ts.sdk.synthetic.com.amazonaws.sts"; +const _tLT = "tagListType"; +const n0 = "com.amazonaws.sts"; +var accessKeySecretType = [0, n0, _aKST, 8, 0]; +var clientTokenType = [0, n0, _cTT, 8, 0]; +var AssumedRoleUser = [3, n0, _ARU, 0, [_ARI, _A], [0, 0]]; +var AssumeRoleRequest = [ + 3, + n0, + _ARR, + 0, + [_RA, _RSN, _PA, _P, _DS, _T, _TTK, _EI, _SN, _TC, _SI, _PC], + [0, 0, () => policyDescriptorListType, 0, 1, () => tagListType, 64 | 0, 0, 0, 0, 0, () => ProvidedContextsListType], +]; +var AssumeRoleResponse = [ + 3, + n0, + _ARRs, + 0, + [_C, _ARU, _PPS, _SI], + [[() => Credentials, 0], () => AssumedRoleUser, 1, 0], +]; +var AssumeRoleWithWebIdentityRequest = [ + 3, + n0, + _ARWWIR, + 0, + [_RA, _RSN, _WIT, _PI, _PA, _P, _DS], + [0, 0, [() => clientTokenType, 0], 0, () => policyDescriptorListType, 0, 1], +]; +var AssumeRoleWithWebIdentityResponse = [ + 3, + n0, + _ARWWIRs, + 0, + [_C, _SFWIT, _ARU, _PPS, _Pr, _Au, _SI], + [[() => Credentials, 0], 0, () => AssumedRoleUser, 1, 0, 0, 0], +]; +var Credentials = [ + 3, + n0, + _C, + 0, + [_AKI, _SAK, _ST, _E], + [0, [() => accessKeySecretType, 0], 0, 4], +]; +var ExpiredTokenException = [ + -3, + n0, + _ETE, + { + [_e]: _c, + [_hE]: 400, + [_aQE]: [`ExpiredTokenException`, 400], + }, + [_m], + [0], +]; +schema.TypeRegistry.for(n0).registerError(ExpiredTokenException, ExpiredTokenException$1); +var IDPCommunicationErrorException = [ + -3, + n0, + _IDPCEE, + { + [_e]: _c, + [_hE]: 400, + [_aQE]: [`IDPCommunicationError`, 400], + }, + [_m], + [0], +]; +schema.TypeRegistry.for(n0).registerError(IDPCommunicationErrorException, IDPCommunicationErrorException$1); +var IDPRejectedClaimException = [ + -3, + n0, + _IDPRCE, + { + [_e]: _c, + [_hE]: 403, + [_aQE]: [`IDPRejectedClaim`, 403], + }, + [_m], + [0], +]; +schema.TypeRegistry.for(n0).registerError(IDPRejectedClaimException, IDPRejectedClaimException$1); +var InvalidIdentityTokenException = [ + -3, + n0, + _IITE, + { + [_e]: _c, + [_hE]: 400, + [_aQE]: [`InvalidIdentityToken`, 400], + }, + [_m], + [0], +]; +schema.TypeRegistry.for(n0).registerError(InvalidIdentityTokenException, InvalidIdentityTokenException$1); +var MalformedPolicyDocumentException = [ + -3, + n0, + _MPDE, + { + [_e]: _c, + [_hE]: 400, + [_aQE]: [`MalformedPolicyDocument`, 400], + }, + [_m], + [0], +]; +schema.TypeRegistry.for(n0).registerError(MalformedPolicyDocumentException, MalformedPolicyDocumentException$1); +var PackedPolicyTooLargeException = [ + -3, + n0, + _PPTLE, + { + [_e]: _c, + [_hE]: 400, + [_aQE]: [`PackedPolicyTooLarge`, 400], + }, + [_m], + [0], +]; +schema.TypeRegistry.for(n0).registerError(PackedPolicyTooLargeException, PackedPolicyTooLargeException$1); +var PolicyDescriptorType = [3, n0, _PDT, 0, [_a], [0]]; +var ProvidedContext = [3, n0, _PCr, 0, [_PAr, _CA], [0, 0]]; +var RegionDisabledException = [ + -3, + n0, + _RDE, + { + [_e]: _c, + [_hE]: 403, + [_aQE]: [`RegionDisabledException`, 403], + }, + [_m], + [0], +]; +schema.TypeRegistry.for(n0).registerError(RegionDisabledException, RegionDisabledException$1); +var Tag = [3, n0, _Ta, 0, [_K, _V], [0, 0]]; +var STSServiceException = [-3, _s, "STSServiceException", 0, [], []]; +schema.TypeRegistry.for(_s).registerError(STSServiceException, STSServiceException$1); +var policyDescriptorListType = [1, n0, _pDLT, 0, () => PolicyDescriptorType]; +var ProvidedContextsListType = [1, n0, _PCLT, 0, () => ProvidedContext]; +var tagListType = [1, n0, _tLT, 0, () => Tag]; +var AssumeRole = [9, n0, _AR, 0, () => AssumeRoleRequest, () => AssumeRoleResponse]; +var AssumeRoleWithWebIdentity = [ + 9, + n0, + _ARWWI, + 0, + () => AssumeRoleWithWebIdentityRequest, + () => AssumeRoleWithWebIdentityResponse, +]; + +class AssumeRoleCommand extends smithyClient.Command + .classBuilder() + .ep(EndpointParameters.commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("AWSSecurityTokenServiceV20110615", "AssumeRole", {}) + .n("STSClient", "AssumeRoleCommand") + .sc(AssumeRole) + .build() { +} + +class AssumeRoleWithWebIdentityCommand extends smithyClient.Command + .classBuilder() + .ep(EndpointParameters.commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("AWSSecurityTokenServiceV20110615", "AssumeRoleWithWebIdentity", {}) + .n("STSClient", "AssumeRoleWithWebIdentityCommand") + .sc(AssumeRoleWithWebIdentity) + .build() { +} + +const commands = { + AssumeRoleCommand, + AssumeRoleWithWebIdentityCommand, +}; +class STS extends STSClient.STSClient { +} +smithyClient.createAggregatedClient(commands, STS); + +const getAccountIdFromAssumedRoleUser = (assumedRoleUser) => { + if (typeof assumedRoleUser?.Arn === "string") { + const arnComponents = assumedRoleUser.Arn.split(":"); + if (arnComponents.length > 4 && arnComponents[4] !== "") { + return arnComponents[4]; + } + } + return undefined; +}; +const resolveRegion = async (_region, _parentRegion, credentialProviderLogger, loaderConfig = {}) => { + const region = typeof _region === "function" ? await _region() : _region; + const parentRegion = typeof _parentRegion === "function" ? await _parentRegion() : _parentRegion; + const stsDefaultRegion = await regionConfigResolver.stsRegionDefaultResolver(loaderConfig)(); + credentialProviderLogger?.debug?.("@aws-sdk/client-sts::resolveRegion", "accepting first of:", `${region} (credential provider clientConfig)`, `${parentRegion} (contextual client)`, `${stsDefaultRegion} (STS default: AWS_REGION, profile region, or us-east-1)`); + return region ?? parentRegion ?? stsDefaultRegion; +}; +const getDefaultRoleAssumer$1 = (stsOptions, STSClient) => { + let stsClient; + let closureSourceCreds; + return async (sourceCreds, params) => { + closureSourceCreds = sourceCreds; + if (!stsClient) { + const { logger = stsOptions?.parentClientConfig?.logger, profile = stsOptions?.parentClientConfig?.profile, region, requestHandler = stsOptions?.parentClientConfig?.requestHandler, credentialProviderLogger, userAgentAppId = stsOptions?.parentClientConfig?.userAgentAppId, } = stsOptions; + const resolvedRegion = await resolveRegion(region, stsOptions?.parentClientConfig?.region, credentialProviderLogger, { + logger, + profile, + }); + const isCompatibleRequestHandler = !isH2(requestHandler); + stsClient = new STSClient({ + ...stsOptions, + userAgentAppId, + profile, + credentialDefaultProvider: () => async () => closureSourceCreds, + region: resolvedRegion, + requestHandler: isCompatibleRequestHandler ? requestHandler : undefined, + logger: logger, + }); + } + const { Credentials, AssumedRoleUser } = await stsClient.send(new AssumeRoleCommand(params)); + if (!Credentials || !Credentials.AccessKeyId || !Credentials.SecretAccessKey) { + throw new Error(`Invalid response from STS.assumeRole call with role ${params.RoleArn}`); + } + const accountId = getAccountIdFromAssumedRoleUser(AssumedRoleUser); + const credentials = { + accessKeyId: Credentials.AccessKeyId, + secretAccessKey: Credentials.SecretAccessKey, + sessionToken: Credentials.SessionToken, + expiration: Credentials.Expiration, + ...(Credentials.CredentialScope && { credentialScope: Credentials.CredentialScope }), + ...(accountId && { accountId }), + }; + client.setCredentialFeature(credentials, "CREDENTIALS_STS_ASSUME_ROLE", "i"); + return credentials; + }; +}; +const getDefaultRoleAssumerWithWebIdentity$1 = (stsOptions, STSClient) => { + let stsClient; + return async (params) => { + if (!stsClient) { + const { logger = stsOptions?.parentClientConfig?.logger, profile = stsOptions?.parentClientConfig?.profile, region, requestHandler = stsOptions?.parentClientConfig?.requestHandler, credentialProviderLogger, userAgentAppId = stsOptions?.parentClientConfig?.userAgentAppId, } = stsOptions; + const resolvedRegion = await resolveRegion(region, stsOptions?.parentClientConfig?.region, credentialProviderLogger, { + logger, + profile, + }); + const isCompatibleRequestHandler = !isH2(requestHandler); + stsClient = new STSClient({ + ...stsOptions, + userAgentAppId, + profile, + region: resolvedRegion, + requestHandler: isCompatibleRequestHandler ? requestHandler : undefined, + logger: logger, + }); + } + const { Credentials, AssumedRoleUser } = await stsClient.send(new AssumeRoleWithWebIdentityCommand(params)); + if (!Credentials || !Credentials.AccessKeyId || !Credentials.SecretAccessKey) { + throw new Error(`Invalid response from STS.assumeRoleWithWebIdentity call with role ${params.RoleArn}`); + } + const accountId = getAccountIdFromAssumedRoleUser(AssumedRoleUser); + const credentials = { + accessKeyId: Credentials.AccessKeyId, + secretAccessKey: Credentials.SecretAccessKey, + sessionToken: Credentials.SessionToken, + expiration: Credentials.Expiration, + ...(Credentials.CredentialScope && { credentialScope: Credentials.CredentialScope }), + ...(accountId && { accountId }), + }; + if (accountId) { + client.setCredentialFeature(credentials, "RESOLVED_ACCOUNT_ID", "T"); + } + client.setCredentialFeature(credentials, "CREDENTIALS_STS_ASSUME_ROLE_WEB_ID", "k"); + return credentials; + }; +}; +const isH2 = (requestHandler) => { + return requestHandler?.metadata?.handlerProtocol === "h2"; +}; + +const getCustomizableStsClientCtor = (baseCtor, customizations) => { + if (!customizations) + return baseCtor; + else + return class CustomizableSTSClient extends baseCtor { + constructor(config) { + super(config); + for (const customization of customizations) { + this.middlewareStack.use(customization); + } + } + }; +}; +const getDefaultRoleAssumer = (stsOptions = {}, stsPlugins) => getDefaultRoleAssumer$1(stsOptions, getCustomizableStsClientCtor(STSClient.STSClient, stsPlugins)); +const getDefaultRoleAssumerWithWebIdentity = (stsOptions = {}, stsPlugins) => getDefaultRoleAssumerWithWebIdentity$1(stsOptions, getCustomizableStsClientCtor(STSClient.STSClient, stsPlugins)); +const decorateDefaultCredentialProvider = (provider) => (input) => provider({ + roleAssumer: getDefaultRoleAssumer(input), + roleAssumerWithWebIdentity: getDefaultRoleAssumerWithWebIdentity(input), + ...input, +}); + +Object.defineProperty(exports, "$Command", ({ + enumerable: true, + get: function () { return smithyClient.Command; } +})); +exports.AssumeRoleCommand = AssumeRoleCommand; +exports.AssumeRoleWithWebIdentityCommand = AssumeRoleWithWebIdentityCommand; +exports.ExpiredTokenException = ExpiredTokenException$1; +exports.IDPCommunicationErrorException = IDPCommunicationErrorException$1; +exports.IDPRejectedClaimException = IDPRejectedClaimException$1; +exports.InvalidIdentityTokenException = InvalidIdentityTokenException$1; +exports.MalformedPolicyDocumentException = MalformedPolicyDocumentException$1; +exports.PackedPolicyTooLargeException = PackedPolicyTooLargeException$1; +exports.RegionDisabledException = RegionDisabledException$1; +exports.STS = STS; +exports.STSServiceException = STSServiceException$1; +exports.decorateDefaultCredentialProvider = decorateDefaultCredentialProvider; +exports.getDefaultRoleAssumer = getDefaultRoleAssumer; +exports.getDefaultRoleAssumerWithWebIdentity = getDefaultRoleAssumerWithWebIdentity; +Object.keys(STSClient).forEach(function (k) { + if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, { + enumerable: true, + get: function () { return STSClient[k]; } + }); +}); + + +/***/ }), + +/***/ 6578: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getRuntimeConfig = void 0; +const tslib_1 = __webpack_require__(1860); +const package_json_1 = tslib_1.__importDefault(__webpack_require__(9955)); +const core_1 = __webpack_require__(8704); +const util_user_agent_node_1 = __webpack_require__(1656); +const config_resolver_1 = __webpack_require__(9316); +const core_2 = __webpack_require__(402); +const hash_node_1 = __webpack_require__(2711); +const middleware_retry_1 = __webpack_require__(9618); +const node_config_provider_1 = __webpack_require__(5704); +const node_http_handler_1 = __webpack_require__(1279); +const util_body_length_node_1 = __webpack_require__(3638); +const util_retry_1 = __webpack_require__(5518); +const runtimeConfig_shared_1 = __webpack_require__(4443); +const smithy_client_1 = __webpack_require__(1411); +const util_defaults_mode_node_1 = __webpack_require__(5435); +const smithy_client_2 = __webpack_require__(1411); +const getRuntimeConfig = (config) => { + (0, smithy_client_2.emitWarningIfUnsupportedVersion)(process.version); + const defaultsMode = (0, util_defaults_mode_node_1.resolveDefaultsModeConfig)(config); + const defaultConfigProvider = () => defaultsMode().then(smithy_client_1.loadConfigsForDefaultMode); + const clientSharedValues = (0, runtimeConfig_shared_1.getRuntimeConfig)(config); + (0, core_1.emitWarningIfUnsupportedVersion)(process.version); + const loaderConfig = { + profile: config?.profile, + logger: clientSharedValues.logger, + }; + return { + ...clientSharedValues, + ...config, + runtime: "node", + defaultsMode, + authSchemePreference: config?.authSchemePreference ?? (0, node_config_provider_1.loadConfig)(core_1.NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig), + bodyLengthChecker: config?.bodyLengthChecker ?? util_body_length_node_1.calculateBodyLength, + defaultUserAgentProvider: config?.defaultUserAgentProvider ?? + (0, util_user_agent_node_1.createDefaultUserAgentProvider)({ serviceId: clientSharedValues.serviceId, clientVersion: package_json_1.default.version }), + httpAuthSchemes: config?.httpAuthSchemes ?? [ + { + schemeId: "aws.auth#sigv4", + identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4") || + (async (idProps) => await config.credentialDefaultProvider(idProps?.__config || {})()), + signer: new core_1.AwsSdkSigV4Signer(), + }, + { + schemeId: "smithy.api#noAuth", + identityProvider: (ipc) => ipc.getIdentityProvider("smithy.api#noAuth") || (async () => ({})), + signer: new core_2.NoAuthSigner(), + }, + ], + maxAttempts: config?.maxAttempts ?? (0, node_config_provider_1.loadConfig)(middleware_retry_1.NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config), + region: config?.region ?? + (0, node_config_provider_1.loadConfig)(config_resolver_1.NODE_REGION_CONFIG_OPTIONS, { ...config_resolver_1.NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }), + requestHandler: node_http_handler_1.NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider), + retryMode: config?.retryMode ?? + (0, node_config_provider_1.loadConfig)({ + ...middleware_retry_1.NODE_RETRY_MODE_CONFIG_OPTIONS, + default: async () => (await defaultConfigProvider()).retryMode || util_retry_1.DEFAULT_RETRY_MODE, + }, config), + sha256: config?.sha256 ?? hash_node_1.Hash.bind(null, "sha256"), + streamCollector: config?.streamCollector ?? node_http_handler_1.streamCollector, + useDualstackEndpoint: config?.useDualstackEndpoint ?? (0, node_config_provider_1.loadConfig)(config_resolver_1.NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig), + useFipsEndpoint: config?.useFipsEndpoint ?? (0, node_config_provider_1.loadConfig)(config_resolver_1.NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig), + userAgentAppId: config?.userAgentAppId ?? (0, node_config_provider_1.loadConfig)(util_user_agent_node_1.NODE_APP_ID_CONFIG_OPTIONS, loaderConfig), + }; +}; +exports.getRuntimeConfig = getRuntimeConfig; + + +/***/ }), + +/***/ 4443: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getRuntimeConfig = void 0; +const core_1 = __webpack_require__(8704); +const protocols_1 = __webpack_require__(7288); +const core_2 = __webpack_require__(402); +const smithy_client_1 = __webpack_require__(1411); +const url_parser_1 = __webpack_require__(4494); +const util_base64_1 = __webpack_require__(8385); +const util_utf8_1 = __webpack_require__(1577); +const httpAuthSchemeProvider_1 = __webpack_require__(7851); +const endpointResolver_1 = __webpack_require__(9765); +const getRuntimeConfig = (config) => { + return { + apiVersion: "2011-06-15", + base64Decoder: config?.base64Decoder ?? util_base64_1.fromBase64, + base64Encoder: config?.base64Encoder ?? util_base64_1.toBase64, + disableHostPrefix: config?.disableHostPrefix ?? false, + endpointProvider: config?.endpointProvider ?? endpointResolver_1.defaultEndpointResolver, + extensions: config?.extensions ?? [], + httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? httpAuthSchemeProvider_1.defaultSTSHttpAuthSchemeProvider, + httpAuthSchemes: config?.httpAuthSchemes ?? [ + { + schemeId: "aws.auth#sigv4", + identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"), + signer: new core_1.AwsSdkSigV4Signer(), + }, + { + schemeId: "smithy.api#noAuth", + identityProvider: (ipc) => ipc.getIdentityProvider("smithy.api#noAuth") || (async () => ({})), + signer: new core_2.NoAuthSigner(), + }, + ], + logger: config?.logger ?? new smithy_client_1.NoOpLogger(), + protocol: config?.protocol ?? + new protocols_1.AwsQueryProtocol({ + defaultNamespace: "com.amazonaws.sts", + xmlNamespace: "https://sts.amazonaws.com/doc/2011-06-15/", + version: "2011-06-15", + }), + serviceId: config?.serviceId ?? "STS", + urlParser: config?.urlParser ?? url_parser_1.parseUrl, + utf8Decoder: config?.utf8Decoder ?? util_utf8_1.fromUtf8, + utf8Encoder: config?.utf8Encoder ?? util_utf8_1.toUtf8, + }; +}; +exports.getRuntimeConfig = getRuntimeConfig; + + +/***/ }), + +/***/ 7742: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.resolveRuntimeExtensions = void 0; +const region_config_resolver_1 = __webpack_require__(6463); +const protocol_http_1 = __webpack_require__(2356); +const smithy_client_1 = __webpack_require__(1411); +const httpAuthExtensionConfiguration_1 = __webpack_require__(4532); +const resolveRuntimeExtensions = (runtimeConfig, extensions) => { + const extensionConfiguration = Object.assign((0, region_config_resolver_1.getAwsRegionExtensionConfiguration)(runtimeConfig), (0, smithy_client_1.getDefaultExtensionConfiguration)(runtimeConfig), (0, protocol_http_1.getHttpHandlerExtensionConfiguration)(runtimeConfig), (0, httpAuthExtensionConfiguration_1.getHttpAuthExtensionConfiguration)(runtimeConfig)); + extensions.forEach((extension) => extension.configure(extensionConfiguration)); + return Object.assign(runtimeConfig, (0, region_config_resolver_1.resolveAwsRegionExtensionConfiguration)(extensionConfiguration), (0, smithy_client_1.resolveDefaultRuntimeConfig)(extensionConfiguration), (0, protocol_http_1.resolveHttpHandlerRuntimeConfig)(extensionConfiguration), (0, httpAuthExtensionConfiguration_1.resolveHttpAuthRuntimeConfig)(extensionConfiguration)); +}; +exports.resolveRuntimeExtensions = resolveRuntimeExtensions; + + +/***/ }), + +/***/ 9955: +/***/ ((module) => { + +module.exports = /*#__PURE__*/JSON.parse('{"name":"@aws-sdk/nested-clients","version":"3.935.0","description":"Nested clients for AWS SDK packages.","main":"./dist-cjs/index.js","module":"./dist-es/index.js","types":"./dist-types/index.d.ts","scripts":{"build":"yarn lint && concurrently \'yarn:build:cjs\' \'yarn:build:es\' \'yarn:build:types\'","build:cjs":"node ../../scripts/compilation/inline nested-clients","build:es":"tsc -p tsconfig.es.json","build:include:deps":"lerna run --scope $npm_package_name --include-dependencies build","build:types":"tsc -p tsconfig.types.json","build:types:downlevel":"downlevel-dts dist-types dist-types/ts3.4","clean":"rimraf ./dist-* && rimraf *.tsbuildinfo","lint":"node ../../scripts/validation/submodules-linter.js --pkg nested-clients","test":"yarn g:vitest run","test:watch":"yarn g:vitest watch"},"engines":{"node":">=18.0.0"},"sideEffects":false,"author":{"name":"AWS SDK for JavaScript Team","url":"https://aws.amazon.com/javascript/"},"license":"Apache-2.0","dependencies":{"@aws-crypto/sha256-browser":"5.2.0","@aws-crypto/sha256-js":"5.2.0","@aws-sdk/core":"3.935.0","@aws-sdk/middleware-host-header":"3.930.0","@aws-sdk/middleware-logger":"3.930.0","@aws-sdk/middleware-recursion-detection":"3.933.0","@aws-sdk/middleware-user-agent":"3.935.0","@aws-sdk/region-config-resolver":"3.930.0","@aws-sdk/types":"3.930.0","@aws-sdk/util-endpoints":"3.930.0","@aws-sdk/util-user-agent-browser":"3.930.0","@aws-sdk/util-user-agent-node":"3.935.0","@smithy/config-resolver":"^4.4.3","@smithy/core":"^3.18.5","@smithy/fetch-http-handler":"^5.3.6","@smithy/hash-node":"^4.2.5","@smithy/invalid-dependency":"^4.2.5","@smithy/middleware-content-length":"^4.2.5","@smithy/middleware-endpoint":"^4.3.12","@smithy/middleware-retry":"^4.4.12","@smithy/middleware-serde":"^4.2.6","@smithy/middleware-stack":"^4.2.5","@smithy/node-config-provider":"^4.3.5","@smithy/node-http-handler":"^4.4.5","@smithy/protocol-http":"^5.3.5","@smithy/smithy-client":"^4.9.8","@smithy/types":"^4.9.0","@smithy/url-parser":"^4.2.5","@smithy/util-base64":"^4.3.0","@smithy/util-body-length-browser":"^4.2.0","@smithy/util-body-length-node":"^4.2.1","@smithy/util-defaults-mode-browser":"^4.3.11","@smithy/util-defaults-mode-node":"^4.2.14","@smithy/util-endpoints":"^3.2.5","@smithy/util-middleware":"^4.2.5","@smithy/util-retry":"^4.2.5","@smithy/util-utf8":"^4.2.0","tslib":"^2.6.2"},"devDependencies":{"concurrently":"7.0.0","downlevel-dts":"0.10.1","rimraf":"3.0.2","typescript":"~5.8.3"},"typesVersions":{"<4.0":{"dist-types/*":["dist-types/ts3.4/*"]}},"files":["./sso-oidc.d.ts","./sso-oidc.js","./sts.d.ts","./sts.js","dist-*/**"],"browser":{"./dist-es/submodules/sso-oidc/runtimeConfig":"./dist-es/submodules/sso-oidc/runtimeConfig.browser","./dist-es/submodules/sts/runtimeConfig":"./dist-es/submodules/sts/runtimeConfig.browser"},"react-native":{},"homepage":"https://github.com/aws/aws-sdk-js-v3/tree/main/packages/nested-clients","repository":{"type":"git","url":"https://github.com/aws/aws-sdk-js-v3.git","directory":"packages/nested-clients"},"exports":{"./sso-oidc":{"types":"./dist-types/submodules/sso-oidc/index.d.ts","module":"./dist-es/submodules/sso-oidc/index.js","node":"./dist-cjs/submodules/sso-oidc/index.js","import":"./dist-es/submodules/sso-oidc/index.js","require":"./dist-cjs/submodules/sso-oidc/index.js"},"./sts":{"types":"./dist-types/submodules/sts/index.d.ts","module":"./dist-es/submodules/sts/index.js","node":"./dist-cjs/submodules/sts/index.js","import":"./dist-es/submodules/sts/index.js","require":"./dist-cjs/submodules/sts/index.js"}}}'); + +/***/ }) + +}; +; \ No newline at end of file diff --git a/dist/360.index.js b/dist/360.index.js new file mode 100644 index 0000000..728715f --- /dev/null +++ b/dist/360.index.js @@ -0,0 +1,93 @@ +"use strict"; +exports.id = 360; +exports.ids = [360]; +exports.modules = { + +/***/ 5360: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + + +var sharedIniFileLoader = __webpack_require__(4964); +var propertyProvider = __webpack_require__(8857); +var child_process = __webpack_require__(5317); +var util = __webpack_require__(9023); +var client = __webpack_require__(5152); + +const getValidatedProcessCredentials = (profileName, data, profiles) => { + if (data.Version !== 1) { + throw Error(`Profile ${profileName} credential_process did not return Version 1.`); + } + if (data.AccessKeyId === undefined || data.SecretAccessKey === undefined) { + throw Error(`Profile ${profileName} credential_process returned invalid credentials.`); + } + if (data.Expiration) { + const currentTime = new Date(); + const expireTime = new Date(data.Expiration); + if (expireTime < currentTime) { + throw Error(`Profile ${profileName} credential_process returned expired credentials.`); + } + } + let accountId = data.AccountId; + if (!accountId && profiles?.[profileName]?.aws_account_id) { + accountId = profiles[profileName].aws_account_id; + } + const credentials = { + accessKeyId: data.AccessKeyId, + secretAccessKey: data.SecretAccessKey, + ...(data.SessionToken && { sessionToken: data.SessionToken }), + ...(data.Expiration && { expiration: new Date(data.Expiration) }), + ...(data.CredentialScope && { credentialScope: data.CredentialScope }), + ...(accountId && { accountId }), + }; + client.setCredentialFeature(credentials, "CREDENTIALS_PROCESS", "w"); + return credentials; +}; + +const resolveProcessCredentials = async (profileName, profiles, logger) => { + const profile = profiles[profileName]; + if (profiles[profileName]) { + const credentialProcess = profile["credential_process"]; + if (credentialProcess !== undefined) { + const execPromise = util.promisify(sharedIniFileLoader.externalDataInterceptor?.getTokenRecord?.().exec ?? child_process.exec); + try { + const { stdout } = await execPromise(credentialProcess); + let data; + try { + data = JSON.parse(stdout.trim()); + } + catch { + throw Error(`Profile ${profileName} credential_process returned invalid JSON.`); + } + return getValidatedProcessCredentials(profileName, data, profiles); + } + catch (error) { + throw new propertyProvider.CredentialsProviderError(error.message, { logger }); + } + } + else { + throw new propertyProvider.CredentialsProviderError(`Profile ${profileName} did not contain credential_process.`, { logger }); + } + } + else { + throw new propertyProvider.CredentialsProviderError(`Profile ${profileName} could not be found in shared credentials file.`, { + logger, + }); + } +}; + +const fromProcess = (init = {}) => async ({ callerClientConfig } = {}) => { + init.logger?.debug("@aws-sdk/credential-provider-process - fromProcess"); + const profiles = await sharedIniFileLoader.parseKnownFiles(init); + return resolveProcessCredentials(sharedIniFileLoader.getProfileName({ + profile: init.profile ?? callerClientConfig?.profile, + }), profiles, init.logger); +}; + +exports.fromProcess = fromProcess; + + +/***/ }) + +}; +; \ No newline at end of file diff --git a/dist/443.index.js b/dist/443.index.js new file mode 100644 index 0000000..b422576 --- /dev/null +++ b/dist/443.index.js @@ -0,0 +1,795 @@ +"use strict"; +exports.id = 443; +exports.ids = [443]; +exports.modules = { + +/***/ 8396: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.resolveHttpAuthSchemeConfig = exports.defaultSSOOIDCHttpAuthSchemeProvider = exports.defaultSSOOIDCHttpAuthSchemeParametersProvider = void 0; +const core_1 = __webpack_require__(8704); +const util_middleware_1 = __webpack_require__(6324); +const defaultSSOOIDCHttpAuthSchemeParametersProvider = async (config, context, input) => { + return { + operation: (0, util_middleware_1.getSmithyContext)(context).operation, + region: (await (0, util_middleware_1.normalizeProvider)(config.region)()) || + (() => { + throw new Error("expected `region` to be configured for `aws.auth#sigv4`"); + })(), + }; +}; +exports.defaultSSOOIDCHttpAuthSchemeParametersProvider = defaultSSOOIDCHttpAuthSchemeParametersProvider; +function createAwsAuthSigv4HttpAuthOption(authParameters) { + return { + schemeId: "aws.auth#sigv4", + signingProperties: { + name: "sso-oauth", + region: authParameters.region, + }, + propertiesExtractor: (config, context) => ({ + signingProperties: { + config, + context, + }, + }), + }; +} +function createSmithyApiNoAuthHttpAuthOption(authParameters) { + return { + schemeId: "smithy.api#noAuth", + }; +} +const defaultSSOOIDCHttpAuthSchemeProvider = (authParameters) => { + const options = []; + switch (authParameters.operation) { + case "CreateToken": { + options.push(createSmithyApiNoAuthHttpAuthOption(authParameters)); + break; + } + default: { + options.push(createAwsAuthSigv4HttpAuthOption(authParameters)); + } + } + return options; +}; +exports.defaultSSOOIDCHttpAuthSchemeProvider = defaultSSOOIDCHttpAuthSchemeProvider; +const resolveHttpAuthSchemeConfig = (config) => { + const config_0 = (0, core_1.resolveAwsSdkSigV4Config)(config); + return Object.assign(config_0, { + authSchemePreference: (0, util_middleware_1.normalizeProvider)(config.authSchemePreference ?? []), + }); +}; +exports.resolveHttpAuthSchemeConfig = resolveHttpAuthSchemeConfig; + + +/***/ }), + +/***/ 546: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.defaultEndpointResolver = void 0; +const util_endpoints_1 = __webpack_require__(3068); +const util_endpoints_2 = __webpack_require__(9674); +const ruleset_1 = __webpack_require__(9947); +const cache = new util_endpoints_2.EndpointCache({ + size: 50, + params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"], +}); +const defaultEndpointResolver = (endpointParams, context = {}) => { + return cache.get(endpointParams, () => (0, util_endpoints_2.resolveEndpoint)(ruleset_1.ruleSet, { + endpointParams: endpointParams, + logger: context.logger, + })); +}; +exports.defaultEndpointResolver = defaultEndpointResolver; +util_endpoints_2.customEndpointFunctions.aws = util_endpoints_1.awsEndpointFunctions; + + +/***/ }), + +/***/ 9947: +/***/ ((__unused_webpack_module, exports) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ruleSet = void 0; +const u = "required", v = "fn", w = "argv", x = "ref"; +const a = true, b = "isSet", c = "booleanEquals", d = "error", e = "endpoint", f = "tree", g = "PartitionResult", h = "getAttr", i = { [u]: false, "type": "string" }, j = { [u]: true, "default": false, "type": "boolean" }, k = { [x]: "Endpoint" }, l = { [v]: c, [w]: [{ [x]: "UseFIPS" }, true] }, m = { [v]: c, [w]: [{ [x]: "UseDualStack" }, true] }, n = {}, o = { [v]: h, [w]: [{ [x]: g }, "supportsFIPS"] }, p = { [x]: g }, q = { [v]: c, [w]: [true, { [v]: h, [w]: [p, "supportsDualStack"] }] }, r = [l], s = [m], t = [{ [x]: "Region" }]; +const _data = { version: "1.0", parameters: { Region: i, UseDualStack: j, UseFIPS: j, Endpoint: i }, rules: [{ conditions: [{ [v]: b, [w]: [k] }], rules: [{ conditions: r, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: d }, { conditions: s, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: d }, { endpoint: { url: k, properties: n, headers: n }, type: e }], type: f }, { conditions: [{ [v]: b, [w]: t }], rules: [{ conditions: [{ [v]: "aws.partition", [w]: t, assign: g }], rules: [{ conditions: [l, m], rules: [{ conditions: [{ [v]: c, [w]: [a, o] }, q], rules: [{ endpoint: { url: "https://oidc-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: n, headers: n }, type: e }], type: f }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: d }], type: f }, { conditions: r, rules: [{ conditions: [{ [v]: c, [w]: [o, a] }], rules: [{ conditions: [{ [v]: "stringEquals", [w]: [{ [v]: h, [w]: [p, "name"] }, "aws-us-gov"] }], endpoint: { url: "https://oidc.{Region}.amazonaws.com", properties: n, headers: n }, type: e }, { endpoint: { url: "https://oidc-fips.{Region}.{PartitionResult#dnsSuffix}", properties: n, headers: n }, type: e }], type: f }, { error: "FIPS is enabled but this partition does not support FIPS", type: d }], type: f }, { conditions: s, rules: [{ conditions: [q], rules: [{ endpoint: { url: "https://oidc.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: n, headers: n }, type: e }], type: f }, { error: "DualStack is enabled but this partition does not support DualStack", type: d }], type: f }, { endpoint: { url: "https://oidc.{Region}.{PartitionResult#dnsSuffix}", properties: n, headers: n }, type: e }], type: f }], type: f }, { error: "Invalid Configuration: Missing Region", type: d }] }; +exports.ruleSet = _data; + + +/***/ }), + +/***/ 9443: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +var __webpack_unused_export__; + + +var middlewareHostHeader = __webpack_require__(2590); +var middlewareLogger = __webpack_require__(5242); +var middlewareRecursionDetection = __webpack_require__(1568); +var middlewareUserAgent = __webpack_require__(2959); +var configResolver = __webpack_require__(9316); +var core = __webpack_require__(402); +var schema = __webpack_require__(6890); +var middlewareContentLength = __webpack_require__(7212); +var middlewareEndpoint = __webpack_require__(99); +var middlewareRetry = __webpack_require__(9618); +var smithyClient = __webpack_require__(1411); +var httpAuthSchemeProvider = __webpack_require__(8396); +var runtimeConfig = __webpack_require__(6901); +var regionConfigResolver = __webpack_require__(6463); +var protocolHttp = __webpack_require__(2356); + +const resolveClientEndpointParameters = (options) => { + return Object.assign(options, { + useDualstackEndpoint: options.useDualstackEndpoint ?? false, + useFipsEndpoint: options.useFipsEndpoint ?? false, + defaultSigningName: "sso-oauth", + }); +}; +const commonParams = { + UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" }, + Endpoint: { type: "builtInParams", name: "endpoint" }, + Region: { type: "builtInParams", name: "region" }, + UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }, +}; + +const getHttpAuthExtensionConfiguration = (runtimeConfig) => { + const _httpAuthSchemes = runtimeConfig.httpAuthSchemes; + let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider; + let _credentials = runtimeConfig.credentials; + return { + setHttpAuthScheme(httpAuthScheme) { + const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId); + if (index === -1) { + _httpAuthSchemes.push(httpAuthScheme); + } + else { + _httpAuthSchemes.splice(index, 1, httpAuthScheme); + } + }, + httpAuthSchemes() { + return _httpAuthSchemes; + }, + setHttpAuthSchemeProvider(httpAuthSchemeProvider) { + _httpAuthSchemeProvider = httpAuthSchemeProvider; + }, + httpAuthSchemeProvider() { + return _httpAuthSchemeProvider; + }, + setCredentials(credentials) { + _credentials = credentials; + }, + credentials() { + return _credentials; + }, + }; +}; +const resolveHttpAuthRuntimeConfig = (config) => { + return { + httpAuthSchemes: config.httpAuthSchemes(), + httpAuthSchemeProvider: config.httpAuthSchemeProvider(), + credentials: config.credentials(), + }; +}; + +const resolveRuntimeExtensions = (runtimeConfig, extensions) => { + const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig)); + extensions.forEach((extension) => extension.configure(extensionConfiguration)); + return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration)); +}; + +class SSOOIDCClient extends smithyClient.Client { + config; + constructor(...[configuration]) { + const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {}); + super(_config_0); + this.initConfig = _config_0; + const _config_1 = resolveClientEndpointParameters(_config_0); + const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1); + const _config_3 = middlewareRetry.resolveRetryConfig(_config_2); + const _config_4 = configResolver.resolveRegionConfig(_config_3); + const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4); + const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5); + const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6); + const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []); + this.config = _config_8; + this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config)); + this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config)); + this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config)); + this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config)); + this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config)); + this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config)); + this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config)); + this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, { + httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultSSOOIDCHttpAuthSchemeParametersProvider, + identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({ + "aws.auth#sigv4": config.credentials, + }), + })); + this.middlewareStack.use(core.getHttpSigningPlugin(this.config)); + } + destroy() { + super.destroy(); + } +} + +let SSOOIDCServiceException$1 = class SSOOIDCServiceException extends smithyClient.ServiceException { + constructor(options) { + super(options); + Object.setPrototypeOf(this, SSOOIDCServiceException.prototype); + } +}; + +let AccessDeniedException$1 = class AccessDeniedException extends SSOOIDCServiceException$1 { + name = "AccessDeniedException"; + $fault = "client"; + error; + reason; + error_description; + constructor(opts) { + super({ + name: "AccessDeniedException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, AccessDeniedException.prototype); + this.error = opts.error; + this.reason = opts.reason; + this.error_description = opts.error_description; + } +}; +let AuthorizationPendingException$1 = class AuthorizationPendingException extends SSOOIDCServiceException$1 { + name = "AuthorizationPendingException"; + $fault = "client"; + error; + error_description; + constructor(opts) { + super({ + name: "AuthorizationPendingException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, AuthorizationPendingException.prototype); + this.error = opts.error; + this.error_description = opts.error_description; + } +}; +let ExpiredTokenException$1 = class ExpiredTokenException extends SSOOIDCServiceException$1 { + name = "ExpiredTokenException"; + $fault = "client"; + error; + error_description; + constructor(opts) { + super({ + name: "ExpiredTokenException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, ExpiredTokenException.prototype); + this.error = opts.error; + this.error_description = opts.error_description; + } +}; +let InternalServerException$1 = class InternalServerException extends SSOOIDCServiceException$1 { + name = "InternalServerException"; + $fault = "server"; + error; + error_description; + constructor(opts) { + super({ + name: "InternalServerException", + $fault: "server", + ...opts, + }); + Object.setPrototypeOf(this, InternalServerException.prototype); + this.error = opts.error; + this.error_description = opts.error_description; + } +}; +let InvalidClientException$1 = class InvalidClientException extends SSOOIDCServiceException$1 { + name = "InvalidClientException"; + $fault = "client"; + error; + error_description; + constructor(opts) { + super({ + name: "InvalidClientException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, InvalidClientException.prototype); + this.error = opts.error; + this.error_description = opts.error_description; + } +}; +let InvalidGrantException$1 = class InvalidGrantException extends SSOOIDCServiceException$1 { + name = "InvalidGrantException"; + $fault = "client"; + error; + error_description; + constructor(opts) { + super({ + name: "InvalidGrantException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, InvalidGrantException.prototype); + this.error = opts.error; + this.error_description = opts.error_description; + } +}; +let InvalidRequestException$1 = class InvalidRequestException extends SSOOIDCServiceException$1 { + name = "InvalidRequestException"; + $fault = "client"; + error; + reason; + error_description; + constructor(opts) { + super({ + name: "InvalidRequestException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, InvalidRequestException.prototype); + this.error = opts.error; + this.reason = opts.reason; + this.error_description = opts.error_description; + } +}; +let InvalidScopeException$1 = class InvalidScopeException extends SSOOIDCServiceException$1 { + name = "InvalidScopeException"; + $fault = "client"; + error; + error_description; + constructor(opts) { + super({ + name: "InvalidScopeException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, InvalidScopeException.prototype); + this.error = opts.error; + this.error_description = opts.error_description; + } +}; +let SlowDownException$1 = class SlowDownException extends SSOOIDCServiceException$1 { + name = "SlowDownException"; + $fault = "client"; + error; + error_description; + constructor(opts) { + super({ + name: "SlowDownException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, SlowDownException.prototype); + this.error = opts.error; + this.error_description = opts.error_description; + } +}; +let UnauthorizedClientException$1 = class UnauthorizedClientException extends SSOOIDCServiceException$1 { + name = "UnauthorizedClientException"; + $fault = "client"; + error; + error_description; + constructor(opts) { + super({ + name: "UnauthorizedClientException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, UnauthorizedClientException.prototype); + this.error = opts.error; + this.error_description = opts.error_description; + } +}; +let UnsupportedGrantTypeException$1 = class UnsupportedGrantTypeException extends SSOOIDCServiceException$1 { + name = "UnsupportedGrantTypeException"; + $fault = "client"; + error; + error_description; + constructor(opts) { + super({ + name: "UnsupportedGrantTypeException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, UnsupportedGrantTypeException.prototype); + this.error = opts.error; + this.error_description = opts.error_description; + } +}; + +const _ADE = "AccessDeniedException"; +const _APE = "AuthorizationPendingException"; +const _AT = "AccessToken"; +const _CS = "ClientSecret"; +const _CT = "CreateToken"; +const _CTR = "CreateTokenRequest"; +const _CTRr = "CreateTokenResponse"; +const _CV = "CodeVerifier"; +const _ETE = "ExpiredTokenException"; +const _ICE = "InvalidClientException"; +const _IGE = "InvalidGrantException"; +const _IRE = "InvalidRequestException"; +const _ISE = "InternalServerException"; +const _ISEn = "InvalidScopeException"; +const _IT = "IdToken"; +const _RT = "RefreshToken"; +const _SDE = "SlowDownException"; +const _UCE = "UnauthorizedClientException"; +const _UGTE = "UnsupportedGrantTypeException"; +const _aT = "accessToken"; +const _c = "client"; +const _cI = "clientId"; +const _cS = "clientSecret"; +const _cV = "codeVerifier"; +const _co = "code"; +const _dC = "deviceCode"; +const _e = "error"; +const _eI = "expiresIn"; +const _ed = "error_description"; +const _gT = "grantType"; +const _h = "http"; +const _hE = "httpError"; +const _iT = "idToken"; +const _r = "reason"; +const _rT = "refreshToken"; +const _rU = "redirectUri"; +const _s = "scope"; +const _se = "server"; +const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.ssooidc"; +const _tT = "tokenType"; +const n0 = "com.amazonaws.ssooidc"; +var AccessToken = [0, n0, _AT, 8, 0]; +var ClientSecret = [0, n0, _CS, 8, 0]; +var CodeVerifier = [0, n0, _CV, 8, 0]; +var IdToken = [0, n0, _IT, 8, 0]; +var RefreshToken = [0, n0, _RT, 8, 0]; +var AccessDeniedException = [ + -3, + n0, + _ADE, + { + [_e]: _c, + [_hE]: 400, + }, + [_e, _r, _ed], + [0, 0, 0], +]; +schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1); +var AuthorizationPendingException = [ + -3, + n0, + _APE, + { + [_e]: _c, + [_hE]: 400, + }, + [_e, _ed], + [0, 0], +]; +schema.TypeRegistry.for(n0).registerError(AuthorizationPendingException, AuthorizationPendingException$1); +var CreateTokenRequest = [ + 3, + n0, + _CTR, + 0, + [_cI, _cS, _gT, _dC, _co, _rT, _s, _rU, _cV], + [0, [() => ClientSecret, 0], 0, 0, 0, [() => RefreshToken, 0], 64 | 0, 0, [() => CodeVerifier, 0]], +]; +var CreateTokenResponse = [ + 3, + n0, + _CTRr, + 0, + [_aT, _tT, _eI, _rT, _iT], + [[() => AccessToken, 0], 0, 1, [() => RefreshToken, 0], [() => IdToken, 0]], +]; +var ExpiredTokenException = [ + -3, + n0, + _ETE, + { + [_e]: _c, + [_hE]: 400, + }, + [_e, _ed], + [0, 0], +]; +schema.TypeRegistry.for(n0).registerError(ExpiredTokenException, ExpiredTokenException$1); +var InternalServerException = [ + -3, + n0, + _ISE, + { + [_e]: _se, + [_hE]: 500, + }, + [_e, _ed], + [0, 0], +]; +schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1); +var InvalidClientException = [ + -3, + n0, + _ICE, + { + [_e]: _c, + [_hE]: 401, + }, + [_e, _ed], + [0, 0], +]; +schema.TypeRegistry.for(n0).registerError(InvalidClientException, InvalidClientException$1); +var InvalidGrantException = [ + -3, + n0, + _IGE, + { + [_e]: _c, + [_hE]: 400, + }, + [_e, _ed], + [0, 0], +]; +schema.TypeRegistry.for(n0).registerError(InvalidGrantException, InvalidGrantException$1); +var InvalidRequestException = [ + -3, + n0, + _IRE, + { + [_e]: _c, + [_hE]: 400, + }, + [_e, _r, _ed], + [0, 0, 0], +]; +schema.TypeRegistry.for(n0).registerError(InvalidRequestException, InvalidRequestException$1); +var InvalidScopeException = [ + -3, + n0, + _ISEn, + { + [_e]: _c, + [_hE]: 400, + }, + [_e, _ed], + [0, 0], +]; +schema.TypeRegistry.for(n0).registerError(InvalidScopeException, InvalidScopeException$1); +var SlowDownException = [ + -3, + n0, + _SDE, + { + [_e]: _c, + [_hE]: 400, + }, + [_e, _ed], + [0, 0], +]; +schema.TypeRegistry.for(n0).registerError(SlowDownException, SlowDownException$1); +var UnauthorizedClientException = [ + -3, + n0, + _UCE, + { + [_e]: _c, + [_hE]: 400, + }, + [_e, _ed], + [0, 0], +]; +schema.TypeRegistry.for(n0).registerError(UnauthorizedClientException, UnauthorizedClientException$1); +var UnsupportedGrantTypeException = [ + -3, + n0, + _UGTE, + { + [_e]: _c, + [_hE]: 400, + }, + [_e, _ed], + [0, 0], +]; +schema.TypeRegistry.for(n0).registerError(UnsupportedGrantTypeException, UnsupportedGrantTypeException$1); +var SSOOIDCServiceException = [-3, _sm, "SSOOIDCServiceException", 0, [], []]; +schema.TypeRegistry.for(_sm).registerError(SSOOIDCServiceException, SSOOIDCServiceException$1); +var CreateToken = [ + 9, + n0, + _CT, + { + [_h]: ["POST", "/token", 200], + }, + () => CreateTokenRequest, + () => CreateTokenResponse, +]; + +class CreateTokenCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("AWSSSOOIDCService", "CreateToken", {}) + .n("SSOOIDCClient", "CreateTokenCommand") + .sc(CreateToken) + .build() { +} + +const commands = { + CreateTokenCommand, +}; +class SSOOIDC extends SSOOIDCClient { +} +smithyClient.createAggregatedClient(commands, SSOOIDC); + +const AccessDeniedExceptionReason = { + KMS_ACCESS_DENIED: "KMS_AccessDeniedException", +}; +const InvalidRequestExceptionReason = { + KMS_DISABLED_KEY: "KMS_DisabledException", + KMS_INVALID_KEY_USAGE: "KMS_InvalidKeyUsageException", + KMS_INVALID_STATE: "KMS_InvalidStateException", + KMS_KEY_NOT_FOUND: "KMS_NotFoundException", +}; + +__webpack_unused_export__ = ({ + enumerable: true, + get: function () { return smithyClient.Command; } +}); +__webpack_unused_export__ = ({ + enumerable: true, + get: function () { return smithyClient.Client; } +}); +__webpack_unused_export__ = AccessDeniedException$1; +__webpack_unused_export__ = AccessDeniedExceptionReason; +__webpack_unused_export__ = AuthorizationPendingException$1; +exports.CreateTokenCommand = CreateTokenCommand; +__webpack_unused_export__ = ExpiredTokenException$1; +__webpack_unused_export__ = InternalServerException$1; +__webpack_unused_export__ = InvalidClientException$1; +__webpack_unused_export__ = InvalidGrantException$1; +__webpack_unused_export__ = InvalidRequestException$1; +__webpack_unused_export__ = InvalidRequestExceptionReason; +__webpack_unused_export__ = InvalidScopeException$1; +__webpack_unused_export__ = SSOOIDC; +exports.SSOOIDCClient = SSOOIDCClient; +__webpack_unused_export__ = SSOOIDCServiceException$1; +__webpack_unused_export__ = SlowDownException$1; +__webpack_unused_export__ = UnauthorizedClientException$1; +__webpack_unused_export__ = UnsupportedGrantTypeException$1; + + +/***/ }), + +/***/ 6901: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getRuntimeConfig = void 0; +const tslib_1 = __webpack_require__(1860); +const package_json_1 = tslib_1.__importDefault(__webpack_require__(9955)); +const core_1 = __webpack_require__(8704); +const util_user_agent_node_1 = __webpack_require__(1656); +const config_resolver_1 = __webpack_require__(9316); +const hash_node_1 = __webpack_require__(2711); +const middleware_retry_1 = __webpack_require__(9618); +const node_config_provider_1 = __webpack_require__(5704); +const node_http_handler_1 = __webpack_require__(1279); +const util_body_length_node_1 = __webpack_require__(3638); +const util_retry_1 = __webpack_require__(5518); +const runtimeConfig_shared_1 = __webpack_require__(1546); +const smithy_client_1 = __webpack_require__(1411); +const util_defaults_mode_node_1 = __webpack_require__(5435); +const smithy_client_2 = __webpack_require__(1411); +const getRuntimeConfig = (config) => { + (0, smithy_client_2.emitWarningIfUnsupportedVersion)(process.version); + const defaultsMode = (0, util_defaults_mode_node_1.resolveDefaultsModeConfig)(config); + const defaultConfigProvider = () => defaultsMode().then(smithy_client_1.loadConfigsForDefaultMode); + const clientSharedValues = (0, runtimeConfig_shared_1.getRuntimeConfig)(config); + (0, core_1.emitWarningIfUnsupportedVersion)(process.version); + const loaderConfig = { + profile: config?.profile, + logger: clientSharedValues.logger, + }; + return { + ...clientSharedValues, + ...config, + runtime: "node", + defaultsMode, + authSchemePreference: config?.authSchemePreference ?? (0, node_config_provider_1.loadConfig)(core_1.NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig), + bodyLengthChecker: config?.bodyLengthChecker ?? util_body_length_node_1.calculateBodyLength, + defaultUserAgentProvider: config?.defaultUserAgentProvider ?? + (0, util_user_agent_node_1.createDefaultUserAgentProvider)({ serviceId: clientSharedValues.serviceId, clientVersion: package_json_1.default.version }), + maxAttempts: config?.maxAttempts ?? (0, node_config_provider_1.loadConfig)(middleware_retry_1.NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config), + region: config?.region ?? + (0, node_config_provider_1.loadConfig)(config_resolver_1.NODE_REGION_CONFIG_OPTIONS, { ...config_resolver_1.NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }), + requestHandler: node_http_handler_1.NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider), + retryMode: config?.retryMode ?? + (0, node_config_provider_1.loadConfig)({ + ...middleware_retry_1.NODE_RETRY_MODE_CONFIG_OPTIONS, + default: async () => (await defaultConfigProvider()).retryMode || util_retry_1.DEFAULT_RETRY_MODE, + }, config), + sha256: config?.sha256 ?? hash_node_1.Hash.bind(null, "sha256"), + streamCollector: config?.streamCollector ?? node_http_handler_1.streamCollector, + useDualstackEndpoint: config?.useDualstackEndpoint ?? (0, node_config_provider_1.loadConfig)(config_resolver_1.NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig), + useFipsEndpoint: config?.useFipsEndpoint ?? (0, node_config_provider_1.loadConfig)(config_resolver_1.NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig), + userAgentAppId: config?.userAgentAppId ?? (0, node_config_provider_1.loadConfig)(util_user_agent_node_1.NODE_APP_ID_CONFIG_OPTIONS, loaderConfig), + }; +}; +exports.getRuntimeConfig = getRuntimeConfig; + + +/***/ }), + +/***/ 1546: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getRuntimeConfig = void 0; +const core_1 = __webpack_require__(8704); +const protocols_1 = __webpack_require__(7288); +const core_2 = __webpack_require__(402); +const smithy_client_1 = __webpack_require__(1411); +const url_parser_1 = __webpack_require__(4494); +const util_base64_1 = __webpack_require__(8385); +const util_utf8_1 = __webpack_require__(1577); +const httpAuthSchemeProvider_1 = __webpack_require__(8396); +const endpointResolver_1 = __webpack_require__(546); +const getRuntimeConfig = (config) => { + return { + apiVersion: "2019-06-10", + base64Decoder: config?.base64Decoder ?? util_base64_1.fromBase64, + base64Encoder: config?.base64Encoder ?? util_base64_1.toBase64, + disableHostPrefix: config?.disableHostPrefix ?? false, + endpointProvider: config?.endpointProvider ?? endpointResolver_1.defaultEndpointResolver, + extensions: config?.extensions ?? [], + httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? httpAuthSchemeProvider_1.defaultSSOOIDCHttpAuthSchemeProvider, + httpAuthSchemes: config?.httpAuthSchemes ?? [ + { + schemeId: "aws.auth#sigv4", + identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"), + signer: new core_1.AwsSdkSigV4Signer(), + }, + { + schemeId: "smithy.api#noAuth", + identityProvider: (ipc) => ipc.getIdentityProvider("smithy.api#noAuth") || (async () => ({})), + signer: new core_2.NoAuthSigner(), + }, + ], + logger: config?.logger ?? new smithy_client_1.NoOpLogger(), + protocol: config?.protocol ?? new protocols_1.AwsRestJsonProtocol({ defaultNamespace: "com.amazonaws.ssooidc" }), + serviceId: config?.serviceId ?? "SSO OIDC", + urlParser: config?.urlParser ?? url_parser_1.parseUrl, + utf8Decoder: config?.utf8Decoder ?? util_utf8_1.fromUtf8, + utf8Encoder: config?.utf8Encoder ?? util_utf8_1.toUtf8, + }; +}; +exports.getRuntimeConfig = getRuntimeConfig; + + +/***/ }), + +/***/ 9955: +/***/ ((module) => { + +module.exports = /*#__PURE__*/JSON.parse('{"name":"@aws-sdk/nested-clients","version":"3.935.0","description":"Nested clients for AWS SDK packages.","main":"./dist-cjs/index.js","module":"./dist-es/index.js","types":"./dist-types/index.d.ts","scripts":{"build":"yarn lint && concurrently \'yarn:build:cjs\' \'yarn:build:es\' \'yarn:build:types\'","build:cjs":"node ../../scripts/compilation/inline nested-clients","build:es":"tsc -p tsconfig.es.json","build:include:deps":"lerna run --scope $npm_package_name --include-dependencies build","build:types":"tsc -p tsconfig.types.json","build:types:downlevel":"downlevel-dts dist-types dist-types/ts3.4","clean":"rimraf ./dist-* && rimraf *.tsbuildinfo","lint":"node ../../scripts/validation/submodules-linter.js --pkg nested-clients","test":"yarn g:vitest run","test:watch":"yarn g:vitest watch"},"engines":{"node":">=18.0.0"},"sideEffects":false,"author":{"name":"AWS SDK for JavaScript Team","url":"https://aws.amazon.com/javascript/"},"license":"Apache-2.0","dependencies":{"@aws-crypto/sha256-browser":"5.2.0","@aws-crypto/sha256-js":"5.2.0","@aws-sdk/core":"3.935.0","@aws-sdk/middleware-host-header":"3.930.0","@aws-sdk/middleware-logger":"3.930.0","@aws-sdk/middleware-recursion-detection":"3.933.0","@aws-sdk/middleware-user-agent":"3.935.0","@aws-sdk/region-config-resolver":"3.930.0","@aws-sdk/types":"3.930.0","@aws-sdk/util-endpoints":"3.930.0","@aws-sdk/util-user-agent-browser":"3.930.0","@aws-sdk/util-user-agent-node":"3.935.0","@smithy/config-resolver":"^4.4.3","@smithy/core":"^3.18.5","@smithy/fetch-http-handler":"^5.3.6","@smithy/hash-node":"^4.2.5","@smithy/invalid-dependency":"^4.2.5","@smithy/middleware-content-length":"^4.2.5","@smithy/middleware-endpoint":"^4.3.12","@smithy/middleware-retry":"^4.4.12","@smithy/middleware-serde":"^4.2.6","@smithy/middleware-stack":"^4.2.5","@smithy/node-config-provider":"^4.3.5","@smithy/node-http-handler":"^4.4.5","@smithy/protocol-http":"^5.3.5","@smithy/smithy-client":"^4.9.8","@smithy/types":"^4.9.0","@smithy/url-parser":"^4.2.5","@smithy/util-base64":"^4.3.0","@smithy/util-body-length-browser":"^4.2.0","@smithy/util-body-length-node":"^4.2.1","@smithy/util-defaults-mode-browser":"^4.3.11","@smithy/util-defaults-mode-node":"^4.2.14","@smithy/util-endpoints":"^3.2.5","@smithy/util-middleware":"^4.2.5","@smithy/util-retry":"^4.2.5","@smithy/util-utf8":"^4.2.0","tslib":"^2.6.2"},"devDependencies":{"concurrently":"7.0.0","downlevel-dts":"0.10.1","rimraf":"3.0.2","typescript":"~5.8.3"},"typesVersions":{"<4.0":{"dist-types/*":["dist-types/ts3.4/*"]}},"files":["./sso-oidc.d.ts","./sso-oidc.js","./sts.d.ts","./sts.js","dist-*/**"],"browser":{"./dist-es/submodules/sso-oidc/runtimeConfig":"./dist-es/submodules/sso-oidc/runtimeConfig.browser","./dist-es/submodules/sts/runtimeConfig":"./dist-es/submodules/sts/runtimeConfig.browser"},"react-native":{},"homepage":"https://github.com/aws/aws-sdk-js-v3/tree/main/packages/nested-clients","repository":{"type":"git","url":"https://github.com/aws/aws-sdk-js-v3.git","directory":"packages/nested-clients"},"exports":{"./sso-oidc":{"types":"./dist-types/submodules/sso-oidc/index.d.ts","module":"./dist-es/submodules/sso-oidc/index.js","node":"./dist-cjs/submodules/sso-oidc/index.js","import":"./dist-es/submodules/sso-oidc/index.js","require":"./dist-cjs/submodules/sso-oidc/index.js"},"./sts":{"types":"./dist-types/submodules/sts/index.d.ts","module":"./dist-es/submodules/sts/index.js","node":"./dist-cjs/submodules/sts/index.js","import":"./dist-es/submodules/sts/index.js","require":"./dist-cjs/submodules/sts/index.js"}}}'); + +/***/ }) + +}; +; \ No newline at end of file diff --git a/dist/566.index.js b/dist/566.index.js new file mode 100644 index 0000000..1e76c66 --- /dev/null +++ b/dist/566.index.js @@ -0,0 +1,387 @@ +"use strict"; +exports.id = 566; +exports.ids = [566]; +exports.modules = { + +/***/ 566: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +var __webpack_unused_export__; + + +var propertyProvider = __webpack_require__(8857); +var url = __webpack_require__(7016); +var buffer = __webpack_require__(181); +var http = __webpack_require__(8611); +var nodeConfigProvider = __webpack_require__(5704); +var urlParser = __webpack_require__(4494); + +function httpRequest(options) { + return new Promise((resolve, reject) => { + const req = http.request({ + method: "GET", + ...options, + hostname: options.hostname?.replace(/^\[(.+)\]$/, "$1"), + }); + req.on("error", (err) => { + reject(Object.assign(new propertyProvider.ProviderError("Unable to connect to instance metadata service"), err)); + req.destroy(); + }); + req.on("timeout", () => { + reject(new propertyProvider.ProviderError("TimeoutError from instance metadata service")); + req.destroy(); + }); + req.on("response", (res) => { + const { statusCode = 400 } = res; + if (statusCode < 200 || 300 <= statusCode) { + reject(Object.assign(new propertyProvider.ProviderError("Error response received from instance metadata service"), { statusCode })); + req.destroy(); + } + const chunks = []; + res.on("data", (chunk) => { + chunks.push(chunk); + }); + res.on("end", () => { + resolve(buffer.Buffer.concat(chunks)); + req.destroy(); + }); + }); + req.end(); + }); +} + +const isImdsCredentials = (arg) => Boolean(arg) && + typeof arg === "object" && + typeof arg.AccessKeyId === "string" && + typeof arg.SecretAccessKey === "string" && + typeof arg.Token === "string" && + typeof arg.Expiration === "string"; +const fromImdsCredentials = (creds) => ({ + accessKeyId: creds.AccessKeyId, + secretAccessKey: creds.SecretAccessKey, + sessionToken: creds.Token, + expiration: new Date(creds.Expiration), + ...(creds.AccountId && { accountId: creds.AccountId }), +}); + +const DEFAULT_TIMEOUT = 1000; +const DEFAULT_MAX_RETRIES = 0; +const providerConfigFromInit = ({ maxRetries = DEFAULT_MAX_RETRIES, timeout = DEFAULT_TIMEOUT, }) => ({ maxRetries, timeout }); + +const retry = (toRetry, maxRetries) => { + let promise = toRetry(); + for (let i = 0; i < maxRetries; i++) { + promise = promise.catch(toRetry); + } + return promise; +}; + +const ENV_CMDS_FULL_URI = "AWS_CONTAINER_CREDENTIALS_FULL_URI"; +const ENV_CMDS_RELATIVE_URI = "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI"; +const ENV_CMDS_AUTH_TOKEN = "AWS_CONTAINER_AUTHORIZATION_TOKEN"; +const fromContainerMetadata = (init = {}) => { + const { timeout, maxRetries } = providerConfigFromInit(init); + return () => retry(async () => { + const requestOptions = await getCmdsUri({ logger: init.logger }); + const credsResponse = JSON.parse(await requestFromEcsImds(timeout, requestOptions)); + if (!isImdsCredentials(credsResponse)) { + throw new propertyProvider.CredentialsProviderError("Invalid response received from instance metadata service.", { + logger: init.logger, + }); + } + return fromImdsCredentials(credsResponse); + }, maxRetries); +}; +const requestFromEcsImds = async (timeout, options) => { + if (process.env[ENV_CMDS_AUTH_TOKEN]) { + options.headers = { + ...options.headers, + Authorization: process.env[ENV_CMDS_AUTH_TOKEN], + }; + } + const buffer = await httpRequest({ + ...options, + timeout, + }); + return buffer.toString(); +}; +const CMDS_IP = "169.254.170.2"; +const GREENGRASS_HOSTS = { + localhost: true, + "127.0.0.1": true, +}; +const GREENGRASS_PROTOCOLS = { + "http:": true, + "https:": true, +}; +const getCmdsUri = async ({ logger }) => { + if (process.env[ENV_CMDS_RELATIVE_URI]) { + return { + hostname: CMDS_IP, + path: process.env[ENV_CMDS_RELATIVE_URI], + }; + } + if (process.env[ENV_CMDS_FULL_URI]) { + const parsed = url.parse(process.env[ENV_CMDS_FULL_URI]); + if (!parsed.hostname || !(parsed.hostname in GREENGRASS_HOSTS)) { + throw new propertyProvider.CredentialsProviderError(`${parsed.hostname} is not a valid container metadata service hostname`, { + tryNextLink: false, + logger, + }); + } + if (!parsed.protocol || !(parsed.protocol in GREENGRASS_PROTOCOLS)) { + throw new propertyProvider.CredentialsProviderError(`${parsed.protocol} is not a valid container metadata service protocol`, { + tryNextLink: false, + logger, + }); + } + return { + ...parsed, + port: parsed.port ? parseInt(parsed.port, 10) : undefined, + }; + } + throw new propertyProvider.CredentialsProviderError("The container metadata credential provider cannot be used unless" + + ` the ${ENV_CMDS_RELATIVE_URI} or ${ENV_CMDS_FULL_URI} environment` + + " variable is set", { + tryNextLink: false, + logger, + }); +}; + +class InstanceMetadataV1FallbackError extends propertyProvider.CredentialsProviderError { + tryNextLink; + name = "InstanceMetadataV1FallbackError"; + constructor(message, tryNextLink = true) { + super(message, tryNextLink); + this.tryNextLink = tryNextLink; + Object.setPrototypeOf(this, InstanceMetadataV1FallbackError.prototype); + } +} + +exports.yI = void 0; +(function (Endpoint) { + Endpoint["IPv4"] = "http://169.254.169.254"; + Endpoint["IPv6"] = "http://[fd00:ec2::254]"; +})(exports.yI || (exports.yI = {})); + +const ENV_ENDPOINT_NAME = "AWS_EC2_METADATA_SERVICE_ENDPOINT"; +const CONFIG_ENDPOINT_NAME = "ec2_metadata_service_endpoint"; +const ENDPOINT_CONFIG_OPTIONS = { + environmentVariableSelector: (env) => env[ENV_ENDPOINT_NAME], + configFileSelector: (profile) => profile[CONFIG_ENDPOINT_NAME], + default: undefined, +}; + +var EndpointMode; +(function (EndpointMode) { + EndpointMode["IPv4"] = "IPv4"; + EndpointMode["IPv6"] = "IPv6"; +})(EndpointMode || (EndpointMode = {})); + +const ENV_ENDPOINT_MODE_NAME = "AWS_EC2_METADATA_SERVICE_ENDPOINT_MODE"; +const CONFIG_ENDPOINT_MODE_NAME = "ec2_metadata_service_endpoint_mode"; +const ENDPOINT_MODE_CONFIG_OPTIONS = { + environmentVariableSelector: (env) => env[ENV_ENDPOINT_MODE_NAME], + configFileSelector: (profile) => profile[CONFIG_ENDPOINT_MODE_NAME], + default: EndpointMode.IPv4, +}; + +const getInstanceMetadataEndpoint = async () => urlParser.parseUrl((await getFromEndpointConfig()) || (await getFromEndpointModeConfig())); +const getFromEndpointConfig = async () => nodeConfigProvider.loadConfig(ENDPOINT_CONFIG_OPTIONS)(); +const getFromEndpointModeConfig = async () => { + const endpointMode = await nodeConfigProvider.loadConfig(ENDPOINT_MODE_CONFIG_OPTIONS)(); + switch (endpointMode) { + case EndpointMode.IPv4: + return exports.yI.IPv4; + case EndpointMode.IPv6: + return exports.yI.IPv6; + default: + throw new Error(`Unsupported endpoint mode: ${endpointMode}.` + ` Select from ${Object.values(EndpointMode)}`); + } +}; + +const STATIC_STABILITY_REFRESH_INTERVAL_SECONDS = 5 * 60; +const STATIC_STABILITY_REFRESH_INTERVAL_JITTER_WINDOW_SECONDS = 5 * 60; +const STATIC_STABILITY_DOC_URL = "https://docs.aws.amazon.com/sdkref/latest/guide/feature-static-credentials.html"; +const getExtendedInstanceMetadataCredentials = (credentials, logger) => { + const refreshInterval = STATIC_STABILITY_REFRESH_INTERVAL_SECONDS + + Math.floor(Math.random() * STATIC_STABILITY_REFRESH_INTERVAL_JITTER_WINDOW_SECONDS); + const newExpiration = new Date(Date.now() + refreshInterval * 1000); + logger.warn("Attempting credential expiration extension due to a credential service availability issue. A refresh of these " + + `credentials will be attempted after ${new Date(newExpiration)}.\nFor more information, please visit: ` + + STATIC_STABILITY_DOC_URL); + const originalExpiration = credentials.originalExpiration ?? credentials.expiration; + return { + ...credentials, + ...(originalExpiration ? { originalExpiration } : {}), + expiration: newExpiration, + }; +}; + +const staticStabilityProvider = (provider, options = {}) => { + const logger = options?.logger || console; + let pastCredentials; + return async () => { + let credentials; + try { + credentials = await provider(); + if (credentials.expiration && credentials.expiration.getTime() < Date.now()) { + credentials = getExtendedInstanceMetadataCredentials(credentials, logger); + } + } + catch (e) { + if (pastCredentials) { + logger.warn("Credential renew failed: ", e); + credentials = getExtendedInstanceMetadataCredentials(pastCredentials, logger); + } + else { + throw e; + } + } + pastCredentials = credentials; + return credentials; + }; +}; + +const IMDS_PATH = "/latest/meta-data/iam/security-credentials/"; +const IMDS_TOKEN_PATH = "/latest/api/token"; +const AWS_EC2_METADATA_V1_DISABLED = "AWS_EC2_METADATA_V1_DISABLED"; +const PROFILE_AWS_EC2_METADATA_V1_DISABLED = "ec2_metadata_v1_disabled"; +const X_AWS_EC2_METADATA_TOKEN = "x-aws-ec2-metadata-token"; +const fromInstanceMetadata = (init = {}) => staticStabilityProvider(getInstanceMetadataProvider(init), { logger: init.logger }); +const getInstanceMetadataProvider = (init = {}) => { + let disableFetchToken = false; + const { logger, profile } = init; + const { timeout, maxRetries } = providerConfigFromInit(init); + const getCredentials = async (maxRetries, options) => { + const isImdsV1Fallback = disableFetchToken || options.headers?.[X_AWS_EC2_METADATA_TOKEN] == null; + if (isImdsV1Fallback) { + let fallbackBlockedFromProfile = false; + let fallbackBlockedFromProcessEnv = false; + const configValue = await nodeConfigProvider.loadConfig({ + environmentVariableSelector: (env) => { + const envValue = env[AWS_EC2_METADATA_V1_DISABLED]; + fallbackBlockedFromProcessEnv = !!envValue && envValue !== "false"; + if (envValue === undefined) { + throw new propertyProvider.CredentialsProviderError(`${AWS_EC2_METADATA_V1_DISABLED} not set in env, checking config file next.`, { logger: init.logger }); + } + return fallbackBlockedFromProcessEnv; + }, + configFileSelector: (profile) => { + const profileValue = profile[PROFILE_AWS_EC2_METADATA_V1_DISABLED]; + fallbackBlockedFromProfile = !!profileValue && profileValue !== "false"; + return fallbackBlockedFromProfile; + }, + default: false, + }, { + profile, + })(); + if (init.ec2MetadataV1Disabled || configValue) { + const causes = []; + if (init.ec2MetadataV1Disabled) + causes.push("credential provider initialization (runtime option ec2MetadataV1Disabled)"); + if (fallbackBlockedFromProfile) + causes.push(`config file profile (${PROFILE_AWS_EC2_METADATA_V1_DISABLED})`); + if (fallbackBlockedFromProcessEnv) + causes.push(`process environment variable (${AWS_EC2_METADATA_V1_DISABLED})`); + throw new InstanceMetadataV1FallbackError(`AWS EC2 Metadata v1 fallback has been blocked by AWS SDK configuration in the following: [${causes.join(", ")}].`); + } + } + const imdsProfile = (await retry(async () => { + let profile; + try { + profile = await getProfile(options); + } + catch (err) { + if (err.statusCode === 401) { + disableFetchToken = false; + } + throw err; + } + return profile; + }, maxRetries)).trim(); + return retry(async () => { + let creds; + try { + creds = await getCredentialsFromProfile(imdsProfile, options, init); + } + catch (err) { + if (err.statusCode === 401) { + disableFetchToken = false; + } + throw err; + } + return creds; + }, maxRetries); + }; + return async () => { + const endpoint = await getInstanceMetadataEndpoint(); + if (disableFetchToken) { + logger?.debug("AWS SDK Instance Metadata", "using v1 fallback (no token fetch)"); + return getCredentials(maxRetries, { ...endpoint, timeout }); + } + else { + let token; + try { + token = (await getMetadataToken({ ...endpoint, timeout })).toString(); + } + catch (error) { + if (error?.statusCode === 400) { + throw Object.assign(error, { + message: "EC2 Metadata token request returned error", + }); + } + else if (error.message === "TimeoutError" || [403, 404, 405].includes(error.statusCode)) { + disableFetchToken = true; + } + logger?.debug("AWS SDK Instance Metadata", "using v1 fallback (initial)"); + return getCredentials(maxRetries, { ...endpoint, timeout }); + } + return getCredentials(maxRetries, { + ...endpoint, + headers: { + [X_AWS_EC2_METADATA_TOKEN]: token, + }, + timeout, + }); + } + }; +}; +const getMetadataToken = async (options) => httpRequest({ + ...options, + path: IMDS_TOKEN_PATH, + method: "PUT", + headers: { + "x-aws-ec2-metadata-token-ttl-seconds": "21600", + }, +}); +const getProfile = async (options) => (await httpRequest({ ...options, path: IMDS_PATH })).toString(); +const getCredentialsFromProfile = async (profile, options, init) => { + const credentialsResponse = JSON.parse((await httpRequest({ + ...options, + path: IMDS_PATH + profile, + })).toString()); + if (!isImdsCredentials(credentialsResponse)) { + throw new propertyProvider.CredentialsProviderError("Invalid response received from instance metadata service.", { + logger: init.logger, + }); + } + return fromImdsCredentials(credentialsResponse); +}; + +__webpack_unused_export__ = DEFAULT_MAX_RETRIES; +__webpack_unused_export__ = DEFAULT_TIMEOUT; +__webpack_unused_export__ = ENV_CMDS_AUTH_TOKEN; +exports.ENV_CMDS_FULL_URI = ENV_CMDS_FULL_URI; +exports.ENV_CMDS_RELATIVE_URI = ENV_CMDS_RELATIVE_URI; +exports.fromContainerMetadata = fromContainerMetadata; +exports.fromInstanceMetadata = fromInstanceMetadata; +exports.getInstanceMetadataEndpoint = getInstanceMetadataEndpoint; +exports.httpRequest = httpRequest; +__webpack_unused_export__ = providerConfigFromInit; + + +/***/ }) + +}; +; \ No newline at end of file diff --git a/dist/579.index.js b/dist/579.index.js new file mode 100644 index 0000000..a3cbf84 --- /dev/null +++ b/dist/579.index.js @@ -0,0 +1,270 @@ +"use strict"; +exports.id = 579; +exports.ids = [579]; +exports.modules = { + +/***/ 6579: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + + +var utilUtf8 = __webpack_require__(1577); + +class EventStreamSerde { + marshaller; + serializer; + deserializer; + serdeContext; + defaultContentType; + constructor({ marshaller, serializer, deserializer, serdeContext, defaultContentType, }) { + this.marshaller = marshaller; + this.serializer = serializer; + this.deserializer = deserializer; + this.serdeContext = serdeContext; + this.defaultContentType = defaultContentType; + } + async serializeEventStream({ eventStream, requestSchema, initialRequest, }) { + const marshaller = this.marshaller; + const eventStreamMember = requestSchema.getEventStreamMember(); + const unionSchema = requestSchema.getMemberSchema(eventStreamMember); + const serializer = this.serializer; + const defaultContentType = this.defaultContentType; + const initialRequestMarker = Symbol("initialRequestMarker"); + const eventStreamIterable = { + async *[Symbol.asyncIterator]() { + if (initialRequest) { + const headers = { + ":event-type": { type: "string", value: "initial-request" }, + ":message-type": { type: "string", value: "event" }, + ":content-type": { type: "string", value: defaultContentType }, + }; + serializer.write(requestSchema, initialRequest); + const body = serializer.flush(); + yield { + [initialRequestMarker]: true, + headers, + body, + }; + } + for await (const page of eventStream) { + yield page; + } + }, + }; + return marshaller.serialize(eventStreamIterable, (event) => { + if (event[initialRequestMarker]) { + return { + headers: event.headers, + body: event.body, + }; + } + const unionMember = Object.keys(event).find((key) => { + return key !== "__type"; + }) ?? ""; + const { additionalHeaders, body, eventType, explicitPayloadContentType } = this.writeEventBody(unionMember, unionSchema, event); + const headers = { + ":event-type": { type: "string", value: eventType }, + ":message-type": { type: "string", value: "event" }, + ":content-type": { type: "string", value: explicitPayloadContentType ?? defaultContentType }, + ...additionalHeaders, + }; + return { + headers, + body, + }; + }); + } + async deserializeEventStream({ response, responseSchema, initialResponseContainer, }) { + const marshaller = this.marshaller; + const eventStreamMember = responseSchema.getEventStreamMember(); + const unionSchema = responseSchema.getMemberSchema(eventStreamMember); + const memberSchemas = unionSchema.getMemberSchemas(); + const initialResponseMarker = Symbol("initialResponseMarker"); + const asyncIterable = marshaller.deserialize(response.body, async (event) => { + const unionMember = Object.keys(event).find((key) => { + return key !== "__type"; + }) ?? ""; + const body = event[unionMember].body; + if (unionMember === "initial-response") { + const dataObject = await this.deserializer.read(responseSchema, body); + delete dataObject[eventStreamMember]; + return { + [initialResponseMarker]: true, + ...dataObject, + }; + } + else if (unionMember in memberSchemas) { + const eventStreamSchema = memberSchemas[unionMember]; + if (eventStreamSchema.isStructSchema()) { + const out = {}; + let hasBindings = false; + for (const [name, member] of eventStreamSchema.structIterator()) { + const { eventHeader, eventPayload } = member.getMergedTraits(); + hasBindings = hasBindings || Boolean(eventHeader || eventPayload); + if (eventPayload) { + if (member.isBlobSchema()) { + out[name] = body; + } + else if (member.isStringSchema()) { + out[name] = (this.serdeContext?.utf8Encoder ?? utilUtf8.toUtf8)(body); + } + else if (member.isStructSchema()) { + out[name] = await this.deserializer.read(member, body); + } + } + else if (eventHeader) { + const value = event[unionMember].headers[name]?.value; + if (value != null) { + if (member.isNumericSchema()) { + if (value && typeof value === "object" && "bytes" in value) { + out[name] = BigInt(value.toString()); + } + else { + out[name] = Number(value); + } + } + else { + out[name] = value; + } + } + } + } + if (hasBindings) { + return { + [unionMember]: out, + }; + } + if (body.byteLength === 0) { + return { + [unionMember]: {}, + }; + } + } + return { + [unionMember]: await this.deserializer.read(eventStreamSchema, body), + }; + } + else { + return { + $unknown: event, + }; + } + }); + const asyncIterator = asyncIterable[Symbol.asyncIterator](); + const firstEvent = await asyncIterator.next(); + if (firstEvent.done) { + return asyncIterable; + } + if (firstEvent.value?.[initialResponseMarker]) { + if (!responseSchema) { + throw new Error("@smithy::core/protocols - initial-response event encountered in event stream but no response schema given."); + } + for (const [key, value] of Object.entries(firstEvent.value)) { + initialResponseContainer[key] = value; + } + } + return { + async *[Symbol.asyncIterator]() { + if (!firstEvent?.value?.[initialResponseMarker]) { + yield firstEvent.value; + } + while (true) { + const { done, value } = await asyncIterator.next(); + if (done) { + break; + } + yield value; + } + }, + }; + } + writeEventBody(unionMember, unionSchema, event) { + const serializer = this.serializer; + let eventType = unionMember; + let explicitPayloadMember = null; + let explicitPayloadContentType; + const isKnownSchema = (() => { + const struct = unionSchema.getSchema(); + return struct[4].includes(unionMember); + })(); + const additionalHeaders = {}; + if (!isKnownSchema) { + const [type, value] = event[unionMember]; + eventType = type; + serializer.write(15, value); + } + else { + const eventSchema = unionSchema.getMemberSchema(unionMember); + if (eventSchema.isStructSchema()) { + for (const [memberName, memberSchema] of eventSchema.structIterator()) { + const { eventHeader, eventPayload } = memberSchema.getMergedTraits(); + if (eventPayload) { + explicitPayloadMember = memberName; + } + else if (eventHeader) { + const value = event[unionMember][memberName]; + let type = "binary"; + if (memberSchema.isNumericSchema()) { + if ((-2) ** 31 <= value && value <= 2 ** 31 - 1) { + type = "integer"; + } + else { + type = "long"; + } + } + else if (memberSchema.isTimestampSchema()) { + type = "timestamp"; + } + else if (memberSchema.isStringSchema()) { + type = "string"; + } + else if (memberSchema.isBooleanSchema()) { + type = "boolean"; + } + if (value != null) { + additionalHeaders[memberName] = { + type, + value, + }; + delete event[unionMember][memberName]; + } + } + } + if (explicitPayloadMember !== null) { + const payloadSchema = eventSchema.getMemberSchema(explicitPayloadMember); + if (payloadSchema.isBlobSchema()) { + explicitPayloadContentType = "application/octet-stream"; + } + else if (payloadSchema.isStringSchema()) { + explicitPayloadContentType = "text/plain"; + } + serializer.write(payloadSchema, event[unionMember][explicitPayloadMember]); + } + else { + serializer.write(eventSchema, event[unionMember]); + } + } + else { + throw new Error("@smithy/core/event-streams - non-struct member not supported in event stream union."); + } + } + const messageSerialization = serializer.flush(); + const body = typeof messageSerialization === "string" + ? (this.serdeContext?.utf8Decoder ?? utilUtf8.fromUtf8)(messageSerialization) + : messageSerialization; + return { + body, + eventType, + explicitPayloadContentType, + additionalHeaders, + }; + } +} + +exports.EventStreamSerde = EventStreamSerde; + + +/***/ }) + +}; +; \ No newline at end of file diff --git a/dist/605.index.js b/dist/605.index.js new file mode 100644 index 0000000..0ff2fce --- /dev/null +++ b/dist/605.index.js @@ -0,0 +1,234 @@ +"use strict"; +exports.id = 605; +exports.ids = [605]; +exports.modules = { + +/***/ 1509: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.checkUrl = void 0; +const property_provider_1 = __webpack_require__(8857); +const LOOPBACK_CIDR_IPv4 = "127.0.0.0/8"; +const LOOPBACK_CIDR_IPv6 = "::1/128"; +const ECS_CONTAINER_HOST = "169.254.170.2"; +const EKS_CONTAINER_HOST_IPv4 = "169.254.170.23"; +const EKS_CONTAINER_HOST_IPv6 = "[fd00:ec2::23]"; +const checkUrl = (url, logger) => { + if (url.protocol === "https:") { + return; + } + if (url.hostname === ECS_CONTAINER_HOST || + url.hostname === EKS_CONTAINER_HOST_IPv4 || + url.hostname === EKS_CONTAINER_HOST_IPv6) { + return; + } + if (url.hostname.includes("[")) { + if (url.hostname === "[::1]" || url.hostname === "[0000:0000:0000:0000:0000:0000:0000:0001]") { + return; + } + } + else { + if (url.hostname === "localhost") { + return; + } + const ipComponents = url.hostname.split("."); + const inRange = (component) => { + const num = parseInt(component, 10); + return 0 <= num && num <= 255; + }; + if (ipComponents[0] === "127" && + inRange(ipComponents[1]) && + inRange(ipComponents[2]) && + inRange(ipComponents[3]) && + ipComponents.length === 4) { + return; + } + } + throw new property_provider_1.CredentialsProviderError(`URL not accepted. It must either be HTTPS or match one of the following: + - loopback CIDR 127.0.0.0/8 or [::1/128] + - ECS container host 169.254.170.2 + - EKS container host 169.254.170.23 or [fd00:ec2::23]`, { logger }); +}; +exports.checkUrl = checkUrl; + + +/***/ }), + +/***/ 8712: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.fromHttp = void 0; +const tslib_1 = __webpack_require__(1860); +const client_1 = __webpack_require__(5152); +const node_http_handler_1 = __webpack_require__(1279); +const property_provider_1 = __webpack_require__(8857); +const promises_1 = tslib_1.__importDefault(__webpack_require__(1943)); +const checkUrl_1 = __webpack_require__(1509); +const requestHelpers_1 = __webpack_require__(8914); +const retry_wrapper_1 = __webpack_require__(1122); +const AWS_CONTAINER_CREDENTIALS_RELATIVE_URI = "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI"; +const DEFAULT_LINK_LOCAL_HOST = "http://169.254.170.2"; +const AWS_CONTAINER_CREDENTIALS_FULL_URI = "AWS_CONTAINER_CREDENTIALS_FULL_URI"; +const AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE = "AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE"; +const AWS_CONTAINER_AUTHORIZATION_TOKEN = "AWS_CONTAINER_AUTHORIZATION_TOKEN"; +const fromHttp = (options = {}) => { + options.logger?.debug("@aws-sdk/credential-provider-http - fromHttp"); + let host; + const relative = options.awsContainerCredentialsRelativeUri ?? process.env[AWS_CONTAINER_CREDENTIALS_RELATIVE_URI]; + const full = options.awsContainerCredentialsFullUri ?? process.env[AWS_CONTAINER_CREDENTIALS_FULL_URI]; + const token = options.awsContainerAuthorizationToken ?? process.env[AWS_CONTAINER_AUTHORIZATION_TOKEN]; + const tokenFile = options.awsContainerAuthorizationTokenFile ?? process.env[AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE]; + const warn = options.logger?.constructor?.name === "NoOpLogger" || !options.logger?.warn + ? console.warn + : options.logger.warn.bind(options.logger); + if (relative && full) { + warn("@aws-sdk/credential-provider-http: " + + "you have set both awsContainerCredentialsRelativeUri and awsContainerCredentialsFullUri."); + warn("awsContainerCredentialsFullUri will take precedence."); + } + if (token && tokenFile) { + warn("@aws-sdk/credential-provider-http: " + + "you have set both awsContainerAuthorizationToken and awsContainerAuthorizationTokenFile."); + warn("awsContainerAuthorizationToken will take precedence."); + } + if (full) { + host = full; + } + else if (relative) { + host = `${DEFAULT_LINK_LOCAL_HOST}${relative}`; + } + else { + throw new property_provider_1.CredentialsProviderError(`No HTTP credential provider host provided. +Set AWS_CONTAINER_CREDENTIALS_FULL_URI or AWS_CONTAINER_CREDENTIALS_RELATIVE_URI.`, { logger: options.logger }); + } + const url = new URL(host); + (0, checkUrl_1.checkUrl)(url, options.logger); + const requestHandler = node_http_handler_1.NodeHttpHandler.create({ + requestTimeout: options.timeout ?? 1000, + connectionTimeout: options.timeout ?? 1000, + }); + return (0, retry_wrapper_1.retryWrapper)(async () => { + const request = (0, requestHelpers_1.createGetRequest)(url); + if (token) { + request.headers.Authorization = token; + } + else if (tokenFile) { + request.headers.Authorization = (await promises_1.default.readFile(tokenFile)).toString(); + } + try { + const result = await requestHandler.handle(request); + return (0, requestHelpers_1.getCredentials)(result.response).then((creds) => (0, client_1.setCredentialFeature)(creds, "CREDENTIALS_HTTP", "z")); + } + catch (e) { + throw new property_provider_1.CredentialsProviderError(String(e), { logger: options.logger }); + } + }, options.maxRetries ?? 3, options.timeout ?? 1000); +}; +exports.fromHttp = fromHttp; + + +/***/ }), + +/***/ 8914: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.createGetRequest = createGetRequest; +exports.getCredentials = getCredentials; +const property_provider_1 = __webpack_require__(8857); +const protocol_http_1 = __webpack_require__(2356); +const smithy_client_1 = __webpack_require__(1411); +const util_stream_1 = __webpack_require__(4252); +function createGetRequest(url) { + return new protocol_http_1.HttpRequest({ + protocol: url.protocol, + hostname: url.hostname, + port: Number(url.port), + path: url.pathname, + query: Array.from(url.searchParams.entries()).reduce((acc, [k, v]) => { + acc[k] = v; + return acc; + }, {}), + fragment: url.hash, + }); +} +async function getCredentials(response, logger) { + const stream = (0, util_stream_1.sdkStreamMixin)(response.body); + const str = await stream.transformToString(); + if (response.statusCode === 200) { + const parsed = JSON.parse(str); + if (typeof parsed.AccessKeyId !== "string" || + typeof parsed.SecretAccessKey !== "string" || + typeof parsed.Token !== "string" || + typeof parsed.Expiration !== "string") { + throw new property_provider_1.CredentialsProviderError("HTTP credential provider response not of the required format, an object matching: " + + "{ AccessKeyId: string, SecretAccessKey: string, Token: string, Expiration: string(rfc3339) }", { logger }); + } + return { + accessKeyId: parsed.AccessKeyId, + secretAccessKey: parsed.SecretAccessKey, + sessionToken: parsed.Token, + expiration: (0, smithy_client_1.parseRfc3339DateTime)(parsed.Expiration), + }; + } + if (response.statusCode >= 400 && response.statusCode < 500) { + let parsedBody = {}; + try { + parsedBody = JSON.parse(str); + } + catch (e) { } + throw Object.assign(new property_provider_1.CredentialsProviderError(`Server responded with status: ${response.statusCode}`, { logger }), { + Code: parsedBody.Code, + Message: parsedBody.Message, + }); + } + throw new property_provider_1.CredentialsProviderError(`Server responded with status: ${response.statusCode}`, { logger }); +} + + +/***/ }), + +/***/ 1122: +/***/ ((__unused_webpack_module, exports) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.retryWrapper = void 0; +const retryWrapper = (toRetry, maxRetries, delayMs) => { + return async () => { + for (let i = 0; i < maxRetries; ++i) { + try { + return await toRetry(); + } + catch (e) { + await new Promise((resolve) => setTimeout(resolve, delayMs)); + } + } + return await toRetry(); + }; +}; +exports.retryWrapper = retryWrapper; + + +/***/ }), + +/***/ 8605: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +var __webpack_unused_export__; + +__webpack_unused_export__ = ({ value: true }); +exports.fromHttp = void 0; +var fromHttp_1 = __webpack_require__(8712); +Object.defineProperty(exports, "fromHttp", ({ enumerable: true, get: function () { return fromHttp_1.fromHttp; } })); + + +/***/ }) + +}; +; \ No newline at end of file diff --git a/dist/869.index.js b/dist/869.index.js new file mode 100644 index 0000000..8680c7f --- /dev/null +++ b/dist/869.index.js @@ -0,0 +1,225 @@ +"use strict"; +exports.id = 869; +exports.ids = [869]; +exports.modules = { + +/***/ 5869: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + + +var sharedIniFileLoader = __webpack_require__(4964); +var propertyProvider = __webpack_require__(8857); +var client = __webpack_require__(5152); + +const resolveCredentialSource = (credentialSource, profileName, logger) => { + const sourceProvidersMap = { + EcsContainer: async (options) => { + const { fromHttp } = await __webpack_require__.e(/* import() */ 605).then(__webpack_require__.bind(__webpack_require__, 8605)); + const { fromContainerMetadata } = await __webpack_require__.e(/* import() */ 566).then(__webpack_require__.t.bind(__webpack_require__, 566, 19)); + logger?.debug("@aws-sdk/credential-provider-ini - credential_source is EcsContainer"); + return async () => propertyProvider.chain(fromHttp(options ?? {}), fromContainerMetadata(options))().then(setNamedProvider); + }, + Ec2InstanceMetadata: async (options) => { + logger?.debug("@aws-sdk/credential-provider-ini - credential_source is Ec2InstanceMetadata"); + const { fromInstanceMetadata } = await __webpack_require__.e(/* import() */ 566).then(__webpack_require__.t.bind(__webpack_require__, 566, 19)); + return async () => fromInstanceMetadata(options)().then(setNamedProvider); + }, + Environment: async (options) => { + logger?.debug("@aws-sdk/credential-provider-ini - credential_source is Environment"); + const { fromEnv } = await Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 5606, 19)); + return async () => fromEnv(options)().then(setNamedProvider); + }, + }; + if (credentialSource in sourceProvidersMap) { + return sourceProvidersMap[credentialSource]; + } + else { + throw new propertyProvider.CredentialsProviderError(`Unsupported credential source in profile ${profileName}. Got ${credentialSource}, ` + + `expected EcsContainer or Ec2InstanceMetadata or Environment.`, { logger }); + } +}; +const setNamedProvider = (creds) => client.setCredentialFeature(creds, "CREDENTIALS_PROFILE_NAMED_PROVIDER", "p"); + +const isAssumeRoleProfile = (arg, { profile = "default", logger } = {}) => { + return (Boolean(arg) && + typeof arg === "object" && + typeof arg.role_arn === "string" && + ["undefined", "string"].indexOf(typeof arg.role_session_name) > -1 && + ["undefined", "string"].indexOf(typeof arg.external_id) > -1 && + ["undefined", "string"].indexOf(typeof arg.mfa_serial) > -1 && + (isAssumeRoleWithSourceProfile(arg, { profile, logger }) || isCredentialSourceProfile(arg, { profile, logger }))); +}; +const isAssumeRoleWithSourceProfile = (arg, { profile, logger }) => { + const withSourceProfile = typeof arg.source_profile === "string" && typeof arg.credential_source === "undefined"; + if (withSourceProfile) { + logger?.debug?.(` ${profile} isAssumeRoleWithSourceProfile source_profile=${arg.source_profile}`); + } + return withSourceProfile; +}; +const isCredentialSourceProfile = (arg, { profile, logger }) => { + const withProviderProfile = typeof arg.credential_source === "string" && typeof arg.source_profile === "undefined"; + if (withProviderProfile) { + logger?.debug?.(` ${profile} isCredentialSourceProfile credential_source=${arg.credential_source}`); + } + return withProviderProfile; +}; +const resolveAssumeRoleCredentials = async (profileName, profiles, options, visitedProfiles = {}, resolveProfileData) => { + options.logger?.debug("@aws-sdk/credential-provider-ini - resolveAssumeRoleCredentials (STS)"); + const profileData = profiles[profileName]; + const { source_profile, region } = profileData; + if (!options.roleAssumer) { + const { getDefaultRoleAssumer } = await __webpack_require__.e(/* import() */ 136).then(__webpack_require__.t.bind(__webpack_require__, 1136, 23)); + options.roleAssumer = getDefaultRoleAssumer({ + ...options.clientConfig, + credentialProviderLogger: options.logger, + parentClientConfig: { + ...options?.parentClientConfig, + region: region ?? options?.parentClientConfig?.region, + }, + }, options.clientPlugins); + } + if (source_profile && source_profile in visitedProfiles) { + throw new propertyProvider.CredentialsProviderError(`Detected a cycle attempting to resolve credentials for profile` + + ` ${sharedIniFileLoader.getProfileName(options)}. Profiles visited: ` + + Object.keys(visitedProfiles).join(", "), { logger: options.logger }); + } + options.logger?.debug(`@aws-sdk/credential-provider-ini - finding credential resolver using ${source_profile ? `source_profile=[${source_profile}]` : `profile=[${profileName}]`}`); + const sourceCredsProvider = source_profile + ? resolveProfileData(source_profile, profiles, options, { + ...visitedProfiles, + [source_profile]: true, + }, isCredentialSourceWithoutRoleArn(profiles[source_profile] ?? {})) + : (await resolveCredentialSource(profileData.credential_source, profileName, options.logger)(options))(); + if (isCredentialSourceWithoutRoleArn(profileData)) { + return sourceCredsProvider.then((creds) => client.setCredentialFeature(creds, "CREDENTIALS_PROFILE_SOURCE_PROFILE", "o")); + } + else { + const params = { + RoleArn: profileData.role_arn, + RoleSessionName: profileData.role_session_name || `aws-sdk-js-${Date.now()}`, + ExternalId: profileData.external_id, + DurationSeconds: parseInt(profileData.duration_seconds || "3600", 10), + }; + const { mfa_serial } = profileData; + if (mfa_serial) { + if (!options.mfaCodeProvider) { + throw new propertyProvider.CredentialsProviderError(`Profile ${profileName} requires multi-factor authentication, but no MFA code callback was provided.`, { logger: options.logger, tryNextLink: false }); + } + params.SerialNumber = mfa_serial; + params.TokenCode = await options.mfaCodeProvider(mfa_serial); + } + const sourceCreds = await sourceCredsProvider; + return options.roleAssumer(sourceCreds, params).then((creds) => client.setCredentialFeature(creds, "CREDENTIALS_PROFILE_SOURCE_PROFILE", "o")); + } +}; +const isCredentialSourceWithoutRoleArn = (section) => { + return !section.role_arn && !!section.credential_source; +}; + +const isProcessProfile = (arg) => Boolean(arg) && typeof arg === "object" && typeof arg.credential_process === "string"; +const resolveProcessCredentials = async (options, profile) => __webpack_require__.e(/* import() */ 360).then(__webpack_require__.t.bind(__webpack_require__, 5360, 19)).then(({ fromProcess }) => fromProcess({ + ...options, + profile, +})().then((creds) => client.setCredentialFeature(creds, "CREDENTIALS_PROFILE_PROCESS", "v"))); + +const resolveSsoCredentials = async (profile, profileData, options = {}) => { + const { fromSSO } = await __webpack_require__.e(/* import() */ 998).then(__webpack_require__.t.bind(__webpack_require__, 998, 19)); + return fromSSO({ + profile, + logger: options.logger, + parentClientConfig: options.parentClientConfig, + clientConfig: options.clientConfig, + })().then((creds) => { + if (profileData.sso_session) { + return client.setCredentialFeature(creds, "CREDENTIALS_PROFILE_SSO", "r"); + } + else { + return client.setCredentialFeature(creds, "CREDENTIALS_PROFILE_SSO_LEGACY", "t"); + } + }); +}; +const isSsoProfile = (arg) => arg && + (typeof arg.sso_start_url === "string" || + typeof arg.sso_account_id === "string" || + typeof arg.sso_session === "string" || + typeof arg.sso_region === "string" || + typeof arg.sso_role_name === "string"); + +const isStaticCredsProfile = (arg) => Boolean(arg) && + typeof arg === "object" && + typeof arg.aws_access_key_id === "string" && + typeof arg.aws_secret_access_key === "string" && + ["undefined", "string"].indexOf(typeof arg.aws_session_token) > -1 && + ["undefined", "string"].indexOf(typeof arg.aws_account_id) > -1; +const resolveStaticCredentials = async (profile, options) => { + options?.logger?.debug("@aws-sdk/credential-provider-ini - resolveStaticCredentials"); + const credentials = { + accessKeyId: profile.aws_access_key_id, + secretAccessKey: profile.aws_secret_access_key, + sessionToken: profile.aws_session_token, + ...(profile.aws_credential_scope && { credentialScope: profile.aws_credential_scope }), + ...(profile.aws_account_id && { accountId: profile.aws_account_id }), + }; + return client.setCredentialFeature(credentials, "CREDENTIALS_PROFILE", "n"); +}; + +const isWebIdentityProfile = (arg) => Boolean(arg) && + typeof arg === "object" && + typeof arg.web_identity_token_file === "string" && + typeof arg.role_arn === "string" && + ["undefined", "string"].indexOf(typeof arg.role_session_name) > -1; +const resolveWebIdentityCredentials = async (profile, options) => __webpack_require__.e(/* import() */ 956).then(__webpack_require__.t.bind(__webpack_require__, 9956, 23)).then(({ fromTokenFile }) => fromTokenFile({ + webIdentityTokenFile: profile.web_identity_token_file, + roleArn: profile.role_arn, + roleSessionName: profile.role_session_name, + roleAssumerWithWebIdentity: options.roleAssumerWithWebIdentity, + logger: options.logger, + parentClientConfig: options.parentClientConfig, +})().then((creds) => client.setCredentialFeature(creds, "CREDENTIALS_PROFILE_STS_WEB_ID_TOKEN", "q"))); + +const resolveProfileData = async (profileName, profiles, options, visitedProfiles = {}, isAssumeRoleRecursiveCall = false) => { + const data = profiles[profileName]; + if (Object.keys(visitedProfiles).length > 0 && isStaticCredsProfile(data)) { + return resolveStaticCredentials(data, options); + } + if (isAssumeRoleRecursiveCall || isAssumeRoleProfile(data, { profile: profileName, logger: options.logger })) { + return resolveAssumeRoleCredentials(profileName, profiles, options, visitedProfiles, resolveProfileData); + } + if (isStaticCredsProfile(data)) { + return resolveStaticCredentials(data, options); + } + if (isWebIdentityProfile(data)) { + return resolveWebIdentityCredentials(data, options); + } + if (isProcessProfile(data)) { + return resolveProcessCredentials(options, profileName); + } + if (isSsoProfile(data)) { + return await resolveSsoCredentials(profileName, data, options); + } + throw new propertyProvider.CredentialsProviderError(`Could not resolve credentials using profile: [${profileName}] in configuration/credentials file(s).`, { logger: options.logger }); +}; + +const fromIni = (_init = {}) => async ({ callerClientConfig } = {}) => { + const init = { + ..._init, + parentClientConfig: { + ...callerClientConfig, + ..._init.parentClientConfig, + }, + }; + init.logger?.debug("@aws-sdk/credential-provider-ini - fromIni"); + const profiles = await sharedIniFileLoader.parseKnownFiles(init); + return resolveProfileData(sharedIniFileLoader.getProfileName({ + profile: _init.profile ?? callerClientConfig?.profile, + }), profiles, init); +}; + +exports.fromIni = fromIni; + + +/***/ }) + +}; +; \ No newline at end of file diff --git a/dist/956.index.js b/dist/956.index.js new file mode 100644 index 0000000..b2ce7d4 --- /dev/null +++ b/dist/956.index.js @@ -0,0 +1,1039 @@ +"use strict"; +exports.id = 956; +exports.ids = [956,136]; +exports.modules = { + +/***/ 8079: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.fromTokenFile = void 0; +const client_1 = __webpack_require__(5152); +const property_provider_1 = __webpack_require__(8857); +const shared_ini_file_loader_1 = __webpack_require__(4964); +const fs_1 = __webpack_require__(9896); +const fromWebToken_1 = __webpack_require__(4453); +const ENV_TOKEN_FILE = "AWS_WEB_IDENTITY_TOKEN_FILE"; +const ENV_ROLE_ARN = "AWS_ROLE_ARN"; +const ENV_ROLE_SESSION_NAME = "AWS_ROLE_SESSION_NAME"; +const fromTokenFile = (init = {}) => async (awsIdentityProperties) => { + init.logger?.debug("@aws-sdk/credential-provider-web-identity - fromTokenFile"); + const webIdentityTokenFile = init?.webIdentityTokenFile ?? process.env[ENV_TOKEN_FILE]; + const roleArn = init?.roleArn ?? process.env[ENV_ROLE_ARN]; + const roleSessionName = init?.roleSessionName ?? process.env[ENV_ROLE_SESSION_NAME]; + if (!webIdentityTokenFile || !roleArn) { + throw new property_provider_1.CredentialsProviderError("Web identity configuration not specified", { + logger: init.logger, + }); + } + const credentials = await (0, fromWebToken_1.fromWebToken)({ + ...init, + webIdentityToken: shared_ini_file_loader_1.externalDataInterceptor?.getTokenRecord?.()[webIdentityTokenFile] ?? + (0, fs_1.readFileSync)(webIdentityTokenFile, { encoding: "ascii" }), + roleArn, + roleSessionName, + })(awsIdentityProperties); + if (webIdentityTokenFile === process.env[ENV_TOKEN_FILE]) { + (0, client_1.setCredentialFeature)(credentials, "CREDENTIALS_ENV_VARS_STS_WEB_ID_TOKEN", "h"); + } + return credentials; +}; +exports.fromTokenFile = fromTokenFile; + + +/***/ }), + +/***/ 4453: +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + + +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 })); +exports.fromWebToken = void 0; +const fromWebToken = (init) => async (awsIdentityProperties) => { + init.logger?.debug("@aws-sdk/credential-provider-web-identity - fromWebToken"); + const { roleArn, roleSessionName, webIdentityToken, providerId, policyArns, policy, durationSeconds } = init; + let { roleAssumerWithWebIdentity } = init; + if (!roleAssumerWithWebIdentity) { + const { getDefaultRoleAssumerWithWebIdentity } = await Promise.resolve().then(() => __importStar(__webpack_require__(1136))); + roleAssumerWithWebIdentity = getDefaultRoleAssumerWithWebIdentity({ + ...init.clientConfig, + credentialProviderLogger: init.logger, + parentClientConfig: { + ...awsIdentityProperties?.callerClientConfig, + ...init.parentClientConfig, + }, + }, init.clientPlugins); + } + return roleAssumerWithWebIdentity({ + RoleArn: roleArn, + RoleSessionName: roleSessionName ?? `aws-sdk-js-session-${Date.now()}`, + WebIdentityToken: webIdentityToken, + ProviderId: providerId, + PolicyArns: policyArns, + Policy: policy, + DurationSeconds: durationSeconds, + }); +}; +exports.fromWebToken = fromWebToken; + + +/***/ }), + +/***/ 9956: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + + +var fromTokenFile = __webpack_require__(8079); +var fromWebToken = __webpack_require__(4453); + + + +Object.keys(fromTokenFile).forEach(function (k) { + if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, { + enumerable: true, + get: function () { return fromTokenFile[k]; } + }); +}); +Object.keys(fromWebToken).forEach(function (k) { + if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, { + enumerable: true, + get: function () { return fromWebToken[k]; } + }); +}); + + +/***/ }), + +/***/ 3723: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.STSClient = exports.__Client = void 0; +const middleware_host_header_1 = __webpack_require__(2590); +const middleware_logger_1 = __webpack_require__(5242); +const middleware_recursion_detection_1 = __webpack_require__(1568); +const middleware_user_agent_1 = __webpack_require__(2959); +const config_resolver_1 = __webpack_require__(9316); +const core_1 = __webpack_require__(402); +const schema_1 = __webpack_require__(6890); +const middleware_content_length_1 = __webpack_require__(7212); +const middleware_endpoint_1 = __webpack_require__(99); +const middleware_retry_1 = __webpack_require__(9618); +const smithy_client_1 = __webpack_require__(1411); +Object.defineProperty(exports, "__Client", ({ enumerable: true, get: function () { return smithy_client_1.Client; } })); +const httpAuthSchemeProvider_1 = __webpack_require__(7851); +const EndpointParameters_1 = __webpack_require__(6811); +const runtimeConfig_1 = __webpack_require__(6578); +const runtimeExtensions_1 = __webpack_require__(7742); +class STSClient extends smithy_client_1.Client { + config; + constructor(...[configuration]) { + const _config_0 = (0, runtimeConfig_1.getRuntimeConfig)(configuration || {}); + super(_config_0); + this.initConfig = _config_0; + const _config_1 = (0, EndpointParameters_1.resolveClientEndpointParameters)(_config_0); + const _config_2 = (0, middleware_user_agent_1.resolveUserAgentConfig)(_config_1); + const _config_3 = (0, middleware_retry_1.resolveRetryConfig)(_config_2); + const _config_4 = (0, config_resolver_1.resolveRegionConfig)(_config_3); + const _config_5 = (0, middleware_host_header_1.resolveHostHeaderConfig)(_config_4); + const _config_6 = (0, middleware_endpoint_1.resolveEndpointConfig)(_config_5); + const _config_7 = (0, httpAuthSchemeProvider_1.resolveHttpAuthSchemeConfig)(_config_6); + const _config_8 = (0, runtimeExtensions_1.resolveRuntimeExtensions)(_config_7, configuration?.extensions || []); + this.config = _config_8; + this.middlewareStack.use((0, schema_1.getSchemaSerdePlugin)(this.config)); + this.middlewareStack.use((0, middleware_user_agent_1.getUserAgentPlugin)(this.config)); + this.middlewareStack.use((0, middleware_retry_1.getRetryPlugin)(this.config)); + this.middlewareStack.use((0, middleware_content_length_1.getContentLengthPlugin)(this.config)); + this.middlewareStack.use((0, middleware_host_header_1.getHostHeaderPlugin)(this.config)); + this.middlewareStack.use((0, middleware_logger_1.getLoggerPlugin)(this.config)); + this.middlewareStack.use((0, middleware_recursion_detection_1.getRecursionDetectionPlugin)(this.config)); + this.middlewareStack.use((0, core_1.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, { + httpAuthSchemeParametersProvider: httpAuthSchemeProvider_1.defaultSTSHttpAuthSchemeParametersProvider, + identityProviderConfigProvider: async (config) => new core_1.DefaultIdentityProviderConfig({ + "aws.auth#sigv4": config.credentials, + }), + })); + this.middlewareStack.use((0, core_1.getHttpSigningPlugin)(this.config)); + } + destroy() { + super.destroy(); + } +} +exports.STSClient = STSClient; + + +/***/ }), + +/***/ 4532: +/***/ ((__unused_webpack_module, exports) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.resolveHttpAuthRuntimeConfig = exports.getHttpAuthExtensionConfiguration = void 0; +const getHttpAuthExtensionConfiguration = (runtimeConfig) => { + const _httpAuthSchemes = runtimeConfig.httpAuthSchemes; + let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider; + let _credentials = runtimeConfig.credentials; + return { + setHttpAuthScheme(httpAuthScheme) { + const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId); + if (index === -1) { + _httpAuthSchemes.push(httpAuthScheme); + } + else { + _httpAuthSchemes.splice(index, 1, httpAuthScheme); + } + }, + httpAuthSchemes() { + return _httpAuthSchemes; + }, + setHttpAuthSchemeProvider(httpAuthSchemeProvider) { + _httpAuthSchemeProvider = httpAuthSchemeProvider; + }, + httpAuthSchemeProvider() { + return _httpAuthSchemeProvider; + }, + setCredentials(credentials) { + _credentials = credentials; + }, + credentials() { + return _credentials; + }, + }; +}; +exports.getHttpAuthExtensionConfiguration = getHttpAuthExtensionConfiguration; +const resolveHttpAuthRuntimeConfig = (config) => { + return { + httpAuthSchemes: config.httpAuthSchemes(), + httpAuthSchemeProvider: config.httpAuthSchemeProvider(), + credentials: config.credentials(), + }; +}; +exports.resolveHttpAuthRuntimeConfig = resolveHttpAuthRuntimeConfig; + + +/***/ }), + +/***/ 7851: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.resolveHttpAuthSchemeConfig = exports.resolveStsAuthConfig = exports.defaultSTSHttpAuthSchemeProvider = exports.defaultSTSHttpAuthSchemeParametersProvider = void 0; +const core_1 = __webpack_require__(8704); +const util_middleware_1 = __webpack_require__(6324); +const STSClient_1 = __webpack_require__(3723); +const defaultSTSHttpAuthSchemeParametersProvider = async (config, context, input) => { + return { + operation: (0, util_middleware_1.getSmithyContext)(context).operation, + region: (await (0, util_middleware_1.normalizeProvider)(config.region)()) || + (() => { + throw new Error("expected `region` to be configured for `aws.auth#sigv4`"); + })(), + }; +}; +exports.defaultSTSHttpAuthSchemeParametersProvider = defaultSTSHttpAuthSchemeParametersProvider; +function createAwsAuthSigv4HttpAuthOption(authParameters) { + return { + schemeId: "aws.auth#sigv4", + signingProperties: { + name: "sts", + region: authParameters.region, + }, + propertiesExtractor: (config, context) => ({ + signingProperties: { + config, + context, + }, + }), + }; +} +function createSmithyApiNoAuthHttpAuthOption(authParameters) { + return { + schemeId: "smithy.api#noAuth", + }; +} +const defaultSTSHttpAuthSchemeProvider = (authParameters) => { + const options = []; + switch (authParameters.operation) { + case "AssumeRoleWithWebIdentity": { + options.push(createSmithyApiNoAuthHttpAuthOption(authParameters)); + break; + } + default: { + options.push(createAwsAuthSigv4HttpAuthOption(authParameters)); + } + } + return options; +}; +exports.defaultSTSHttpAuthSchemeProvider = defaultSTSHttpAuthSchemeProvider; +const resolveStsAuthConfig = (input) => Object.assign(input, { + stsClientCtor: STSClient_1.STSClient, +}); +exports.resolveStsAuthConfig = resolveStsAuthConfig; +const resolveHttpAuthSchemeConfig = (config) => { + const config_0 = (0, exports.resolveStsAuthConfig)(config); + const config_1 = (0, core_1.resolveAwsSdkSigV4Config)(config_0); + return Object.assign(config_1, { + authSchemePreference: (0, util_middleware_1.normalizeProvider)(config.authSchemePreference ?? []), + }); +}; +exports.resolveHttpAuthSchemeConfig = resolveHttpAuthSchemeConfig; + + +/***/ }), + +/***/ 6811: +/***/ ((__unused_webpack_module, exports) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.commonParams = exports.resolveClientEndpointParameters = void 0; +const resolveClientEndpointParameters = (options) => { + return Object.assign(options, { + useDualstackEndpoint: options.useDualstackEndpoint ?? false, + useFipsEndpoint: options.useFipsEndpoint ?? false, + useGlobalEndpoint: options.useGlobalEndpoint ?? false, + defaultSigningName: "sts", + }); +}; +exports.resolveClientEndpointParameters = resolveClientEndpointParameters; +exports.commonParams = { + UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" }, + UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" }, + Endpoint: { type: "builtInParams", name: "endpoint" }, + Region: { type: "builtInParams", name: "region" }, + UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }, +}; + + +/***/ }), + +/***/ 9765: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.defaultEndpointResolver = void 0; +const util_endpoints_1 = __webpack_require__(3068); +const util_endpoints_2 = __webpack_require__(9674); +const ruleset_1 = __webpack_require__(1670); +const cache = new util_endpoints_2.EndpointCache({ + size: 50, + params: ["Endpoint", "Region", "UseDualStack", "UseFIPS", "UseGlobalEndpoint"], +}); +const defaultEndpointResolver = (endpointParams, context = {}) => { + return cache.get(endpointParams, () => (0, util_endpoints_2.resolveEndpoint)(ruleset_1.ruleSet, { + endpointParams: endpointParams, + logger: context.logger, + })); +}; +exports.defaultEndpointResolver = defaultEndpointResolver; +util_endpoints_2.customEndpointFunctions.aws = util_endpoints_1.awsEndpointFunctions; + + +/***/ }), + +/***/ 1670: +/***/ ((__unused_webpack_module, exports) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ruleSet = void 0; +const F = "required", G = "type", H = "fn", I = "argv", J = "ref"; +const a = false, b = true, c = "booleanEquals", d = "stringEquals", e = "sigv4", f = "sts", g = "us-east-1", h = "endpoint", i = "https://sts.{Region}.{PartitionResult#dnsSuffix}", j = "tree", k = "error", l = "getAttr", m = { [F]: false, [G]: "string" }, n = { [F]: true, "default": false, [G]: "boolean" }, o = { [J]: "Endpoint" }, p = { [H]: "isSet", [I]: [{ [J]: "Region" }] }, q = { [J]: "Region" }, r = { [H]: "aws.partition", [I]: [q], "assign": "PartitionResult" }, s = { [J]: "UseFIPS" }, t = { [J]: "UseDualStack" }, u = { "url": "https://sts.amazonaws.com", "properties": { "authSchemes": [{ "name": e, "signingName": f, "signingRegion": g }] }, "headers": {} }, v = {}, w = { "conditions": [{ [H]: d, [I]: [q, "aws-global"] }], [h]: u, [G]: h }, x = { [H]: c, [I]: [s, true] }, y = { [H]: c, [I]: [t, true] }, z = { [H]: l, [I]: [{ [J]: "PartitionResult" }, "supportsFIPS"] }, A = { [J]: "PartitionResult" }, B = { [H]: c, [I]: [true, { [H]: l, [I]: [A, "supportsDualStack"] }] }, C = [{ [H]: "isSet", [I]: [o] }], D = [x], E = [y]; +const _data = { version: "1.0", parameters: { Region: m, UseDualStack: n, UseFIPS: n, Endpoint: m, UseGlobalEndpoint: n }, rules: [{ conditions: [{ [H]: c, [I]: [{ [J]: "UseGlobalEndpoint" }, b] }, { [H]: "not", [I]: C }, p, r, { [H]: c, [I]: [s, a] }, { [H]: c, [I]: [t, a] }], rules: [{ conditions: [{ [H]: d, [I]: [q, "ap-northeast-1"] }], endpoint: u, [G]: h }, { conditions: [{ [H]: d, [I]: [q, "ap-south-1"] }], endpoint: u, [G]: h }, { conditions: [{ [H]: d, [I]: [q, "ap-southeast-1"] }], endpoint: u, [G]: h }, { conditions: [{ [H]: d, [I]: [q, "ap-southeast-2"] }], endpoint: u, [G]: h }, w, { conditions: [{ [H]: d, [I]: [q, "ca-central-1"] }], endpoint: u, [G]: h }, { conditions: [{ [H]: d, [I]: [q, "eu-central-1"] }], endpoint: u, [G]: h }, { conditions: [{ [H]: d, [I]: [q, "eu-north-1"] }], endpoint: u, [G]: h }, { conditions: [{ [H]: d, [I]: [q, "eu-west-1"] }], endpoint: u, [G]: h }, { conditions: [{ [H]: d, [I]: [q, "eu-west-2"] }], endpoint: u, [G]: h }, { conditions: [{ [H]: d, [I]: [q, "eu-west-3"] }], endpoint: u, [G]: h }, { conditions: [{ [H]: d, [I]: [q, "sa-east-1"] }], endpoint: u, [G]: h }, { conditions: [{ [H]: d, [I]: [q, g] }], endpoint: u, [G]: h }, { conditions: [{ [H]: d, [I]: [q, "us-east-2"] }], endpoint: u, [G]: h }, { conditions: [{ [H]: d, [I]: [q, "us-west-1"] }], endpoint: u, [G]: h }, { conditions: [{ [H]: d, [I]: [q, "us-west-2"] }], endpoint: u, [G]: h }, { endpoint: { url: i, properties: { authSchemes: [{ name: e, signingName: f, signingRegion: "{Region}" }] }, headers: v }, [G]: h }], [G]: j }, { conditions: C, rules: [{ conditions: D, error: "Invalid Configuration: FIPS and custom endpoint are not supported", [G]: k }, { conditions: E, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", [G]: k }, { endpoint: { url: o, properties: v, headers: v }, [G]: h }], [G]: j }, { conditions: [p], rules: [{ conditions: [r], rules: [{ conditions: [x, y], rules: [{ conditions: [{ [H]: c, [I]: [b, z] }, B], rules: [{ endpoint: { url: "https://sts-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: v, headers: v }, [G]: h }], [G]: j }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", [G]: k }], [G]: j }, { conditions: D, rules: [{ conditions: [{ [H]: c, [I]: [z, b] }], rules: [{ conditions: [{ [H]: d, [I]: [{ [H]: l, [I]: [A, "name"] }, "aws-us-gov"] }], endpoint: { url: "https://sts.{Region}.amazonaws.com", properties: v, headers: v }, [G]: h }, { endpoint: { url: "https://sts-fips.{Region}.{PartitionResult#dnsSuffix}", properties: v, headers: v }, [G]: h }], [G]: j }, { error: "FIPS is enabled but this partition does not support FIPS", [G]: k }], [G]: j }, { conditions: E, rules: [{ conditions: [B], rules: [{ endpoint: { url: "https://sts.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: v, headers: v }, [G]: h }], [G]: j }, { error: "DualStack is enabled but this partition does not support DualStack", [G]: k }], [G]: j }, w, { endpoint: { url: i, properties: v, headers: v }, [G]: h }], [G]: j }], [G]: j }, { error: "Invalid Configuration: Missing Region", [G]: k }] }; +exports.ruleSet = _data; + + +/***/ }), + +/***/ 1136: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + + +var STSClient = __webpack_require__(3723); +var smithyClient = __webpack_require__(1411); +var middlewareEndpoint = __webpack_require__(99); +var EndpointParameters = __webpack_require__(6811); +var schema = __webpack_require__(6890); +var client = __webpack_require__(5152); +var regionConfigResolver = __webpack_require__(6463); + +let STSServiceException$1 = class STSServiceException extends smithyClient.ServiceException { + constructor(options) { + super(options); + Object.setPrototypeOf(this, STSServiceException.prototype); + } +}; + +let ExpiredTokenException$1 = class ExpiredTokenException extends STSServiceException$1 { + name = "ExpiredTokenException"; + $fault = "client"; + constructor(opts) { + super({ + name: "ExpiredTokenException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, ExpiredTokenException.prototype); + } +}; +let MalformedPolicyDocumentException$1 = class MalformedPolicyDocumentException extends STSServiceException$1 { + name = "MalformedPolicyDocumentException"; + $fault = "client"; + constructor(opts) { + super({ + name: "MalformedPolicyDocumentException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, MalformedPolicyDocumentException.prototype); + } +}; +let PackedPolicyTooLargeException$1 = class PackedPolicyTooLargeException extends STSServiceException$1 { + name = "PackedPolicyTooLargeException"; + $fault = "client"; + constructor(opts) { + super({ + name: "PackedPolicyTooLargeException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, PackedPolicyTooLargeException.prototype); + } +}; +let RegionDisabledException$1 = class RegionDisabledException extends STSServiceException$1 { + name = "RegionDisabledException"; + $fault = "client"; + constructor(opts) { + super({ + name: "RegionDisabledException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, RegionDisabledException.prototype); + } +}; +let IDPRejectedClaimException$1 = class IDPRejectedClaimException extends STSServiceException$1 { + name = "IDPRejectedClaimException"; + $fault = "client"; + constructor(opts) { + super({ + name: "IDPRejectedClaimException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, IDPRejectedClaimException.prototype); + } +}; +let InvalidIdentityTokenException$1 = class InvalidIdentityTokenException extends STSServiceException$1 { + name = "InvalidIdentityTokenException"; + $fault = "client"; + constructor(opts) { + super({ + name: "InvalidIdentityTokenException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, InvalidIdentityTokenException.prototype); + } +}; +let IDPCommunicationErrorException$1 = class IDPCommunicationErrorException extends STSServiceException$1 { + name = "IDPCommunicationErrorException"; + $fault = "client"; + constructor(opts) { + super({ + name: "IDPCommunicationErrorException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, IDPCommunicationErrorException.prototype); + } +}; + +const _A = "Arn"; +const _AKI = "AccessKeyId"; +const _AR = "AssumeRole"; +const _ARI = "AssumedRoleId"; +const _ARR = "AssumeRoleRequest"; +const _ARRs = "AssumeRoleResponse"; +const _ARU = "AssumedRoleUser"; +const _ARWWI = "AssumeRoleWithWebIdentity"; +const _ARWWIR = "AssumeRoleWithWebIdentityRequest"; +const _ARWWIRs = "AssumeRoleWithWebIdentityResponse"; +const _Au = "Audience"; +const _C = "Credentials"; +const _CA = "ContextAssertion"; +const _DS = "DurationSeconds"; +const _E = "Expiration"; +const _EI = "ExternalId"; +const _ETE = "ExpiredTokenException"; +const _IDPCEE = "IDPCommunicationErrorException"; +const _IDPRCE = "IDPRejectedClaimException"; +const _IITE = "InvalidIdentityTokenException"; +const _K = "Key"; +const _MPDE = "MalformedPolicyDocumentException"; +const _P = "Policy"; +const _PA = "PolicyArns"; +const _PAr = "ProviderArn"; +const _PC = "ProvidedContexts"; +const _PCLT = "ProvidedContextsListType"; +const _PCr = "ProvidedContext"; +const _PDT = "PolicyDescriptorType"; +const _PI = "ProviderId"; +const _PPS = "PackedPolicySize"; +const _PPTLE = "PackedPolicyTooLargeException"; +const _Pr = "Provider"; +const _RA = "RoleArn"; +const _RDE = "RegionDisabledException"; +const _RSN = "RoleSessionName"; +const _SAK = "SecretAccessKey"; +const _SFWIT = "SubjectFromWebIdentityToken"; +const _SI = "SourceIdentity"; +const _SN = "SerialNumber"; +const _ST = "SessionToken"; +const _T = "Tags"; +const _TC = "TokenCode"; +const _TTK = "TransitiveTagKeys"; +const _Ta = "Tag"; +const _V = "Value"; +const _WIT = "WebIdentityToken"; +const _a = "arn"; +const _aKST = "accessKeySecretType"; +const _aQE = "awsQueryError"; +const _c = "client"; +const _cTT = "clientTokenType"; +const _e = "error"; +const _hE = "httpError"; +const _m = "message"; +const _pDLT = "policyDescriptorListType"; +const _s = "smithy.ts.sdk.synthetic.com.amazonaws.sts"; +const _tLT = "tagListType"; +const n0 = "com.amazonaws.sts"; +var accessKeySecretType = [0, n0, _aKST, 8, 0]; +var clientTokenType = [0, n0, _cTT, 8, 0]; +var AssumedRoleUser = [3, n0, _ARU, 0, [_ARI, _A], [0, 0]]; +var AssumeRoleRequest = [ + 3, + n0, + _ARR, + 0, + [_RA, _RSN, _PA, _P, _DS, _T, _TTK, _EI, _SN, _TC, _SI, _PC], + [0, 0, () => policyDescriptorListType, 0, 1, () => tagListType, 64 | 0, 0, 0, 0, 0, () => ProvidedContextsListType], +]; +var AssumeRoleResponse = [ + 3, + n0, + _ARRs, + 0, + [_C, _ARU, _PPS, _SI], + [[() => Credentials, 0], () => AssumedRoleUser, 1, 0], +]; +var AssumeRoleWithWebIdentityRequest = [ + 3, + n0, + _ARWWIR, + 0, + [_RA, _RSN, _WIT, _PI, _PA, _P, _DS], + [0, 0, [() => clientTokenType, 0], 0, () => policyDescriptorListType, 0, 1], +]; +var AssumeRoleWithWebIdentityResponse = [ + 3, + n0, + _ARWWIRs, + 0, + [_C, _SFWIT, _ARU, _PPS, _Pr, _Au, _SI], + [[() => Credentials, 0], 0, () => AssumedRoleUser, 1, 0, 0, 0], +]; +var Credentials = [ + 3, + n0, + _C, + 0, + [_AKI, _SAK, _ST, _E], + [0, [() => accessKeySecretType, 0], 0, 4], +]; +var ExpiredTokenException = [ + -3, + n0, + _ETE, + { + [_e]: _c, + [_hE]: 400, + [_aQE]: [`ExpiredTokenException`, 400], + }, + [_m], + [0], +]; +schema.TypeRegistry.for(n0).registerError(ExpiredTokenException, ExpiredTokenException$1); +var IDPCommunicationErrorException = [ + -3, + n0, + _IDPCEE, + { + [_e]: _c, + [_hE]: 400, + [_aQE]: [`IDPCommunicationError`, 400], + }, + [_m], + [0], +]; +schema.TypeRegistry.for(n0).registerError(IDPCommunicationErrorException, IDPCommunicationErrorException$1); +var IDPRejectedClaimException = [ + -3, + n0, + _IDPRCE, + { + [_e]: _c, + [_hE]: 403, + [_aQE]: [`IDPRejectedClaim`, 403], + }, + [_m], + [0], +]; +schema.TypeRegistry.for(n0).registerError(IDPRejectedClaimException, IDPRejectedClaimException$1); +var InvalidIdentityTokenException = [ + -3, + n0, + _IITE, + { + [_e]: _c, + [_hE]: 400, + [_aQE]: [`InvalidIdentityToken`, 400], + }, + [_m], + [0], +]; +schema.TypeRegistry.for(n0).registerError(InvalidIdentityTokenException, InvalidIdentityTokenException$1); +var MalformedPolicyDocumentException = [ + -3, + n0, + _MPDE, + { + [_e]: _c, + [_hE]: 400, + [_aQE]: [`MalformedPolicyDocument`, 400], + }, + [_m], + [0], +]; +schema.TypeRegistry.for(n0).registerError(MalformedPolicyDocumentException, MalformedPolicyDocumentException$1); +var PackedPolicyTooLargeException = [ + -3, + n0, + _PPTLE, + { + [_e]: _c, + [_hE]: 400, + [_aQE]: [`PackedPolicyTooLarge`, 400], + }, + [_m], + [0], +]; +schema.TypeRegistry.for(n0).registerError(PackedPolicyTooLargeException, PackedPolicyTooLargeException$1); +var PolicyDescriptorType = [3, n0, _PDT, 0, [_a], [0]]; +var ProvidedContext = [3, n0, _PCr, 0, [_PAr, _CA], [0, 0]]; +var RegionDisabledException = [ + -3, + n0, + _RDE, + { + [_e]: _c, + [_hE]: 403, + [_aQE]: [`RegionDisabledException`, 403], + }, + [_m], + [0], +]; +schema.TypeRegistry.for(n0).registerError(RegionDisabledException, RegionDisabledException$1); +var Tag = [3, n0, _Ta, 0, [_K, _V], [0, 0]]; +var STSServiceException = [-3, _s, "STSServiceException", 0, [], []]; +schema.TypeRegistry.for(_s).registerError(STSServiceException, STSServiceException$1); +var policyDescriptorListType = [1, n0, _pDLT, 0, () => PolicyDescriptorType]; +var ProvidedContextsListType = [1, n0, _PCLT, 0, () => ProvidedContext]; +var tagListType = [1, n0, _tLT, 0, () => Tag]; +var AssumeRole = [9, n0, _AR, 0, () => AssumeRoleRequest, () => AssumeRoleResponse]; +var AssumeRoleWithWebIdentity = [ + 9, + n0, + _ARWWI, + 0, + () => AssumeRoleWithWebIdentityRequest, + () => AssumeRoleWithWebIdentityResponse, +]; + +class AssumeRoleCommand extends smithyClient.Command + .classBuilder() + .ep(EndpointParameters.commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("AWSSecurityTokenServiceV20110615", "AssumeRole", {}) + .n("STSClient", "AssumeRoleCommand") + .sc(AssumeRole) + .build() { +} + +class AssumeRoleWithWebIdentityCommand extends smithyClient.Command + .classBuilder() + .ep(EndpointParameters.commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("AWSSecurityTokenServiceV20110615", "AssumeRoleWithWebIdentity", {}) + .n("STSClient", "AssumeRoleWithWebIdentityCommand") + .sc(AssumeRoleWithWebIdentity) + .build() { +} + +const commands = { + AssumeRoleCommand, + AssumeRoleWithWebIdentityCommand, +}; +class STS extends STSClient.STSClient { +} +smithyClient.createAggregatedClient(commands, STS); + +const getAccountIdFromAssumedRoleUser = (assumedRoleUser) => { + if (typeof assumedRoleUser?.Arn === "string") { + const arnComponents = assumedRoleUser.Arn.split(":"); + if (arnComponents.length > 4 && arnComponents[4] !== "") { + return arnComponents[4]; + } + } + return undefined; +}; +const resolveRegion = async (_region, _parentRegion, credentialProviderLogger, loaderConfig = {}) => { + const region = typeof _region === "function" ? await _region() : _region; + const parentRegion = typeof _parentRegion === "function" ? await _parentRegion() : _parentRegion; + const stsDefaultRegion = await regionConfigResolver.stsRegionDefaultResolver(loaderConfig)(); + credentialProviderLogger?.debug?.("@aws-sdk/client-sts::resolveRegion", "accepting first of:", `${region} (credential provider clientConfig)`, `${parentRegion} (contextual client)`, `${stsDefaultRegion} (STS default: AWS_REGION, profile region, or us-east-1)`); + return region ?? parentRegion ?? stsDefaultRegion; +}; +const getDefaultRoleAssumer$1 = (stsOptions, STSClient) => { + let stsClient; + let closureSourceCreds; + return async (sourceCreds, params) => { + closureSourceCreds = sourceCreds; + if (!stsClient) { + const { logger = stsOptions?.parentClientConfig?.logger, profile = stsOptions?.parentClientConfig?.profile, region, requestHandler = stsOptions?.parentClientConfig?.requestHandler, credentialProviderLogger, userAgentAppId = stsOptions?.parentClientConfig?.userAgentAppId, } = stsOptions; + const resolvedRegion = await resolveRegion(region, stsOptions?.parentClientConfig?.region, credentialProviderLogger, { + logger, + profile, + }); + const isCompatibleRequestHandler = !isH2(requestHandler); + stsClient = new STSClient({ + ...stsOptions, + userAgentAppId, + profile, + credentialDefaultProvider: () => async () => closureSourceCreds, + region: resolvedRegion, + requestHandler: isCompatibleRequestHandler ? requestHandler : undefined, + logger: logger, + }); + } + const { Credentials, AssumedRoleUser } = await stsClient.send(new AssumeRoleCommand(params)); + if (!Credentials || !Credentials.AccessKeyId || !Credentials.SecretAccessKey) { + throw new Error(`Invalid response from STS.assumeRole call with role ${params.RoleArn}`); + } + const accountId = getAccountIdFromAssumedRoleUser(AssumedRoleUser); + const credentials = { + accessKeyId: Credentials.AccessKeyId, + secretAccessKey: Credentials.SecretAccessKey, + sessionToken: Credentials.SessionToken, + expiration: Credentials.Expiration, + ...(Credentials.CredentialScope && { credentialScope: Credentials.CredentialScope }), + ...(accountId && { accountId }), + }; + client.setCredentialFeature(credentials, "CREDENTIALS_STS_ASSUME_ROLE", "i"); + return credentials; + }; +}; +const getDefaultRoleAssumerWithWebIdentity$1 = (stsOptions, STSClient) => { + let stsClient; + return async (params) => { + if (!stsClient) { + const { logger = stsOptions?.parentClientConfig?.logger, profile = stsOptions?.parentClientConfig?.profile, region, requestHandler = stsOptions?.parentClientConfig?.requestHandler, credentialProviderLogger, userAgentAppId = stsOptions?.parentClientConfig?.userAgentAppId, } = stsOptions; + const resolvedRegion = await resolveRegion(region, stsOptions?.parentClientConfig?.region, credentialProviderLogger, { + logger, + profile, + }); + const isCompatibleRequestHandler = !isH2(requestHandler); + stsClient = new STSClient({ + ...stsOptions, + userAgentAppId, + profile, + region: resolvedRegion, + requestHandler: isCompatibleRequestHandler ? requestHandler : undefined, + logger: logger, + }); + } + const { Credentials, AssumedRoleUser } = await stsClient.send(new AssumeRoleWithWebIdentityCommand(params)); + if (!Credentials || !Credentials.AccessKeyId || !Credentials.SecretAccessKey) { + throw new Error(`Invalid response from STS.assumeRoleWithWebIdentity call with role ${params.RoleArn}`); + } + const accountId = getAccountIdFromAssumedRoleUser(AssumedRoleUser); + const credentials = { + accessKeyId: Credentials.AccessKeyId, + secretAccessKey: Credentials.SecretAccessKey, + sessionToken: Credentials.SessionToken, + expiration: Credentials.Expiration, + ...(Credentials.CredentialScope && { credentialScope: Credentials.CredentialScope }), + ...(accountId && { accountId }), + }; + if (accountId) { + client.setCredentialFeature(credentials, "RESOLVED_ACCOUNT_ID", "T"); + } + client.setCredentialFeature(credentials, "CREDENTIALS_STS_ASSUME_ROLE_WEB_ID", "k"); + return credentials; + }; +}; +const isH2 = (requestHandler) => { + return requestHandler?.metadata?.handlerProtocol === "h2"; +}; + +const getCustomizableStsClientCtor = (baseCtor, customizations) => { + if (!customizations) + return baseCtor; + else + return class CustomizableSTSClient extends baseCtor { + constructor(config) { + super(config); + for (const customization of customizations) { + this.middlewareStack.use(customization); + } + } + }; +}; +const getDefaultRoleAssumer = (stsOptions = {}, stsPlugins) => getDefaultRoleAssumer$1(stsOptions, getCustomizableStsClientCtor(STSClient.STSClient, stsPlugins)); +const getDefaultRoleAssumerWithWebIdentity = (stsOptions = {}, stsPlugins) => getDefaultRoleAssumerWithWebIdentity$1(stsOptions, getCustomizableStsClientCtor(STSClient.STSClient, stsPlugins)); +const decorateDefaultCredentialProvider = (provider) => (input) => provider({ + roleAssumer: getDefaultRoleAssumer(input), + roleAssumerWithWebIdentity: getDefaultRoleAssumerWithWebIdentity(input), + ...input, +}); + +Object.defineProperty(exports, "$Command", ({ + enumerable: true, + get: function () { return smithyClient.Command; } +})); +exports.AssumeRoleCommand = AssumeRoleCommand; +exports.AssumeRoleWithWebIdentityCommand = AssumeRoleWithWebIdentityCommand; +exports.ExpiredTokenException = ExpiredTokenException$1; +exports.IDPCommunicationErrorException = IDPCommunicationErrorException$1; +exports.IDPRejectedClaimException = IDPRejectedClaimException$1; +exports.InvalidIdentityTokenException = InvalidIdentityTokenException$1; +exports.MalformedPolicyDocumentException = MalformedPolicyDocumentException$1; +exports.PackedPolicyTooLargeException = PackedPolicyTooLargeException$1; +exports.RegionDisabledException = RegionDisabledException$1; +exports.STS = STS; +exports.STSServiceException = STSServiceException$1; +exports.decorateDefaultCredentialProvider = decorateDefaultCredentialProvider; +exports.getDefaultRoleAssumer = getDefaultRoleAssumer; +exports.getDefaultRoleAssumerWithWebIdentity = getDefaultRoleAssumerWithWebIdentity; +Object.keys(STSClient).forEach(function (k) { + if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, { + enumerable: true, + get: function () { return STSClient[k]; } + }); +}); + + +/***/ }), + +/***/ 6578: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getRuntimeConfig = void 0; +const tslib_1 = __webpack_require__(1860); +const package_json_1 = tslib_1.__importDefault(__webpack_require__(9955)); +const core_1 = __webpack_require__(8704); +const util_user_agent_node_1 = __webpack_require__(1656); +const config_resolver_1 = __webpack_require__(9316); +const core_2 = __webpack_require__(402); +const hash_node_1 = __webpack_require__(2711); +const middleware_retry_1 = __webpack_require__(9618); +const node_config_provider_1 = __webpack_require__(5704); +const node_http_handler_1 = __webpack_require__(1279); +const util_body_length_node_1 = __webpack_require__(3638); +const util_retry_1 = __webpack_require__(5518); +const runtimeConfig_shared_1 = __webpack_require__(4443); +const smithy_client_1 = __webpack_require__(1411); +const util_defaults_mode_node_1 = __webpack_require__(5435); +const smithy_client_2 = __webpack_require__(1411); +const getRuntimeConfig = (config) => { + (0, smithy_client_2.emitWarningIfUnsupportedVersion)(process.version); + const defaultsMode = (0, util_defaults_mode_node_1.resolveDefaultsModeConfig)(config); + const defaultConfigProvider = () => defaultsMode().then(smithy_client_1.loadConfigsForDefaultMode); + const clientSharedValues = (0, runtimeConfig_shared_1.getRuntimeConfig)(config); + (0, core_1.emitWarningIfUnsupportedVersion)(process.version); + const loaderConfig = { + profile: config?.profile, + logger: clientSharedValues.logger, + }; + return { + ...clientSharedValues, + ...config, + runtime: "node", + defaultsMode, + authSchemePreference: config?.authSchemePreference ?? (0, node_config_provider_1.loadConfig)(core_1.NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig), + bodyLengthChecker: config?.bodyLengthChecker ?? util_body_length_node_1.calculateBodyLength, + defaultUserAgentProvider: config?.defaultUserAgentProvider ?? + (0, util_user_agent_node_1.createDefaultUserAgentProvider)({ serviceId: clientSharedValues.serviceId, clientVersion: package_json_1.default.version }), + httpAuthSchemes: config?.httpAuthSchemes ?? [ + { + schemeId: "aws.auth#sigv4", + identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4") || + (async (idProps) => await config.credentialDefaultProvider(idProps?.__config || {})()), + signer: new core_1.AwsSdkSigV4Signer(), + }, + { + schemeId: "smithy.api#noAuth", + identityProvider: (ipc) => ipc.getIdentityProvider("smithy.api#noAuth") || (async () => ({})), + signer: new core_2.NoAuthSigner(), + }, + ], + maxAttempts: config?.maxAttempts ?? (0, node_config_provider_1.loadConfig)(middleware_retry_1.NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config), + region: config?.region ?? + (0, node_config_provider_1.loadConfig)(config_resolver_1.NODE_REGION_CONFIG_OPTIONS, { ...config_resolver_1.NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }), + requestHandler: node_http_handler_1.NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider), + retryMode: config?.retryMode ?? + (0, node_config_provider_1.loadConfig)({ + ...middleware_retry_1.NODE_RETRY_MODE_CONFIG_OPTIONS, + default: async () => (await defaultConfigProvider()).retryMode || util_retry_1.DEFAULT_RETRY_MODE, + }, config), + sha256: config?.sha256 ?? hash_node_1.Hash.bind(null, "sha256"), + streamCollector: config?.streamCollector ?? node_http_handler_1.streamCollector, + useDualstackEndpoint: config?.useDualstackEndpoint ?? (0, node_config_provider_1.loadConfig)(config_resolver_1.NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig), + useFipsEndpoint: config?.useFipsEndpoint ?? (0, node_config_provider_1.loadConfig)(config_resolver_1.NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig), + userAgentAppId: config?.userAgentAppId ?? (0, node_config_provider_1.loadConfig)(util_user_agent_node_1.NODE_APP_ID_CONFIG_OPTIONS, loaderConfig), + }; +}; +exports.getRuntimeConfig = getRuntimeConfig; + + +/***/ }), + +/***/ 4443: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getRuntimeConfig = void 0; +const core_1 = __webpack_require__(8704); +const protocols_1 = __webpack_require__(7288); +const core_2 = __webpack_require__(402); +const smithy_client_1 = __webpack_require__(1411); +const url_parser_1 = __webpack_require__(4494); +const util_base64_1 = __webpack_require__(8385); +const util_utf8_1 = __webpack_require__(1577); +const httpAuthSchemeProvider_1 = __webpack_require__(7851); +const endpointResolver_1 = __webpack_require__(9765); +const getRuntimeConfig = (config) => { + return { + apiVersion: "2011-06-15", + base64Decoder: config?.base64Decoder ?? util_base64_1.fromBase64, + base64Encoder: config?.base64Encoder ?? util_base64_1.toBase64, + disableHostPrefix: config?.disableHostPrefix ?? false, + endpointProvider: config?.endpointProvider ?? endpointResolver_1.defaultEndpointResolver, + extensions: config?.extensions ?? [], + httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? httpAuthSchemeProvider_1.defaultSTSHttpAuthSchemeProvider, + httpAuthSchemes: config?.httpAuthSchemes ?? [ + { + schemeId: "aws.auth#sigv4", + identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"), + signer: new core_1.AwsSdkSigV4Signer(), + }, + { + schemeId: "smithy.api#noAuth", + identityProvider: (ipc) => ipc.getIdentityProvider("smithy.api#noAuth") || (async () => ({})), + signer: new core_2.NoAuthSigner(), + }, + ], + logger: config?.logger ?? new smithy_client_1.NoOpLogger(), + protocol: config?.protocol ?? + new protocols_1.AwsQueryProtocol({ + defaultNamespace: "com.amazonaws.sts", + xmlNamespace: "https://sts.amazonaws.com/doc/2011-06-15/", + version: "2011-06-15", + }), + serviceId: config?.serviceId ?? "STS", + urlParser: config?.urlParser ?? url_parser_1.parseUrl, + utf8Decoder: config?.utf8Decoder ?? util_utf8_1.fromUtf8, + utf8Encoder: config?.utf8Encoder ?? util_utf8_1.toUtf8, + }; +}; +exports.getRuntimeConfig = getRuntimeConfig; + + +/***/ }), + +/***/ 7742: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.resolveRuntimeExtensions = void 0; +const region_config_resolver_1 = __webpack_require__(6463); +const protocol_http_1 = __webpack_require__(2356); +const smithy_client_1 = __webpack_require__(1411); +const httpAuthExtensionConfiguration_1 = __webpack_require__(4532); +const resolveRuntimeExtensions = (runtimeConfig, extensions) => { + const extensionConfiguration = Object.assign((0, region_config_resolver_1.getAwsRegionExtensionConfiguration)(runtimeConfig), (0, smithy_client_1.getDefaultExtensionConfiguration)(runtimeConfig), (0, protocol_http_1.getHttpHandlerExtensionConfiguration)(runtimeConfig), (0, httpAuthExtensionConfiguration_1.getHttpAuthExtensionConfiguration)(runtimeConfig)); + extensions.forEach((extension) => extension.configure(extensionConfiguration)); + return Object.assign(runtimeConfig, (0, region_config_resolver_1.resolveAwsRegionExtensionConfiguration)(extensionConfiguration), (0, smithy_client_1.resolveDefaultRuntimeConfig)(extensionConfiguration), (0, protocol_http_1.resolveHttpHandlerRuntimeConfig)(extensionConfiguration), (0, httpAuthExtensionConfiguration_1.resolveHttpAuthRuntimeConfig)(extensionConfiguration)); +}; +exports.resolveRuntimeExtensions = resolveRuntimeExtensions; + + +/***/ }), + +/***/ 9955: +/***/ ((module) => { + +module.exports = /*#__PURE__*/JSON.parse('{"name":"@aws-sdk/nested-clients","version":"3.935.0","description":"Nested clients for AWS SDK packages.","main":"./dist-cjs/index.js","module":"./dist-es/index.js","types":"./dist-types/index.d.ts","scripts":{"build":"yarn lint && concurrently \'yarn:build:cjs\' \'yarn:build:es\' \'yarn:build:types\'","build:cjs":"node ../../scripts/compilation/inline nested-clients","build:es":"tsc -p tsconfig.es.json","build:include:deps":"lerna run --scope $npm_package_name --include-dependencies build","build:types":"tsc -p tsconfig.types.json","build:types:downlevel":"downlevel-dts dist-types dist-types/ts3.4","clean":"rimraf ./dist-* && rimraf *.tsbuildinfo","lint":"node ../../scripts/validation/submodules-linter.js --pkg nested-clients","test":"yarn g:vitest run","test:watch":"yarn g:vitest watch"},"engines":{"node":">=18.0.0"},"sideEffects":false,"author":{"name":"AWS SDK for JavaScript Team","url":"https://aws.amazon.com/javascript/"},"license":"Apache-2.0","dependencies":{"@aws-crypto/sha256-browser":"5.2.0","@aws-crypto/sha256-js":"5.2.0","@aws-sdk/core":"3.935.0","@aws-sdk/middleware-host-header":"3.930.0","@aws-sdk/middleware-logger":"3.930.0","@aws-sdk/middleware-recursion-detection":"3.933.0","@aws-sdk/middleware-user-agent":"3.935.0","@aws-sdk/region-config-resolver":"3.930.0","@aws-sdk/types":"3.930.0","@aws-sdk/util-endpoints":"3.930.0","@aws-sdk/util-user-agent-browser":"3.930.0","@aws-sdk/util-user-agent-node":"3.935.0","@smithy/config-resolver":"^4.4.3","@smithy/core":"^3.18.5","@smithy/fetch-http-handler":"^5.3.6","@smithy/hash-node":"^4.2.5","@smithy/invalid-dependency":"^4.2.5","@smithy/middleware-content-length":"^4.2.5","@smithy/middleware-endpoint":"^4.3.12","@smithy/middleware-retry":"^4.4.12","@smithy/middleware-serde":"^4.2.6","@smithy/middleware-stack":"^4.2.5","@smithy/node-config-provider":"^4.3.5","@smithy/node-http-handler":"^4.4.5","@smithy/protocol-http":"^5.3.5","@smithy/smithy-client":"^4.9.8","@smithy/types":"^4.9.0","@smithy/url-parser":"^4.2.5","@smithy/util-base64":"^4.3.0","@smithy/util-body-length-browser":"^4.2.0","@smithy/util-body-length-node":"^4.2.1","@smithy/util-defaults-mode-browser":"^4.3.11","@smithy/util-defaults-mode-node":"^4.2.14","@smithy/util-endpoints":"^3.2.5","@smithy/util-middleware":"^4.2.5","@smithy/util-retry":"^4.2.5","@smithy/util-utf8":"^4.2.0","tslib":"^2.6.2"},"devDependencies":{"concurrently":"7.0.0","downlevel-dts":"0.10.1","rimraf":"3.0.2","typescript":"~5.8.3"},"typesVersions":{"<4.0":{"dist-types/*":["dist-types/ts3.4/*"]}},"files":["./sso-oidc.d.ts","./sso-oidc.js","./sts.d.ts","./sts.js","dist-*/**"],"browser":{"./dist-es/submodules/sso-oidc/runtimeConfig":"./dist-es/submodules/sso-oidc/runtimeConfig.browser","./dist-es/submodules/sts/runtimeConfig":"./dist-es/submodules/sts/runtimeConfig.browser"},"react-native":{},"homepage":"https://github.com/aws/aws-sdk-js-v3/tree/main/packages/nested-clients","repository":{"type":"git","url":"https://github.com/aws/aws-sdk-js-v3.git","directory":"packages/nested-clients"},"exports":{"./sso-oidc":{"types":"./dist-types/submodules/sso-oidc/index.d.ts","module":"./dist-es/submodules/sso-oidc/index.js","node":"./dist-cjs/submodules/sso-oidc/index.js","import":"./dist-es/submodules/sso-oidc/index.js","require":"./dist-cjs/submodules/sso-oidc/index.js"},"./sts":{"types":"./dist-types/submodules/sts/index.d.ts","module":"./dist-es/submodules/sts/index.js","node":"./dist-cjs/submodules/sts/index.js","import":"./dist-es/submodules/sts/index.js","require":"./dist-cjs/submodules/sts/index.js"}}}'); + +/***/ }) + +}; +; \ No newline at end of file diff --git a/dist/998.index.js b/dist/998.index.js new file mode 100644 index 0000000..2e16556 --- /dev/null +++ b/dist/998.index.js @@ -0,0 +1,1455 @@ +"use strict"; +exports.id = 998; +exports.ids = [998]; +exports.modules = { + +/***/ 2041: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.resolveHttpAuthSchemeConfig = exports.defaultSSOHttpAuthSchemeProvider = exports.defaultSSOHttpAuthSchemeParametersProvider = void 0; +const core_1 = __webpack_require__(8704); +const util_middleware_1 = __webpack_require__(6324); +const defaultSSOHttpAuthSchemeParametersProvider = async (config, context, input) => { + return { + operation: (0, util_middleware_1.getSmithyContext)(context).operation, + region: (await (0, util_middleware_1.normalizeProvider)(config.region)()) || + (() => { + throw new Error("expected `region` to be configured for `aws.auth#sigv4`"); + })(), + }; +}; +exports.defaultSSOHttpAuthSchemeParametersProvider = defaultSSOHttpAuthSchemeParametersProvider; +function createAwsAuthSigv4HttpAuthOption(authParameters) { + return { + schemeId: "aws.auth#sigv4", + signingProperties: { + name: "awsssoportal", + region: authParameters.region, + }, + propertiesExtractor: (config, context) => ({ + signingProperties: { + config, + context, + }, + }), + }; +} +function createSmithyApiNoAuthHttpAuthOption(authParameters) { + return { + schemeId: "smithy.api#noAuth", + }; +} +const defaultSSOHttpAuthSchemeProvider = (authParameters) => { + const options = []; + switch (authParameters.operation) { + case "GetRoleCredentials": { + options.push(createSmithyApiNoAuthHttpAuthOption(authParameters)); + break; + } + case "ListAccountRoles": { + options.push(createSmithyApiNoAuthHttpAuthOption(authParameters)); + break; + } + case "ListAccounts": { + options.push(createSmithyApiNoAuthHttpAuthOption(authParameters)); + break; + } + case "Logout": { + options.push(createSmithyApiNoAuthHttpAuthOption(authParameters)); + break; + } + default: { + options.push(createAwsAuthSigv4HttpAuthOption(authParameters)); + } + } + return options; +}; +exports.defaultSSOHttpAuthSchemeProvider = defaultSSOHttpAuthSchemeProvider; +const resolveHttpAuthSchemeConfig = (config) => { + const config_0 = (0, core_1.resolveAwsSdkSigV4Config)(config); + return Object.assign(config_0, { + authSchemePreference: (0, util_middleware_1.normalizeProvider)(config.authSchemePreference ?? []), + }); +}; +exports.resolveHttpAuthSchemeConfig = resolveHttpAuthSchemeConfig; + + +/***/ }), + +/***/ 3903: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.defaultEndpointResolver = void 0; +const util_endpoints_1 = __webpack_require__(3068); +const util_endpoints_2 = __webpack_require__(9674); +const ruleset_1 = __webpack_require__(1308); +const cache = new util_endpoints_2.EndpointCache({ + size: 50, + params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"], +}); +const defaultEndpointResolver = (endpointParams, context = {}) => { + return cache.get(endpointParams, () => (0, util_endpoints_2.resolveEndpoint)(ruleset_1.ruleSet, { + endpointParams: endpointParams, + logger: context.logger, + })); +}; +exports.defaultEndpointResolver = defaultEndpointResolver; +util_endpoints_2.customEndpointFunctions.aws = util_endpoints_1.awsEndpointFunctions; + + +/***/ }), + +/***/ 1308: +/***/ ((__unused_webpack_module, exports) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ruleSet = void 0; +const u = "required", v = "fn", w = "argv", x = "ref"; +const a = true, b = "isSet", c = "booleanEquals", d = "error", e = "endpoint", f = "tree", g = "PartitionResult", h = "getAttr", i = { [u]: false, "type": "string" }, j = { [u]: true, "default": false, "type": "boolean" }, k = { [x]: "Endpoint" }, l = { [v]: c, [w]: [{ [x]: "UseFIPS" }, true] }, m = { [v]: c, [w]: [{ [x]: "UseDualStack" }, true] }, n = {}, o = { [v]: h, [w]: [{ [x]: g }, "supportsFIPS"] }, p = { [x]: g }, q = { [v]: c, [w]: [true, { [v]: h, [w]: [p, "supportsDualStack"] }] }, r = [l], s = [m], t = [{ [x]: "Region" }]; +const _data = { version: "1.0", parameters: { Region: i, UseDualStack: j, UseFIPS: j, Endpoint: i }, rules: [{ conditions: [{ [v]: b, [w]: [k] }], rules: [{ conditions: r, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: d }, { conditions: s, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: d }, { endpoint: { url: k, properties: n, headers: n }, type: e }], type: f }, { conditions: [{ [v]: b, [w]: t }], rules: [{ conditions: [{ [v]: "aws.partition", [w]: t, assign: g }], rules: [{ conditions: [l, m], rules: [{ conditions: [{ [v]: c, [w]: [a, o] }, q], rules: [{ endpoint: { url: "https://portal.sso-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: n, headers: n }, type: e }], type: f }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: d }], type: f }, { conditions: r, rules: [{ conditions: [{ [v]: c, [w]: [o, a] }], rules: [{ conditions: [{ [v]: "stringEquals", [w]: [{ [v]: h, [w]: [p, "name"] }, "aws-us-gov"] }], endpoint: { url: "https://portal.sso.{Region}.amazonaws.com", properties: n, headers: n }, type: e }, { endpoint: { url: "https://portal.sso-fips.{Region}.{PartitionResult#dnsSuffix}", properties: n, headers: n }, type: e }], type: f }, { error: "FIPS is enabled but this partition does not support FIPS", type: d }], type: f }, { conditions: s, rules: [{ conditions: [q], rules: [{ endpoint: { url: "https://portal.sso.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: n, headers: n }, type: e }], type: f }, { error: "DualStack is enabled but this partition does not support DualStack", type: d }], type: f }, { endpoint: { url: "https://portal.sso.{Region}.{PartitionResult#dnsSuffix}", properties: n, headers: n }, type: e }], type: f }], type: f }, { error: "Invalid Configuration: Missing Region", type: d }] }; +exports.ruleSet = _data; + + +/***/ }), + +/***/ 2054: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + + +var middlewareHostHeader = __webpack_require__(2590); +var middlewareLogger = __webpack_require__(5242); +var middlewareRecursionDetection = __webpack_require__(1568); +var middlewareUserAgent = __webpack_require__(2959); +var configResolver = __webpack_require__(9316); +var core = __webpack_require__(402); +var schema = __webpack_require__(6890); +var middlewareContentLength = __webpack_require__(7212); +var middlewareEndpoint = __webpack_require__(99); +var middlewareRetry = __webpack_require__(9618); +var smithyClient = __webpack_require__(1411); +var httpAuthSchemeProvider = __webpack_require__(2041); +var runtimeConfig = __webpack_require__(2696); +var regionConfigResolver = __webpack_require__(6463); +var protocolHttp = __webpack_require__(2356); + +const resolveClientEndpointParameters = (options) => { + return Object.assign(options, { + useDualstackEndpoint: options.useDualstackEndpoint ?? false, + useFipsEndpoint: options.useFipsEndpoint ?? false, + defaultSigningName: "awsssoportal", + }); +}; +const commonParams = { + UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" }, + Endpoint: { type: "builtInParams", name: "endpoint" }, + Region: { type: "builtInParams", name: "region" }, + UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }, +}; + +const getHttpAuthExtensionConfiguration = (runtimeConfig) => { + const _httpAuthSchemes = runtimeConfig.httpAuthSchemes; + let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider; + let _credentials = runtimeConfig.credentials; + return { + setHttpAuthScheme(httpAuthScheme) { + const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId); + if (index === -1) { + _httpAuthSchemes.push(httpAuthScheme); + } + else { + _httpAuthSchemes.splice(index, 1, httpAuthScheme); + } + }, + httpAuthSchemes() { + return _httpAuthSchemes; + }, + setHttpAuthSchemeProvider(httpAuthSchemeProvider) { + _httpAuthSchemeProvider = httpAuthSchemeProvider; + }, + httpAuthSchemeProvider() { + return _httpAuthSchemeProvider; + }, + setCredentials(credentials) { + _credentials = credentials; + }, + credentials() { + return _credentials; + }, + }; +}; +const resolveHttpAuthRuntimeConfig = (config) => { + return { + httpAuthSchemes: config.httpAuthSchemes(), + httpAuthSchemeProvider: config.httpAuthSchemeProvider(), + credentials: config.credentials(), + }; +}; + +const resolveRuntimeExtensions = (runtimeConfig, extensions) => { + const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig)); + extensions.forEach((extension) => extension.configure(extensionConfiguration)); + return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration)); +}; + +class SSOClient extends smithyClient.Client { + config; + constructor(...[configuration]) { + const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {}); + super(_config_0); + this.initConfig = _config_0; + const _config_1 = resolveClientEndpointParameters(_config_0); + const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1); + const _config_3 = middlewareRetry.resolveRetryConfig(_config_2); + const _config_4 = configResolver.resolveRegionConfig(_config_3); + const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4); + const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5); + const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6); + const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []); + this.config = _config_8; + this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config)); + this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config)); + this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config)); + this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config)); + this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config)); + this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config)); + this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config)); + this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, { + httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultSSOHttpAuthSchemeParametersProvider, + identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({ + "aws.auth#sigv4": config.credentials, + }), + })); + this.middlewareStack.use(core.getHttpSigningPlugin(this.config)); + } + destroy() { + super.destroy(); + } +} + +let SSOServiceException$1 = class SSOServiceException extends smithyClient.ServiceException { + constructor(options) { + super(options); + Object.setPrototypeOf(this, SSOServiceException.prototype); + } +}; + +let InvalidRequestException$1 = class InvalidRequestException extends SSOServiceException$1 { + name = "InvalidRequestException"; + $fault = "client"; + constructor(opts) { + super({ + name: "InvalidRequestException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, InvalidRequestException.prototype); + } +}; +let ResourceNotFoundException$1 = class ResourceNotFoundException extends SSOServiceException$1 { + name = "ResourceNotFoundException"; + $fault = "client"; + constructor(opts) { + super({ + name: "ResourceNotFoundException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, ResourceNotFoundException.prototype); + } +}; +let TooManyRequestsException$1 = class TooManyRequestsException extends SSOServiceException$1 { + name = "TooManyRequestsException"; + $fault = "client"; + constructor(opts) { + super({ + name: "TooManyRequestsException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, TooManyRequestsException.prototype); + } +}; +let UnauthorizedException$1 = class UnauthorizedException extends SSOServiceException$1 { + name = "UnauthorizedException"; + $fault = "client"; + constructor(opts) { + super({ + name: "UnauthorizedException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, UnauthorizedException.prototype); + } +}; + +const _AI = "AccountInfo"; +const _ALT = "AccountListType"; +const _ATT = "AccessTokenType"; +const _GRC = "GetRoleCredentials"; +const _GRCR = "GetRoleCredentialsRequest"; +const _GRCRe = "GetRoleCredentialsResponse"; +const _IRE = "InvalidRequestException"; +const _L = "Logout"; +const _LA = "ListAccounts"; +const _LAR = "ListAccountsRequest"; +const _LARR = "ListAccountRolesRequest"; +const _LARRi = "ListAccountRolesResponse"; +const _LARi = "ListAccountsResponse"; +const _LARis = "ListAccountRoles"; +const _LR = "LogoutRequest"; +const _RC = "RoleCredentials"; +const _RI = "RoleInfo"; +const _RLT = "RoleListType"; +const _RNFE = "ResourceNotFoundException"; +const _SAKT = "SecretAccessKeyType"; +const _STT = "SessionTokenType"; +const _TMRE = "TooManyRequestsException"; +const _UE = "UnauthorizedException"; +const _aI = "accountId"; +const _aKI = "accessKeyId"; +const _aL = "accountList"; +const _aN = "accountName"; +const _aT = "accessToken"; +const _ai = "account_id"; +const _c = "client"; +const _e = "error"; +const _eA = "emailAddress"; +const _ex = "expiration"; +const _h = "http"; +const _hE = "httpError"; +const _hH = "httpHeader"; +const _hQ = "httpQuery"; +const _m = "message"; +const _mR = "maxResults"; +const _mr = "max_result"; +const _nT = "nextToken"; +const _nt = "next_token"; +const _rC = "roleCredentials"; +const _rL = "roleList"; +const _rN = "roleName"; +const _rn = "role_name"; +const _s = "smithy.ts.sdk.synthetic.com.amazonaws.sso"; +const _sAK = "secretAccessKey"; +const _sT = "sessionToken"; +const _xasbt = "x-amz-sso_bearer_token"; +const n0 = "com.amazonaws.sso"; +var AccessTokenType = [0, n0, _ATT, 8, 0]; +var SecretAccessKeyType = [0, n0, _SAKT, 8, 0]; +var SessionTokenType = [0, n0, _STT, 8, 0]; +var AccountInfo = [3, n0, _AI, 0, [_aI, _aN, _eA], [0, 0, 0]]; +var GetRoleCredentialsRequest = [ + 3, + n0, + _GRCR, + 0, + [_rN, _aI, _aT], + [ + [ + 0, + { + [_hQ]: _rn, + }, + ], + [ + 0, + { + [_hQ]: _ai, + }, + ], + [ + () => AccessTokenType, + { + [_hH]: _xasbt, + }, + ], + ], +]; +var GetRoleCredentialsResponse = [3, n0, _GRCRe, 0, [_rC], [[() => RoleCredentials, 0]]]; +var InvalidRequestException = [ + -3, + n0, + _IRE, + { + [_e]: _c, + [_hE]: 400, + }, + [_m], + [0], +]; +schema.TypeRegistry.for(n0).registerError(InvalidRequestException, InvalidRequestException$1); +var ListAccountRolesRequest = [ + 3, + n0, + _LARR, + 0, + [_nT, _mR, _aT, _aI], + [ + [ + 0, + { + [_hQ]: _nt, + }, + ], + [ + 1, + { + [_hQ]: _mr, + }, + ], + [ + () => AccessTokenType, + { + [_hH]: _xasbt, + }, + ], + [ + 0, + { + [_hQ]: _ai, + }, + ], + ], +]; +var ListAccountRolesResponse = [3, n0, _LARRi, 0, [_nT, _rL], [0, () => RoleListType]]; +var ListAccountsRequest = [ + 3, + n0, + _LAR, + 0, + [_nT, _mR, _aT], + [ + [ + 0, + { + [_hQ]: _nt, + }, + ], + [ + 1, + { + [_hQ]: _mr, + }, + ], + [ + () => AccessTokenType, + { + [_hH]: _xasbt, + }, + ], + ], +]; +var ListAccountsResponse = [3, n0, _LARi, 0, [_nT, _aL], [0, () => AccountListType]]; +var LogoutRequest = [ + 3, + n0, + _LR, + 0, + [_aT], + [ + [ + () => AccessTokenType, + { + [_hH]: _xasbt, + }, + ], + ], +]; +var ResourceNotFoundException = [ + -3, + n0, + _RNFE, + { + [_e]: _c, + [_hE]: 404, + }, + [_m], + [0], +]; +schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1); +var RoleCredentials = [ + 3, + n0, + _RC, + 0, + [_aKI, _sAK, _sT, _ex], + [0, [() => SecretAccessKeyType, 0], [() => SessionTokenType, 0], 1], +]; +var RoleInfo = [3, n0, _RI, 0, [_rN, _aI], [0, 0]]; +var TooManyRequestsException = [ + -3, + n0, + _TMRE, + { + [_e]: _c, + [_hE]: 429, + }, + [_m], + [0], +]; +schema.TypeRegistry.for(n0).registerError(TooManyRequestsException, TooManyRequestsException$1); +var UnauthorizedException = [ + -3, + n0, + _UE, + { + [_e]: _c, + [_hE]: 401, + }, + [_m], + [0], +]; +schema.TypeRegistry.for(n0).registerError(UnauthorizedException, UnauthorizedException$1); +var __Unit = "unit"; +var SSOServiceException = [-3, _s, "SSOServiceException", 0, [], []]; +schema.TypeRegistry.for(_s).registerError(SSOServiceException, SSOServiceException$1); +var AccountListType = [1, n0, _ALT, 0, () => AccountInfo]; +var RoleListType = [1, n0, _RLT, 0, () => RoleInfo]; +var GetRoleCredentials = [ + 9, + n0, + _GRC, + { + [_h]: ["GET", "/federation/credentials", 200], + }, + () => GetRoleCredentialsRequest, + () => GetRoleCredentialsResponse, +]; +var ListAccountRoles = [ + 9, + n0, + _LARis, + { + [_h]: ["GET", "/assignment/roles", 200], + }, + () => ListAccountRolesRequest, + () => ListAccountRolesResponse, +]; +var ListAccounts = [ + 9, + n0, + _LA, + { + [_h]: ["GET", "/assignment/accounts", 200], + }, + () => ListAccountsRequest, + () => ListAccountsResponse, +]; +var Logout = [ + 9, + n0, + _L, + { + [_h]: ["POST", "/logout", 200], + }, + () => LogoutRequest, + () => __Unit, +]; + +class GetRoleCredentialsCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("SWBPortalService", "GetRoleCredentials", {}) + .n("SSOClient", "GetRoleCredentialsCommand") + .sc(GetRoleCredentials) + .build() { +} + +class ListAccountRolesCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("SWBPortalService", "ListAccountRoles", {}) + .n("SSOClient", "ListAccountRolesCommand") + .sc(ListAccountRoles) + .build() { +} + +class ListAccountsCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("SWBPortalService", "ListAccounts", {}) + .n("SSOClient", "ListAccountsCommand") + .sc(ListAccounts) + .build() { +} + +class LogoutCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("SWBPortalService", "Logout", {}) + .n("SSOClient", "LogoutCommand") + .sc(Logout) + .build() { +} + +const commands = { + GetRoleCredentialsCommand, + ListAccountRolesCommand, + ListAccountsCommand, + LogoutCommand, +}; +class SSO extends SSOClient { +} +smithyClient.createAggregatedClient(commands, SSO); + +const paginateListAccountRoles = core.createPaginator(SSOClient, ListAccountRolesCommand, "nextToken", "nextToken", "maxResults"); + +const paginateListAccounts = core.createPaginator(SSOClient, ListAccountsCommand, "nextToken", "nextToken", "maxResults"); + +Object.defineProperty(exports, "$Command", ({ + enumerable: true, + get: function () { return smithyClient.Command; } +})); +Object.defineProperty(exports, "__Client", ({ + enumerable: true, + get: function () { return smithyClient.Client; } +})); +exports.GetRoleCredentialsCommand = GetRoleCredentialsCommand; +exports.InvalidRequestException = InvalidRequestException$1; +exports.ListAccountRolesCommand = ListAccountRolesCommand; +exports.ListAccountsCommand = ListAccountsCommand; +exports.LogoutCommand = LogoutCommand; +exports.ResourceNotFoundException = ResourceNotFoundException$1; +exports.SSO = SSO; +exports.SSOClient = SSOClient; +exports.SSOServiceException = SSOServiceException$1; +exports.TooManyRequestsException = TooManyRequestsException$1; +exports.UnauthorizedException = UnauthorizedException$1; +exports.paginateListAccountRoles = paginateListAccountRoles; +exports.paginateListAccounts = paginateListAccounts; + + +/***/ }), + +/***/ 2696: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getRuntimeConfig = void 0; +const tslib_1 = __webpack_require__(1860); +const package_json_1 = tslib_1.__importDefault(__webpack_require__(2807)); +const core_1 = __webpack_require__(8704); +const util_user_agent_node_1 = __webpack_require__(1656); +const config_resolver_1 = __webpack_require__(9316); +const hash_node_1 = __webpack_require__(2711); +const middleware_retry_1 = __webpack_require__(9618); +const node_config_provider_1 = __webpack_require__(5704); +const node_http_handler_1 = __webpack_require__(1279); +const util_body_length_node_1 = __webpack_require__(3638); +const util_retry_1 = __webpack_require__(5518); +const runtimeConfig_shared_1 = __webpack_require__(8073); +const smithy_client_1 = __webpack_require__(1411); +const util_defaults_mode_node_1 = __webpack_require__(5435); +const smithy_client_2 = __webpack_require__(1411); +const getRuntimeConfig = (config) => { + (0, smithy_client_2.emitWarningIfUnsupportedVersion)(process.version); + const defaultsMode = (0, util_defaults_mode_node_1.resolveDefaultsModeConfig)(config); + const defaultConfigProvider = () => defaultsMode().then(smithy_client_1.loadConfigsForDefaultMode); + const clientSharedValues = (0, runtimeConfig_shared_1.getRuntimeConfig)(config); + (0, core_1.emitWarningIfUnsupportedVersion)(process.version); + const loaderConfig = { + profile: config?.profile, + logger: clientSharedValues.logger, + }; + return { + ...clientSharedValues, + ...config, + runtime: "node", + defaultsMode, + authSchemePreference: config?.authSchemePreference ?? (0, node_config_provider_1.loadConfig)(core_1.NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig), + bodyLengthChecker: config?.bodyLengthChecker ?? util_body_length_node_1.calculateBodyLength, + defaultUserAgentProvider: config?.defaultUserAgentProvider ?? + (0, util_user_agent_node_1.createDefaultUserAgentProvider)({ serviceId: clientSharedValues.serviceId, clientVersion: package_json_1.default.version }), + maxAttempts: config?.maxAttempts ?? (0, node_config_provider_1.loadConfig)(middleware_retry_1.NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config), + region: config?.region ?? + (0, node_config_provider_1.loadConfig)(config_resolver_1.NODE_REGION_CONFIG_OPTIONS, { ...config_resolver_1.NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }), + requestHandler: node_http_handler_1.NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider), + retryMode: config?.retryMode ?? + (0, node_config_provider_1.loadConfig)({ + ...middleware_retry_1.NODE_RETRY_MODE_CONFIG_OPTIONS, + default: async () => (await defaultConfigProvider()).retryMode || util_retry_1.DEFAULT_RETRY_MODE, + }, config), + sha256: config?.sha256 ?? hash_node_1.Hash.bind(null, "sha256"), + streamCollector: config?.streamCollector ?? node_http_handler_1.streamCollector, + useDualstackEndpoint: config?.useDualstackEndpoint ?? (0, node_config_provider_1.loadConfig)(config_resolver_1.NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig), + useFipsEndpoint: config?.useFipsEndpoint ?? (0, node_config_provider_1.loadConfig)(config_resolver_1.NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig), + userAgentAppId: config?.userAgentAppId ?? (0, node_config_provider_1.loadConfig)(util_user_agent_node_1.NODE_APP_ID_CONFIG_OPTIONS, loaderConfig), + }; +}; +exports.getRuntimeConfig = getRuntimeConfig; + + +/***/ }), + +/***/ 8073: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getRuntimeConfig = void 0; +const core_1 = __webpack_require__(8704); +const protocols_1 = __webpack_require__(7288); +const core_2 = __webpack_require__(402); +const smithy_client_1 = __webpack_require__(1411); +const url_parser_1 = __webpack_require__(4494); +const util_base64_1 = __webpack_require__(8385); +const util_utf8_1 = __webpack_require__(1577); +const httpAuthSchemeProvider_1 = __webpack_require__(2041); +const endpointResolver_1 = __webpack_require__(3903); +const getRuntimeConfig = (config) => { + return { + apiVersion: "2019-06-10", + base64Decoder: config?.base64Decoder ?? util_base64_1.fromBase64, + base64Encoder: config?.base64Encoder ?? util_base64_1.toBase64, + disableHostPrefix: config?.disableHostPrefix ?? false, + endpointProvider: config?.endpointProvider ?? endpointResolver_1.defaultEndpointResolver, + extensions: config?.extensions ?? [], + httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? httpAuthSchemeProvider_1.defaultSSOHttpAuthSchemeProvider, + httpAuthSchemes: config?.httpAuthSchemes ?? [ + { + schemeId: "aws.auth#sigv4", + identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"), + signer: new core_1.AwsSdkSigV4Signer(), + }, + { + schemeId: "smithy.api#noAuth", + identityProvider: (ipc) => ipc.getIdentityProvider("smithy.api#noAuth") || (async () => ({})), + signer: new core_2.NoAuthSigner(), + }, + ], + logger: config?.logger ?? new smithy_client_1.NoOpLogger(), + protocol: config?.protocol ?? new protocols_1.AwsRestJsonProtocol({ defaultNamespace: "com.amazonaws.sso" }), + serviceId: config?.serviceId ?? "SSO", + urlParser: config?.urlParser ?? url_parser_1.parseUrl, + utf8Decoder: config?.utf8Decoder ?? util_utf8_1.fromUtf8, + utf8Encoder: config?.utf8Encoder ?? util_utf8_1.toUtf8, + }; +}; +exports.getRuntimeConfig = getRuntimeConfig; + + +/***/ }), + +/***/ 7523: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + + +var protocolHttp = __webpack_require__(2356); +var core = __webpack_require__(402); +var propertyProvider = __webpack_require__(8857); +var client = __webpack_require__(5152); +var signatureV4 = __webpack_require__(5118); + +const getDateHeader = (response) => protocolHttp.HttpResponse.isInstance(response) ? response.headers?.date ?? response.headers?.Date : undefined; + +const getSkewCorrectedDate = (systemClockOffset) => new Date(Date.now() + systemClockOffset); + +const isClockSkewed = (clockTime, systemClockOffset) => Math.abs(getSkewCorrectedDate(systemClockOffset).getTime() - clockTime) >= 300000; + +const getUpdatedSystemClockOffset = (clockTime, currentSystemClockOffset) => { + const clockTimeInMs = Date.parse(clockTime); + if (isClockSkewed(clockTimeInMs, currentSystemClockOffset)) { + return clockTimeInMs - Date.now(); + } + return currentSystemClockOffset; +}; + +const throwSigningPropertyError = (name, property) => { + if (!property) { + throw new Error(`Property \`${name}\` is not resolved for AWS SDK SigV4Auth`); + } + return property; +}; +const validateSigningProperties = async (signingProperties) => { + const context = throwSigningPropertyError("context", signingProperties.context); + const config = throwSigningPropertyError("config", signingProperties.config); + const authScheme = context.endpointV2?.properties?.authSchemes?.[0]; + const signerFunction = throwSigningPropertyError("signer", config.signer); + const signer = await signerFunction(authScheme); + const signingRegion = signingProperties?.signingRegion; + const signingRegionSet = signingProperties?.signingRegionSet; + const signingName = signingProperties?.signingName; + return { + config, + signer, + signingRegion, + signingRegionSet, + signingName, + }; +}; +class AwsSdkSigV4Signer { + async sign(httpRequest, identity, signingProperties) { + if (!protocolHttp.HttpRequest.isInstance(httpRequest)) { + throw new Error("The request is not an instance of `HttpRequest` and cannot be signed"); + } + const validatedProps = await validateSigningProperties(signingProperties); + const { config, signer } = validatedProps; + let { signingRegion, signingName } = validatedProps; + const handlerExecutionContext = signingProperties.context; + if (handlerExecutionContext?.authSchemes?.length ?? 0 > 1) { + const [first, second] = handlerExecutionContext.authSchemes; + if (first?.name === "sigv4a" && second?.name === "sigv4") { + signingRegion = second?.signingRegion ?? signingRegion; + signingName = second?.signingName ?? signingName; + } + } + const signedRequest = await signer.sign(httpRequest, { + signingDate: getSkewCorrectedDate(config.systemClockOffset), + signingRegion: signingRegion, + signingService: signingName, + }); + return signedRequest; + } + errorHandler(signingProperties) { + return (error) => { + const serverTime = error.ServerTime ?? getDateHeader(error.$response); + if (serverTime) { + const config = throwSigningPropertyError("config", signingProperties.config); + const initialSystemClockOffset = config.systemClockOffset; + config.systemClockOffset = getUpdatedSystemClockOffset(serverTime, config.systemClockOffset); + const clockSkewCorrected = config.systemClockOffset !== initialSystemClockOffset; + if (clockSkewCorrected && error.$metadata) { + error.$metadata.clockSkewCorrected = true; + } + } + throw error; + }; + } + successHandler(httpResponse, signingProperties) { + const dateHeader = getDateHeader(httpResponse); + if (dateHeader) { + const config = throwSigningPropertyError("config", signingProperties.config); + config.systemClockOffset = getUpdatedSystemClockOffset(dateHeader, config.systemClockOffset); + } + } +} +const AWSSDKSigV4Signer = AwsSdkSigV4Signer; + +class AwsSdkSigV4ASigner extends AwsSdkSigV4Signer { + async sign(httpRequest, identity, signingProperties) { + if (!protocolHttp.HttpRequest.isInstance(httpRequest)) { + throw new Error("The request is not an instance of `HttpRequest` and cannot be signed"); + } + const { config, signer, signingRegion, signingRegionSet, signingName } = await validateSigningProperties(signingProperties); + const configResolvedSigningRegionSet = await config.sigv4aSigningRegionSet?.(); + const multiRegionOverride = (configResolvedSigningRegionSet ?? + signingRegionSet ?? [signingRegion]).join(","); + const signedRequest = await signer.sign(httpRequest, { + signingDate: getSkewCorrectedDate(config.systemClockOffset), + signingRegion: multiRegionOverride, + signingService: signingName, + }); + return signedRequest; + } +} + +const getArrayForCommaSeparatedString = (str) => typeof str === "string" && str.length > 0 ? str.split(",").map((item) => item.trim()) : []; + +const getBearerTokenEnvKey = (signingName) => `AWS_BEARER_TOKEN_${signingName.replace(/[\s-]/g, "_").toUpperCase()}`; + +const NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY = "AWS_AUTH_SCHEME_PREFERENCE"; +const NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY = "auth_scheme_preference"; +const NODE_AUTH_SCHEME_PREFERENCE_OPTIONS = { + environmentVariableSelector: (env, options) => { + if (options?.signingName) { + const bearerTokenKey = getBearerTokenEnvKey(options.signingName); + if (bearerTokenKey in env) + return ["httpBearerAuth"]; + } + if (!(NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY in env)) + return undefined; + return getArrayForCommaSeparatedString(env[NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY]); + }, + configFileSelector: (profile) => { + if (!(NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY in profile)) + return undefined; + return getArrayForCommaSeparatedString(profile[NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY]); + }, + default: [], +}; + +const resolveAwsSdkSigV4AConfig = (config) => { + config.sigv4aSigningRegionSet = core.normalizeProvider(config.sigv4aSigningRegionSet); + return config; +}; +const NODE_SIGV4A_CONFIG_OPTIONS = { + environmentVariableSelector(env) { + if (env.AWS_SIGV4A_SIGNING_REGION_SET) { + return env.AWS_SIGV4A_SIGNING_REGION_SET.split(",").map((_) => _.trim()); + } + throw new propertyProvider.ProviderError("AWS_SIGV4A_SIGNING_REGION_SET not set in env.", { + tryNextLink: true, + }); + }, + configFileSelector(profile) { + if (profile.sigv4a_signing_region_set) { + return (profile.sigv4a_signing_region_set ?? "").split(",").map((_) => _.trim()); + } + throw new propertyProvider.ProviderError("sigv4a_signing_region_set not set in profile.", { + tryNextLink: true, + }); + }, + default: undefined, +}; + +const resolveAwsSdkSigV4Config = (config) => { + let inputCredentials = config.credentials; + let isUserSupplied = !!config.credentials; + let resolvedCredentials = undefined; + Object.defineProperty(config, "credentials", { + set(credentials) { + if (credentials && credentials !== inputCredentials && credentials !== resolvedCredentials) { + isUserSupplied = true; + } + inputCredentials = credentials; + const memoizedProvider = normalizeCredentialProvider(config, { + credentials: inputCredentials, + credentialDefaultProvider: config.credentialDefaultProvider, + }); + const boundProvider = bindCallerConfig(config, memoizedProvider); + if (isUserSupplied && !boundProvider.attributed) { + resolvedCredentials = async (options) => boundProvider(options).then((creds) => client.setCredentialFeature(creds, "CREDENTIALS_CODE", "e")); + resolvedCredentials.memoized = boundProvider.memoized; + resolvedCredentials.configBound = boundProvider.configBound; + resolvedCredentials.attributed = true; + } + else { + resolvedCredentials = boundProvider; + } + }, + get() { + return resolvedCredentials; + }, + enumerable: true, + configurable: true, + }); + config.credentials = inputCredentials; + const { signingEscapePath = true, systemClockOffset = config.systemClockOffset || 0, sha256, } = config; + let signer; + if (config.signer) { + signer = core.normalizeProvider(config.signer); + } + else if (config.regionInfoProvider) { + signer = () => core.normalizeProvider(config.region)() + .then(async (region) => [ + (await config.regionInfoProvider(region, { + useFipsEndpoint: await config.useFipsEndpoint(), + useDualstackEndpoint: await config.useDualstackEndpoint(), + })) || {}, + region, + ]) + .then(([regionInfo, region]) => { + const { signingRegion, signingService } = regionInfo; + config.signingRegion = config.signingRegion || signingRegion || region; + config.signingName = config.signingName || signingService || config.serviceId; + const params = { + ...config, + credentials: config.credentials, + region: config.signingRegion, + service: config.signingName, + sha256, + uriEscapePath: signingEscapePath, + }; + const SignerCtor = config.signerConstructor || signatureV4.SignatureV4; + return new SignerCtor(params); + }); + } + else { + signer = async (authScheme) => { + authScheme = Object.assign({}, { + name: "sigv4", + signingName: config.signingName || config.defaultSigningName, + signingRegion: await core.normalizeProvider(config.region)(), + properties: {}, + }, authScheme); + const signingRegion = authScheme.signingRegion; + const signingService = authScheme.signingName; + config.signingRegion = config.signingRegion || signingRegion; + config.signingName = config.signingName || signingService || config.serviceId; + const params = { + ...config, + credentials: config.credentials, + region: config.signingRegion, + service: config.signingName, + sha256, + uriEscapePath: signingEscapePath, + }; + const SignerCtor = config.signerConstructor || signatureV4.SignatureV4; + return new SignerCtor(params); + }; + } + const resolvedConfig = Object.assign(config, { + systemClockOffset, + signingEscapePath, + signer, + }); + return resolvedConfig; +}; +const resolveAWSSDKSigV4Config = resolveAwsSdkSigV4Config; +function normalizeCredentialProvider(config, { credentials, credentialDefaultProvider, }) { + let credentialsProvider; + if (credentials) { + if (!credentials?.memoized) { + credentialsProvider = core.memoizeIdentityProvider(credentials, core.isIdentityExpired, core.doesIdentityRequireRefresh); + } + else { + credentialsProvider = credentials; + } + } + else { + if (credentialDefaultProvider) { + credentialsProvider = core.normalizeProvider(credentialDefaultProvider(Object.assign({}, config, { + parentClientConfig: config, + }))); + } + else { + credentialsProvider = async () => { + throw new Error("@aws-sdk/core::resolveAwsSdkSigV4Config - `credentials` not provided and no credentialDefaultProvider was configured."); + }; + } + } + credentialsProvider.memoized = true; + return credentialsProvider; +} +function bindCallerConfig(config, credentialsProvider) { + if (credentialsProvider.configBound) { + return credentialsProvider; + } + const fn = async (options) => credentialsProvider({ ...options, callerClientConfig: config }); + fn.memoized = credentialsProvider.memoized; + fn.configBound = true; + return fn; +} + +exports.AWSSDKSigV4Signer = AWSSDKSigV4Signer; +exports.AwsSdkSigV4ASigner = AwsSdkSigV4ASigner; +exports.AwsSdkSigV4Signer = AwsSdkSigV4Signer; +exports.NODE_AUTH_SCHEME_PREFERENCE_OPTIONS = NODE_AUTH_SCHEME_PREFERENCE_OPTIONS; +exports.NODE_SIGV4A_CONFIG_OPTIONS = NODE_SIGV4A_CONFIG_OPTIONS; +exports.getBearerTokenEnvKey = getBearerTokenEnvKey; +exports.resolveAWSSDKSigV4Config = resolveAWSSDKSigV4Config; +exports.resolveAwsSdkSigV4AConfig = resolveAwsSdkSigV4AConfig; +exports.resolveAwsSdkSigV4Config = resolveAwsSdkSigV4Config; +exports.validateSigningProperties = validateSigningProperties; + + +/***/ }), + +/***/ 998: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +var __webpack_unused_export__; + + +var propertyProvider = __webpack_require__(8857); +var sharedIniFileLoader = __webpack_require__(4964); +var client = __webpack_require__(5152); +var tokenProviders = __webpack_require__(5433); + +const isSsoProfile = (arg) => arg && + (typeof arg.sso_start_url === "string" || + typeof arg.sso_account_id === "string" || + typeof arg.sso_session === "string" || + typeof arg.sso_region === "string" || + typeof arg.sso_role_name === "string"); + +const SHOULD_FAIL_CREDENTIAL_CHAIN = false; +const resolveSSOCredentials = async ({ ssoStartUrl, ssoSession, ssoAccountId, ssoRegion, ssoRoleName, ssoClient, clientConfig, parentClientConfig, profile, filepath, configFilepath, ignoreCache, logger, }) => { + let token; + const refreshMessage = `To refresh this SSO session run aws sso login with the corresponding profile.`; + if (ssoSession) { + try { + const _token = await tokenProviders.fromSso({ + profile, + filepath, + configFilepath, + ignoreCache, + })(); + token = { + accessToken: _token.token, + expiresAt: new Date(_token.expiration).toISOString(), + }; + } + catch (e) { + throw new propertyProvider.CredentialsProviderError(e.message, { + tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN, + logger, + }); + } + } + else { + try { + token = await sharedIniFileLoader.getSSOTokenFromFile(ssoStartUrl); + } + catch (e) { + throw new propertyProvider.CredentialsProviderError(`The SSO session associated with this profile is invalid. ${refreshMessage}`, { + tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN, + logger, + }); + } + } + if (new Date(token.expiresAt).getTime() - Date.now() <= 0) { + throw new propertyProvider.CredentialsProviderError(`The SSO session associated with this profile has expired. ${refreshMessage}`, { + tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN, + logger, + }); + } + const { accessToken } = token; + const { SSOClient, GetRoleCredentialsCommand } = await Promise.resolve().then(function () { return __webpack_require__(6553); }); + const sso = ssoClient || + new SSOClient(Object.assign({}, clientConfig ?? {}, { + logger: clientConfig?.logger ?? parentClientConfig?.logger, + region: clientConfig?.region ?? ssoRegion, + userAgentAppId: clientConfig?.userAgentAppId ?? parentClientConfig?.userAgentAppId, + })); + let ssoResp; + try { + ssoResp = await sso.send(new GetRoleCredentialsCommand({ + accountId: ssoAccountId, + roleName: ssoRoleName, + accessToken, + })); + } + catch (e) { + throw new propertyProvider.CredentialsProviderError(e, { + tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN, + logger, + }); + } + const { roleCredentials: { accessKeyId, secretAccessKey, sessionToken, expiration, credentialScope, accountId } = {}, } = ssoResp; + if (!accessKeyId || !secretAccessKey || !sessionToken || !expiration) { + throw new propertyProvider.CredentialsProviderError("SSO returns an invalid temporary credential.", { + tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN, + logger, + }); + } + const credentials = { + accessKeyId, + secretAccessKey, + sessionToken, + expiration: new Date(expiration), + ...(credentialScope && { credentialScope }), + ...(accountId && { accountId }), + }; + if (ssoSession) { + client.setCredentialFeature(credentials, "CREDENTIALS_SSO", "s"); + } + else { + client.setCredentialFeature(credentials, "CREDENTIALS_SSO_LEGACY", "u"); + } + return credentials; +}; + +const validateSsoProfile = (profile, logger) => { + const { sso_start_url, sso_account_id, sso_region, sso_role_name } = profile; + if (!sso_start_url || !sso_account_id || !sso_region || !sso_role_name) { + throw new propertyProvider.CredentialsProviderError(`Profile is configured with invalid SSO credentials. Required parameters "sso_account_id", ` + + `"sso_region", "sso_role_name", "sso_start_url". Got ${Object.keys(profile).join(", ")}\nReference: https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sso.html`, { tryNextLink: false, logger }); + } + return profile; +}; + +const fromSSO = (init = {}) => async ({ callerClientConfig } = {}) => { + init.logger?.debug("@aws-sdk/credential-provider-sso - fromSSO"); + const { ssoStartUrl, ssoAccountId, ssoRegion, ssoRoleName, ssoSession } = init; + const { ssoClient } = init; + const profileName = sharedIniFileLoader.getProfileName({ + profile: init.profile ?? callerClientConfig?.profile, + }); + if (!ssoStartUrl && !ssoAccountId && !ssoRegion && !ssoRoleName && !ssoSession) { + const profiles = await sharedIniFileLoader.parseKnownFiles(init); + const profile = profiles[profileName]; + if (!profile) { + throw new propertyProvider.CredentialsProviderError(`Profile ${profileName} was not found.`, { logger: init.logger }); + } + if (!isSsoProfile(profile)) { + throw new propertyProvider.CredentialsProviderError(`Profile ${profileName} is not configured with SSO credentials.`, { + logger: init.logger, + }); + } + if (profile?.sso_session) { + const ssoSessions = await sharedIniFileLoader.loadSsoSessionData(init); + const session = ssoSessions[profile.sso_session]; + const conflictMsg = ` configurations in profile ${profileName} and sso-session ${profile.sso_session}`; + if (ssoRegion && ssoRegion !== session.sso_region) { + throw new propertyProvider.CredentialsProviderError(`Conflicting SSO region` + conflictMsg, { + tryNextLink: false, + logger: init.logger, + }); + } + if (ssoStartUrl && ssoStartUrl !== session.sso_start_url) { + throw new propertyProvider.CredentialsProviderError(`Conflicting SSO start_url` + conflictMsg, { + tryNextLink: false, + logger: init.logger, + }); + } + profile.sso_region = session.sso_region; + profile.sso_start_url = session.sso_start_url; + } + const { sso_start_url, sso_account_id, sso_region, sso_role_name, sso_session } = validateSsoProfile(profile, init.logger); + return resolveSSOCredentials({ + ssoStartUrl: sso_start_url, + ssoSession: sso_session, + ssoAccountId: sso_account_id, + ssoRegion: sso_region, + ssoRoleName: sso_role_name, + ssoClient: ssoClient, + clientConfig: init.clientConfig, + parentClientConfig: init.parentClientConfig, + profile: profileName, + filepath: init.filepath, + configFilepath: init.configFilepath, + ignoreCache: init.ignoreCache, + logger: init.logger, + }); + } + else if (!ssoStartUrl || !ssoAccountId || !ssoRegion || !ssoRoleName) { + throw new propertyProvider.CredentialsProviderError("Incomplete configuration. The fromSSO() argument hash must include " + + '"ssoStartUrl", "ssoAccountId", "ssoRegion", "ssoRoleName"', { tryNextLink: false, logger: init.logger }); + } + else { + return resolveSSOCredentials({ + ssoStartUrl, + ssoSession, + ssoAccountId, + ssoRegion, + ssoRoleName, + ssoClient, + clientConfig: init.clientConfig, + parentClientConfig: init.parentClientConfig, + profile: profileName, + filepath: init.filepath, + configFilepath: init.configFilepath, + ignoreCache: init.ignoreCache, + logger: init.logger, + }); + } +}; + +exports.fromSSO = fromSSO; +__webpack_unused_export__ = isSsoProfile; +__webpack_unused_export__ = validateSsoProfile; + + +/***/ }), + +/***/ 6553: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + + +var clientSso = __webpack_require__(2054); + + + +Object.defineProperty(exports, "GetRoleCredentialsCommand", ({ + enumerable: true, + get: function () { return clientSso.GetRoleCredentialsCommand; } +})); +Object.defineProperty(exports, "SSOClient", ({ + enumerable: true, + get: function () { return clientSso.SSOClient; } +})); + + +/***/ }), + +/***/ 5433: +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + + + +var client = __webpack_require__(5152); +var httpAuthSchemes = __webpack_require__(7523); +var propertyProvider = __webpack_require__(8857); +var sharedIniFileLoader = __webpack_require__(4964); +var fs = __webpack_require__(9896); + +const fromEnvSigningName = ({ logger, signingName } = {}) => async () => { + logger?.debug?.("@aws-sdk/token-providers - fromEnvSigningName"); + if (!signingName) { + throw new propertyProvider.TokenProviderError("Please pass 'signingName' to compute environment variable key", { logger }); + } + const bearerTokenKey = httpAuthSchemes.getBearerTokenEnvKey(signingName); + if (!(bearerTokenKey in process.env)) { + throw new propertyProvider.TokenProviderError(`Token not present in '${bearerTokenKey}' environment variable`, { logger }); + } + const token = { token: process.env[bearerTokenKey] }; + client.setTokenFeature(token, "BEARER_SERVICE_ENV_VARS", "3"); + return token; +}; + +const EXPIRE_WINDOW_MS = 5 * 60 * 1000; +const REFRESH_MESSAGE = `To refresh this SSO session run 'aws sso login' with the corresponding profile.`; + +const getSsoOidcClient = async (ssoRegion, init = {}) => { + const { SSOOIDCClient } = await __webpack_require__.e(/* import() */ 443).then(__webpack_require__.t.bind(__webpack_require__, 9443, 19)); + const coalesce = (prop) => init.clientConfig?.[prop] ?? init.parentClientConfig?.[prop]; + const ssoOidcClient = new SSOOIDCClient(Object.assign({}, init.clientConfig ?? {}, { + region: ssoRegion ?? init.clientConfig?.region, + logger: coalesce("logger"), + userAgentAppId: coalesce("userAgentAppId"), + })); + return ssoOidcClient; +}; + +const getNewSsoOidcToken = async (ssoToken, ssoRegion, init = {}) => { + const { CreateTokenCommand } = await __webpack_require__.e(/* import() */ 443).then(__webpack_require__.t.bind(__webpack_require__, 9443, 19)); + const ssoOidcClient = await getSsoOidcClient(ssoRegion, init); + return ssoOidcClient.send(new CreateTokenCommand({ + clientId: ssoToken.clientId, + clientSecret: ssoToken.clientSecret, + refreshToken: ssoToken.refreshToken, + grantType: "refresh_token", + })); +}; + +const validateTokenExpiry = (token) => { + if (token.expiration && token.expiration.getTime() < Date.now()) { + throw new propertyProvider.TokenProviderError(`Token is expired. ${REFRESH_MESSAGE}`, false); + } +}; + +const validateTokenKey = (key, value, forRefresh = false) => { + if (typeof value === "undefined") { + throw new propertyProvider.TokenProviderError(`Value not present for '${key}' in SSO Token${forRefresh ? ". Cannot refresh" : ""}. ${REFRESH_MESSAGE}`, false); + } +}; + +const { writeFile } = fs.promises; +const writeSSOTokenToFile = (id, ssoToken) => { + const tokenFilepath = sharedIniFileLoader.getSSOTokenFilepath(id); + const tokenString = JSON.stringify(ssoToken, null, 2); + return writeFile(tokenFilepath, tokenString); +}; + +const lastRefreshAttemptTime = new Date(0); +const fromSso = (_init = {}) => async ({ callerClientConfig } = {}) => { + const init = { + ..._init, + parentClientConfig: { + ...callerClientConfig, + ..._init.parentClientConfig, + }, + }; + init.logger?.debug("@aws-sdk/token-providers - fromSso"); + const profiles = await sharedIniFileLoader.parseKnownFiles(init); + const profileName = sharedIniFileLoader.getProfileName({ + profile: init.profile ?? callerClientConfig?.profile, + }); + const profile = profiles[profileName]; + if (!profile) { + throw new propertyProvider.TokenProviderError(`Profile '${profileName}' could not be found in shared credentials file.`, false); + } + else if (!profile["sso_session"]) { + throw new propertyProvider.TokenProviderError(`Profile '${profileName}' is missing required property 'sso_session'.`); + } + const ssoSessionName = profile["sso_session"]; + const ssoSessions = await sharedIniFileLoader.loadSsoSessionData(init); + const ssoSession = ssoSessions[ssoSessionName]; + if (!ssoSession) { + throw new propertyProvider.TokenProviderError(`Sso session '${ssoSessionName}' could not be found in shared credentials file.`, false); + } + for (const ssoSessionRequiredKey of ["sso_start_url", "sso_region"]) { + if (!ssoSession[ssoSessionRequiredKey]) { + throw new propertyProvider.TokenProviderError(`Sso session '${ssoSessionName}' is missing required property '${ssoSessionRequiredKey}'.`, false); + } + } + ssoSession["sso_start_url"]; + const ssoRegion = ssoSession["sso_region"]; + let ssoToken; + try { + ssoToken = await sharedIniFileLoader.getSSOTokenFromFile(ssoSessionName); + } + catch (e) { + throw new propertyProvider.TokenProviderError(`The SSO session token associated with profile=${profileName} was not found or is invalid. ${REFRESH_MESSAGE}`, false); + } + validateTokenKey("accessToken", ssoToken.accessToken); + validateTokenKey("expiresAt", ssoToken.expiresAt); + const { accessToken, expiresAt } = ssoToken; + const existingToken = { token: accessToken, expiration: new Date(expiresAt) }; + if (existingToken.expiration.getTime() - Date.now() > EXPIRE_WINDOW_MS) { + return existingToken; + } + if (Date.now() - lastRefreshAttemptTime.getTime() < 30 * 1000) { + validateTokenExpiry(existingToken); + return existingToken; + } + validateTokenKey("clientId", ssoToken.clientId, true); + validateTokenKey("clientSecret", ssoToken.clientSecret, true); + validateTokenKey("refreshToken", ssoToken.refreshToken, true); + try { + lastRefreshAttemptTime.setTime(Date.now()); + const newSsoOidcToken = await getNewSsoOidcToken(ssoToken, ssoRegion, init); + validateTokenKey("accessToken", newSsoOidcToken.accessToken); + validateTokenKey("expiresIn", newSsoOidcToken.expiresIn); + const newTokenExpiration = new Date(Date.now() + newSsoOidcToken.expiresIn * 1000); + try { + await writeSSOTokenToFile(ssoSessionName, { + ...ssoToken, + accessToken: newSsoOidcToken.accessToken, + expiresAt: newTokenExpiration.toISOString(), + refreshToken: newSsoOidcToken.refreshToken, + }); + } + catch (error) { + } + return { + token: newSsoOidcToken.accessToken, + expiration: newTokenExpiration, + }; + } + catch (error) { + validateTokenExpiry(existingToken); + return existingToken; + } +}; + +const fromStatic = ({ token, logger }) => async () => { + logger?.debug("@aws-sdk/token-providers - fromStatic"); + if (!token || !token.token) { + throw new propertyProvider.TokenProviderError(`Please pass a valid token to fromStatic`, false); + } + return token; +}; + +const nodeProvider = (init = {}) => propertyProvider.memoize(propertyProvider.chain(fromSso(init), async () => { + throw new propertyProvider.TokenProviderError("Could not load token from any providers", false); +}), (token) => token.expiration !== undefined && token.expiration.getTime() - Date.now() < 300000, (token) => token.expiration !== undefined); + +exports.fromEnvSigningName = fromEnvSigningName; +exports.fromSso = fromSso; +exports.fromStatic = fromStatic; +exports.nodeProvider = nodeProvider; + + +/***/ }), + +/***/ 2807: +/***/ ((module) => { + +module.exports = /*#__PURE__*/JSON.parse('{"name":"@aws-sdk/client-sso","description":"AWS SDK for JavaScript Sso Client for Node.js, Browser and React Native","version":"3.935.0","scripts":{"build":"concurrently \'yarn:build:cjs\' \'yarn:build:es\' \'yarn:build:types\'","build:cjs":"node ../../scripts/compilation/inline client-sso","build:es":"tsc -p tsconfig.es.json","build:include:deps":"lerna run --scope $npm_package_name --include-dependencies build","build:types":"tsc -p tsconfig.types.json","build:types:downlevel":"downlevel-dts dist-types dist-types/ts3.4","clean":"rimraf ./dist-* && rimraf *.tsbuildinfo","extract:docs":"api-extractor run --local","generate:client":"node ../../scripts/generate-clients/single-service --solo sso"},"main":"./dist-cjs/index.js","types":"./dist-types/index.d.ts","module":"./dist-es/index.js","sideEffects":false,"dependencies":{"@aws-crypto/sha256-browser":"5.2.0","@aws-crypto/sha256-js":"5.2.0","@aws-sdk/core":"3.935.0","@aws-sdk/middleware-host-header":"3.930.0","@aws-sdk/middleware-logger":"3.930.0","@aws-sdk/middleware-recursion-detection":"3.933.0","@aws-sdk/middleware-user-agent":"3.935.0","@aws-sdk/region-config-resolver":"3.930.0","@aws-sdk/types":"3.930.0","@aws-sdk/util-endpoints":"3.930.0","@aws-sdk/util-user-agent-browser":"3.930.0","@aws-sdk/util-user-agent-node":"3.935.0","@smithy/config-resolver":"^4.4.3","@smithy/core":"^3.18.5","@smithy/fetch-http-handler":"^5.3.6","@smithy/hash-node":"^4.2.5","@smithy/invalid-dependency":"^4.2.5","@smithy/middleware-content-length":"^4.2.5","@smithy/middleware-endpoint":"^4.3.12","@smithy/middleware-retry":"^4.4.12","@smithy/middleware-serde":"^4.2.6","@smithy/middleware-stack":"^4.2.5","@smithy/node-config-provider":"^4.3.5","@smithy/node-http-handler":"^4.4.5","@smithy/protocol-http":"^5.3.5","@smithy/smithy-client":"^4.9.8","@smithy/types":"^4.9.0","@smithy/url-parser":"^4.2.5","@smithy/util-base64":"^4.3.0","@smithy/util-body-length-browser":"^4.2.0","@smithy/util-body-length-node":"^4.2.1","@smithy/util-defaults-mode-browser":"^4.3.11","@smithy/util-defaults-mode-node":"^4.2.14","@smithy/util-endpoints":"^3.2.5","@smithy/util-middleware":"^4.2.5","@smithy/util-retry":"^4.2.5","@smithy/util-utf8":"^4.2.0","tslib":"^2.6.2"},"devDependencies":{"@tsconfig/node18":"18.2.4","@types/node":"^18.19.69","concurrently":"7.0.0","downlevel-dts":"0.10.1","rimraf":"3.0.2","typescript":"~5.8.3"},"engines":{"node":">=18.0.0"},"typesVersions":{"<4.0":{"dist-types/*":["dist-types/ts3.4/*"]}},"files":["dist-*/**"],"author":{"name":"AWS SDK for JavaScript Team","url":"https://aws.amazon.com/javascript/"},"license":"Apache-2.0","browser":{"./dist-es/runtimeConfig":"./dist-es/runtimeConfig.browser"},"react-native":{"./dist-es/runtimeConfig":"./dist-es/runtimeConfig.native"},"homepage":"https://github.com/aws/aws-sdk-js-v3/tree/main/clients/client-sso","repository":{"type":"git","url":"https://github.com/aws/aws-sdk-js-v3.git","directory":"clients/client-sso"}}'); + +/***/ }) + +}; +; \ No newline at end of file diff --git a/dist/index.js b/dist/index.js index bfd85c5..0e1d734 100644 --- a/dist/index.js +++ b/dist/index.js @@ -1,1442 +1,1226 @@ -module.exports = -/******/ (function(modules, runtime) { // webpackBootstrap -/******/ "use strict"; -/******/ // The module cache -/******/ var installedModules = {}; -/******/ -/******/ // The require function -/******/ function __webpack_require__(moduleId) { -/******/ -/******/ // Check if module is in cache -/******/ if(installedModules[moduleId]) { -/******/ return installedModules[moduleId].exports; -/******/ } -/******/ // Create a new module (and put it into the cache) -/******/ var module = installedModules[moduleId] = { -/******/ i: moduleId, -/******/ l: false, -/******/ exports: {} -/******/ }; -/******/ -/******/ // Execute the module function -/******/ var threw = true; -/******/ try { -/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); -/******/ threw = false; -/******/ } finally { -/******/ if(threw) delete installedModules[moduleId]; -/******/ } -/******/ -/******/ // Flag the module as loaded -/******/ module.l = true; -/******/ -/******/ // Return the exports of the module -/******/ return module.exports; -/******/ } -/******/ -/******/ -/******/ __webpack_require__.ab = __dirname + "/"; -/******/ -/******/ // the startup function -/******/ function startup() { -/******/ // Load entry module and return exports -/******/ return __webpack_require__(198); -/******/ }; -/******/ -/******/ // run startup -/******/ return startup(); -/******/ }) -/************************************************************************/ -/******/ ({ +/******/ (() => { // webpackBootstrap +/******/ var __webpack_modules__ = ({ -/***/ 24: -/***/ (function(module, __unusedexports, __webpack_require__) { +/***/ 4914: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; - -var Type = __webpack_require__(4945); - -module.exports = new Type('tag:yaml.org,2002:map', { - kind: 'mapping', - construct: function (data) { return data !== null ? data : {}; } -}); - - -/***/ }), - -/***/ 32: -/***/ (function(module) { - -module.exports = {"pagination":{"DescribeCases":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken","result_key":"cases"},"DescribeCommunications":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken","result_key":"communications"},"DescribeServices":{"result_key":"services"},"DescribeTrustedAdvisorCheckRefreshStatuses":{"result_key":"statuses"},"DescribeTrustedAdvisorCheckSummaries":{"result_key":"summaries"}}}; - -/***/ }), - -/***/ 42: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['wafv2'] = {}; -AWS.WAFV2 = Service.defineService('wafv2', ['2019-07-29']); -Object.defineProperty(apiLoader.services['wafv2'], '2019-07-29', { - get: function get() { - var model = __webpack_require__(5118); - model.paginators = __webpack_require__(1657).pagination; - return model; - }, - enumerable: true, - configurable: true +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; }); - -module.exports = AWS.WAFV2; - - -/***/ }), - -/***/ 47: -/***/ (function(module) { - -module.exports = {"pagination":{"DescribeAccountAttributes":{"result_key":"AccountAttributes"},"DescribeAddresses":{"result_key":"Addresses"},"DescribeAvailabilityZones":{"result_key":"AvailabilityZones"},"DescribeBundleTasks":{"result_key":"BundleTasks"},"DescribeByoipCidrs":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"ByoipCidrs"},"DescribeCapacityReservations":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"CapacityReservations"},"DescribeClassicLinkInstances":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Instances"},"DescribeClientVpnAuthorizationRules":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"AuthorizationRules"},"DescribeClientVpnConnections":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Connections"},"DescribeClientVpnEndpoints":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"ClientVpnEndpoints"},"DescribeClientVpnRoutes":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Routes"},"DescribeClientVpnTargetNetworks":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"ClientVpnTargetNetworks"},"DescribeCoipPools":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"CoipPools"},"DescribeConversionTasks":{"result_key":"ConversionTasks"},"DescribeCustomerGateways":{"result_key":"CustomerGateways"},"DescribeDhcpOptions":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"DhcpOptions"},"DescribeEgressOnlyInternetGateways":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"EgressOnlyInternetGateways"},"DescribeExportImageTasks":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"ExportImageTasks"},"DescribeExportTasks":{"result_key":"ExportTasks"},"DescribeFastSnapshotRestores":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"FastSnapshotRestores"},"DescribeFleets":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Fleets"},"DescribeFlowLogs":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"FlowLogs"},"DescribeFpgaImages":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"FpgaImages"},"DescribeHostReservationOfferings":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"OfferingSet"},"DescribeHostReservations":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"HostReservationSet"},"DescribeHosts":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Hosts"},"DescribeIamInstanceProfileAssociations":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"IamInstanceProfileAssociations"},"DescribeImages":{"result_key":"Images"},"DescribeImportImageTasks":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"ImportImageTasks"},"DescribeImportSnapshotTasks":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"ImportSnapshotTasks"},"DescribeInstanceCreditSpecifications":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"InstanceCreditSpecifications"},"DescribeInstanceStatus":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"InstanceStatuses"},"DescribeInstanceTypeOfferings":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"InstanceTypeOfferings"},"DescribeInstanceTypes":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"InstanceTypes"},"DescribeInstances":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Reservations"},"DescribeInternetGateways":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"InternetGateways"},"DescribeIpv6Pools":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Ipv6Pools"},"DescribeKeyPairs":{"result_key":"KeyPairs"},"DescribeLaunchTemplateVersions":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"LaunchTemplateVersions"},"DescribeLaunchTemplates":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"LaunchTemplates"},"DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"LocalGatewayRouteTableVirtualInterfaceGroupAssociations"},"DescribeLocalGatewayRouteTableVpcAssociations":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"LocalGatewayRouteTableVpcAssociations"},"DescribeLocalGatewayRouteTables":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"LocalGatewayRouteTables"},"DescribeLocalGatewayVirtualInterfaceGroups":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"LocalGatewayVirtualInterfaceGroups"},"DescribeLocalGatewayVirtualInterfaces":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"LocalGatewayVirtualInterfaces"},"DescribeLocalGateways":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"LocalGateways"},"DescribeManagedPrefixLists":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"PrefixLists"},"DescribeMovingAddresses":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"MovingAddressStatuses"},"DescribeNatGateways":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"NatGateways"},"DescribeNetworkAcls":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"NetworkAcls"},"DescribeNetworkInterfacePermissions":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"NetworkInterfacePermissions"},"DescribeNetworkInterfaces":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"NetworkInterfaces"},"DescribePlacementGroups":{"result_key":"PlacementGroups"},"DescribePrefixLists":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"PrefixLists"},"DescribePrincipalIdFormat":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Principals"},"DescribePublicIpv4Pools":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"PublicIpv4Pools"},"DescribeRegions":{"result_key":"Regions"},"DescribeReservedInstances":{"result_key":"ReservedInstances"},"DescribeReservedInstancesListings":{"result_key":"ReservedInstancesListings"},"DescribeReservedInstancesModifications":{"input_token":"NextToken","output_token":"NextToken","result_key":"ReservedInstancesModifications"},"DescribeReservedInstancesOfferings":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"ReservedInstancesOfferings"},"DescribeRouteTables":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"RouteTables"},"DescribeScheduledInstanceAvailability":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"ScheduledInstanceAvailabilitySet"},"DescribeScheduledInstances":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"ScheduledInstanceSet"},"DescribeSecurityGroups":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"SecurityGroups"},"DescribeSnapshots":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Snapshots"},"DescribeSpotFleetRequests":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"SpotFleetRequestConfigs"},"DescribeSpotInstanceRequests":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"SpotInstanceRequests"},"DescribeSpotPriceHistory":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"SpotPriceHistory"},"DescribeStaleSecurityGroups":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"StaleSecurityGroupSet"},"DescribeSubnets":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Subnets"},"DescribeTags":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Tags"},"DescribeTrafficMirrorFilters":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"TrafficMirrorFilters"},"DescribeTrafficMirrorSessions":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"TrafficMirrorSessions"},"DescribeTrafficMirrorTargets":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"TrafficMirrorTargets"},"DescribeTransitGatewayAttachments":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"TransitGatewayAttachments"},"DescribeTransitGatewayMulticastDomains":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"TransitGatewayMulticastDomains"},"DescribeTransitGatewayPeeringAttachments":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"TransitGatewayPeeringAttachments"},"DescribeTransitGatewayRouteTables":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"TransitGatewayRouteTables"},"DescribeTransitGatewayVpcAttachments":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"TransitGatewayVpcAttachments"},"DescribeTransitGateways":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"TransitGateways"},"DescribeVolumeStatus":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"VolumeStatuses"},"DescribeVolumes":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Volumes"},"DescribeVolumesModifications":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"VolumesModifications"},"DescribeVpcClassicLinkDnsSupport":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Vpcs"},"DescribeVpcEndpointConnectionNotifications":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"ConnectionNotificationSet"},"DescribeVpcEndpointConnections":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"VpcEndpointConnections"},"DescribeVpcEndpointServiceConfigurations":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"ServiceConfigurations"},"DescribeVpcEndpointServicePermissions":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"AllowedPrincipals"},"DescribeVpcEndpoints":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"VpcEndpoints"},"DescribeVpcPeeringConnections":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"VpcPeeringConnections"},"DescribeVpcs":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Vpcs"},"DescribeVpnConnections":{"result_key":"VpnConnections"},"DescribeVpnGateways":{"result_key":"VpnGateways"},"GetAssociatedIpv6PoolCidrs":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Ipv6CidrAssociations"},"GetGroupsForCapacityReservation":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"CapacityReservationGroups"},"GetManagedPrefixListAssociations":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"PrefixListAssociations"},"GetManagedPrefixListEntries":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Entries"},"GetTransitGatewayAttachmentPropagations":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"TransitGatewayAttachmentPropagations"},"GetTransitGatewayMulticastDomainAssociations":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"MulticastDomainAssociations"},"GetTransitGatewayRouteTableAssociations":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Associations"},"GetTransitGatewayRouteTablePropagations":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"TransitGatewayRouteTablePropagations"},"SearchLocalGatewayRoutes":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Routes"},"SearchTransitGatewayMulticastGroups":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"MulticastGroups"}}}; - -/***/ }), - -/***/ 72: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2017-08-22","endpointPrefix":"acm-pca","jsonVersion":"1.1","protocol":"json","serviceAbbreviation":"ACM-PCA","serviceFullName":"AWS Certificate Manager Private Certificate Authority","serviceId":"ACM PCA","signatureVersion":"v4","targetPrefix":"ACMPrivateCA","uid":"acm-pca-2017-08-22"},"operations":{"CreateCertificateAuthority":{"input":{"type":"structure","required":["CertificateAuthorityConfiguration","CertificateAuthorityType"],"members":{"CertificateAuthorityConfiguration":{"shape":"S2"},"RevocationConfiguration":{"shape":"Se"},"CertificateAuthorityType":{},"IdempotencyToken":{},"Tags":{"shape":"Sm"}}},"output":{"type":"structure","members":{"CertificateAuthorityArn":{}}},"idempotent":true},"CreateCertificateAuthorityAuditReport":{"input":{"type":"structure","required":["CertificateAuthorityArn","S3BucketName","AuditReportResponseFormat"],"members":{"CertificateAuthorityArn":{},"S3BucketName":{},"AuditReportResponseFormat":{}}},"output":{"type":"structure","members":{"AuditReportId":{},"S3Key":{}}},"idempotent":true},"CreatePermission":{"input":{"type":"structure","required":["CertificateAuthorityArn","Principal","Actions"],"members":{"CertificateAuthorityArn":{},"Principal":{},"SourceAccount":{},"Actions":{"shape":"S10"}}}},"DeleteCertificateAuthority":{"input":{"type":"structure","required":["CertificateAuthorityArn"],"members":{"CertificateAuthorityArn":{},"PermanentDeletionTimeInDays":{"type":"integer"}}}},"DeletePermission":{"input":{"type":"structure","required":["CertificateAuthorityArn","Principal"],"members":{"CertificateAuthorityArn":{},"Principal":{},"SourceAccount":{}}}},"DescribeCertificateAuthority":{"input":{"type":"structure","required":["CertificateAuthorityArn"],"members":{"CertificateAuthorityArn":{}}},"output":{"type":"structure","members":{"CertificateAuthority":{"shape":"S17"}}}},"DescribeCertificateAuthorityAuditReport":{"input":{"type":"structure","required":["CertificateAuthorityArn","AuditReportId"],"members":{"CertificateAuthorityArn":{},"AuditReportId":{}}},"output":{"type":"structure","members":{"AuditReportStatus":{},"S3BucketName":{},"S3Key":{},"CreatedAt":{"type":"timestamp"}}}},"GetCertificate":{"input":{"type":"structure","required":["CertificateAuthorityArn","CertificateArn"],"members":{"CertificateAuthorityArn":{},"CertificateArn":{}}},"output":{"type":"structure","members":{"Certificate":{},"CertificateChain":{}}}},"GetCertificateAuthorityCertificate":{"input":{"type":"structure","required":["CertificateAuthorityArn"],"members":{"CertificateAuthorityArn":{}}},"output":{"type":"structure","members":{"Certificate":{},"CertificateChain":{}}}},"GetCertificateAuthorityCsr":{"input":{"type":"structure","required":["CertificateAuthorityArn"],"members":{"CertificateAuthorityArn":{}}},"output":{"type":"structure","members":{"Csr":{}}}},"ImportCertificateAuthorityCertificate":{"input":{"type":"structure","required":["CertificateAuthorityArn","Certificate"],"members":{"CertificateAuthorityArn":{},"Certificate":{"type":"blob"},"CertificateChain":{"type":"blob"}}}},"IssueCertificate":{"input":{"type":"structure","required":["CertificateAuthorityArn","Csr","SigningAlgorithm","Validity"],"members":{"CertificateAuthorityArn":{},"Csr":{"type":"blob"},"SigningAlgorithm":{},"TemplateArn":{},"Validity":{"type":"structure","required":["Value","Type"],"members":{"Value":{"type":"long"},"Type":{}}},"IdempotencyToken":{}}},"output":{"type":"structure","members":{"CertificateArn":{}}},"idempotent":true},"ListCertificateAuthorities":{"input":{"type":"structure","members":{"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"CertificateAuthorities":{"type":"list","member":{"shape":"S17"}},"NextToken":{}}}},"ListPermissions":{"input":{"type":"structure","required":["CertificateAuthorityArn"],"members":{"CertificateAuthorityArn":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"Permissions":{"type":"list","member":{"type":"structure","members":{"CertificateAuthorityArn":{},"CreatedAt":{"type":"timestamp"},"Principal":{},"SourceAccount":{},"Actions":{"shape":"S10"},"Policy":{}}}},"NextToken":{}}}},"ListTags":{"input":{"type":"structure","required":["CertificateAuthorityArn"],"members":{"CertificateAuthorityArn":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"Tags":{"shape":"Sm"},"NextToken":{}}}},"RestoreCertificateAuthority":{"input":{"type":"structure","required":["CertificateAuthorityArn"],"members":{"CertificateAuthorityArn":{}}}},"RevokeCertificate":{"input":{"type":"structure","required":["CertificateAuthorityArn","CertificateSerial","RevocationReason"],"members":{"CertificateAuthorityArn":{},"CertificateSerial":{},"RevocationReason":{}}}},"TagCertificateAuthority":{"input":{"type":"structure","required":["CertificateAuthorityArn","Tags"],"members":{"CertificateAuthorityArn":{},"Tags":{"shape":"Sm"}}}},"UntagCertificateAuthority":{"input":{"type":"structure","required":["CertificateAuthorityArn","Tags"],"members":{"CertificateAuthorityArn":{},"Tags":{"shape":"Sm"}}}},"UpdateCertificateAuthority":{"input":{"type":"structure","required":["CertificateAuthorityArn"],"members":{"CertificateAuthorityArn":{},"RevocationConfiguration":{"shape":"Se"},"Status":{}}}}},"shapes":{"S2":{"type":"structure","required":["KeyAlgorithm","SigningAlgorithm","Subject"],"members":{"KeyAlgorithm":{},"SigningAlgorithm":{},"Subject":{"type":"structure","members":{"Country":{},"Organization":{},"OrganizationalUnit":{},"DistinguishedNameQualifier":{},"State":{},"CommonName":{},"SerialNumber":{},"Locality":{},"Title":{},"Surname":{},"GivenName":{},"Initials":{},"Pseudonym":{},"GenerationQualifier":{}}}}},"Se":{"type":"structure","members":{"CrlConfiguration":{"type":"structure","required":["Enabled"],"members":{"Enabled":{"type":"boolean"},"ExpirationInDays":{"type":"integer"},"CustomCname":{},"S3BucketName":{}}}}},"Sm":{"type":"list","member":{"type":"structure","required":["Key"],"members":{"Key":{},"Value":{}}}},"S10":{"type":"list","member":{}},"S17":{"type":"structure","members":{"Arn":{},"CreatedAt":{"type":"timestamp"},"LastStateChangeAt":{"type":"timestamp"},"Type":{},"Serial":{},"Status":{},"NotBefore":{"type":"timestamp"},"NotAfter":{"type":"timestamp"},"FailureReason":{},"CertificateAuthorityConfiguration":{"shape":"S2"},"RevocationConfiguration":{"shape":"Se"},"RestorableUntil":{"type":"timestamp"}}}}}; - -/***/ }), - -/***/ 91: -/***/ (function(module) { - -module.exports = {"pagination":{}}; - -/***/ }), - -/***/ 93: -/***/ (function(module, __unusedexports, __webpack_require__) { - -"use strict"; - - - -var common = __webpack_require__(2740); - - -function Mark(name, buffer, position, line, column) { - this.name = name; - this.buffer = buffer; - this.position = position; - this.line = line; - this.column = column; +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 })); +exports.issueCommand = issueCommand; +exports.issue = issue; +const os = __importStar(__nccwpck_require__(857)); +const utils_1 = __nccwpck_require__(302); +/** + * Issues a command to the GitHub Actions runner + * + * @param command - The command name to issue + * @param properties - Additional properties for the command (key-value pairs) + * @param message - The message to include with the command + * @remarks + * This function outputs a specially formatted string to stdout that the Actions + * runner interprets as a command. These commands can control workflow behavior, + * set outputs, create annotations, mask values, and more. + * + * Command Format: + * ::name key=value,key=value::message + * + * @example + * ```typescript + * // Issue a warning annotation + * issueCommand('warning', {}, 'This is a warning message'); + * // Output: ::warning::This is a warning message + * + * // Set an environment variable + * issueCommand('set-env', { name: 'MY_VAR' }, 'some value'); + * // Output: ::set-env name=MY_VAR::some value + * + * // Add a secret mask + * issueCommand('add-mask', {}, 'secretValue123'); + * // Output: ::add-mask::secretValue123 + * ``` + * + * @internal + * This is an internal utility function that powers the public API functions + * such as setSecret, warning, error, and exportVariable. + */ +function issueCommand(command, properties, message) { + const cmd = new Command(command, properties, message); + process.stdout.write(cmd.toString() + os.EOL); } - - -Mark.prototype.getSnippet = function getSnippet(indent, maxLength) { - var head, start, tail, end, snippet; - - if (!this.buffer) return null; - - indent = indent || 4; - maxLength = maxLength || 75; - - head = ''; - start = this.position; - - while (start > 0 && '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(start - 1)) === -1) { - start -= 1; - if (this.position - start > (maxLength / 2 - 1)) { - head = ' ... '; - start += 5; - break; +function issue(name, message = '') { + issueCommand(name, {}, message); +} +const CMD_STRING = '::'; +class Command { + constructor(command, properties, message) { + if (!command) { + command = 'missing.command'; + } + this.command = command; + this.properties = properties; + this.message = message; } - } - - tail = ''; - end = this.position; - - while (end < this.buffer.length && '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(end)) === -1) { - end += 1; - if (end - this.position > (maxLength / 2 - 1)) { - tail = ' ... '; - end -= 5; - break; + toString() { + let cmdStr = CMD_STRING + this.command; + if (this.properties && Object.keys(this.properties).length > 0) { + cmdStr += ' '; + let first = true; + for (const key in this.properties) { + if (this.properties.hasOwnProperty(key)) { + const val = this.properties[key]; + if (val) { + if (first) { + first = false; + } + else { + cmdStr += ','; + } + cmdStr += `${key}=${escapeProperty(val)}`; + } + } + } + } + cmdStr += `${CMD_STRING}${escapeData(this.message)}`; + return cmdStr; } - } - - snippet = this.buffer.slice(start, end); - - return common.repeat(' ', indent) + head + snippet + tail + '\n' + - common.repeat(' ', indent + this.position - start + head.length) + '^'; -}; - - -Mark.prototype.toString = function toString(compact) { - var snippet, where = ''; +} +function escapeData(s) { + return (0, utils_1.toCommandValue)(s) + .replace(/%/g, '%25') + .replace(/\r/g, '%0D') + .replace(/\n/g, '%0A'); +} +function escapeProperty(s) { + return (0, utils_1.toCommandValue)(s) + .replace(/%/g, '%25') + .replace(/\r/g, '%0D') + .replace(/\n/g, '%0A') + .replace(/:/g, '%3A') + .replace(/,/g, '%2C'); +} +//# sourceMappingURL=command.js.map - if (this.name) { - where += 'in "' + this.name + '" '; - } +/***/ }), - where += 'at line ' + (this.line + 1) + ', column ' + (this.column + 1); +/***/ 7484: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - if (!compact) { - snippet = this.getSnippet(); +"use strict"; - if (snippet) { - where += ':\n' + snippet; +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]; } }; } - } - - return where; -}; - - -module.exports = Mark; - - -/***/ }), - -/***/ 99: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['medialive'] = {}; -AWS.MediaLive = Service.defineService('medialive', ['2017-10-14']); -Object.defineProperty(apiLoader.services['medialive'], '2017-10-14', { - get: function get() { - var model = __webpack_require__(4444); - model.paginators = __webpack_require__(8369).pagination; - model.waiters = __webpack_require__(9461).waiters; - return model; - }, - enumerable: true, - configurable: true + 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; }); - -module.exports = AWS.MediaLive; - - -/***/ }), - -/***/ 109: -/***/ (function(module, __unusedexports, __webpack_require__) { - -var util = __webpack_require__(395).util; -var convert = __webpack_require__(9433); - -var Translator = function(options) { - options = options || {}; - this.attrValue = options.attrValue; - this.convertEmptyValues = Boolean(options.convertEmptyValues); - this.wrapNumbers = Boolean(options.wrapNumbers); -}; - -Translator.prototype.translateInput = function(value, shape) { - this.mode = 'input'; - return this.translate(value, shape); -}; - -Translator.prototype.translateOutput = function(value, shape) { - this.mode = 'output'; - return this.translate(value, shape); -}; - -Translator.prototype.translate = function(value, shape) { - var self = this; - if (!shape || value === undefined) return undefined; - - if (shape.shape === self.attrValue) { - return convert[self.mode](value, { - convertEmptyValues: self.convertEmptyValues, - wrapNumbers: self.wrapNumbers, +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; + }; +})(); +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); }); - } - switch (shape.type) { - case 'structure': return self.translateStructure(value, shape); - case 'map': return self.translateMap(value, shape); - case 'list': return self.translateList(value, shape); - default: return self.translateScalar(value, shape); - } -}; - -Translator.prototype.translateStructure = function(structure, shape) { - var self = this; - if (structure == null) return undefined; - - var struct = {}; - util.each(structure, function(name, value) { - var memberShape = shape.members[name]; - if (memberShape) { - var result = self.translate(value, memberShape); - if (result !== undefined) struct[name] = result; - } - }); - return struct; -}; - -Translator.prototype.translateList = function(list, shape) { - var self = this; - if (list == null) return undefined; - - var out = []; - util.arrayEach(list, function(value) { - var result = self.translate(value, shape.member); - if (result === undefined) out.push(null); - else out.push(result); - }); - return out; -}; - -Translator.prototype.translateMap = function(map, shape) { - var self = this; - if (map == null) return undefined; - - var out = {}; - util.each(map, function(key, value) { - var result = self.translate(value, shape.value); - if (result === undefined) out[key] = null; - else out[key] = result; - }); - return out; -}; - -Translator.prototype.translateScalar = function(value, shape) { - return shape.toType(value); }; - +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.platform = exports.toPlatformPath = exports.toWin32Path = exports.toPosixPath = exports.markdownSummary = exports.summary = exports.ExitCode = void 0; +exports.exportVariable = exportVariable; +exports.setSecret = setSecret; +exports.addPath = addPath; +exports.getInput = getInput; +exports.getMultilineInput = getMultilineInput; +exports.getBooleanInput = getBooleanInput; +exports.setOutput = setOutput; +exports.setCommandEcho = setCommandEcho; +exports.setFailed = setFailed; +exports.isDebug = isDebug; +exports.debug = debug; +exports.error = error; +exports.warning = warning; +exports.notice = notice; +exports.info = info; +exports.startGroup = startGroup; +exports.endGroup = endGroup; +exports.group = group; +exports.saveState = saveState; +exports.getState = getState; +exports.getIDToken = getIDToken; +const command_1 = __nccwpck_require__(4914); +const file_command_1 = __nccwpck_require__(4753); +const utils_1 = __nccwpck_require__(302); +const os = __importStar(__nccwpck_require__(857)); +const path = __importStar(__nccwpck_require__(6928)); +const oidc_utils_1 = __nccwpck_require__(5306); /** - * @api private + * The code to exit an action */ -module.exports = Translator; - - -/***/ }), - -/***/ 153: -/***/ (function(module, __unusedexports, __webpack_require__) { - -/* eslint guard-for-in:0 */ -var AWS; - -/** - * A set of utility methods for use with the AWS SDK. - * - * @!attribute abort - * Return this value from an iterator function {each} or {arrayEach} - * to break out of the iteration. - * @example Breaking out of an iterator function - * AWS.util.each({a: 1, b: 2, c: 3}, function(key, value) { - * if (key == 'b') return AWS.util.abort; - * }); - * @see each - * @see arrayEach - * @api private +var ExitCode; +(function (ExitCode) { + /** + * A code indicating that the action was successful + */ + ExitCode[ExitCode["Success"] = 0] = "Success"; + /** + * A code indicating that the action was a failure + */ + ExitCode[ExitCode["Failure"] = 1] = "Failure"; +})(ExitCode || (exports.ExitCode = ExitCode = {})); +//----------------------------------------------------------------------- +// Variables +//----------------------------------------------------------------------- +/** + * Sets env variable for this action and future actions in the job + * @param name the name of the variable to set + * @param val the value of the variable. Non-string values will be converted to a string via JSON.stringify */ -var util = { - environment: 'nodejs', - engine: function engine() { - if (util.isBrowser() && typeof navigator !== 'undefined') { - return navigator.userAgent; - } else { - var engine = process.platform + '/' + process.version; - if (process.env.AWS_EXECUTION_ENV) { - engine += ' exec-env/' + process.env.AWS_EXECUTION_ENV; - } - return engine; +// eslint-disable-next-line @typescript-eslint/no-explicit-any +function exportVariable(name, val) { + const convertedVal = (0, utils_1.toCommandValue)(val); + process.env[name] = convertedVal; + const filePath = process.env['GITHUB_ENV'] || ''; + if (filePath) { + return (0, file_command_1.issueFileCommand)('ENV', (0, file_command_1.prepareKeyValueMessage)(name, val)); } - }, - - userAgent: function userAgent() { - var name = util.environment; - var agent = 'aws-sdk-' + name + '/' + __webpack_require__(395).VERSION; - if (name === 'nodejs') agent += ' ' + util.engine(); - return agent; - }, - - uriEscape: function uriEscape(string) { - var output = encodeURIComponent(string); - output = output.replace(/[^A-Za-z0-9_.~\-%]+/g, escape); - - // AWS percent-encodes some extra non-standard characters in a URI - output = output.replace(/[*]/g, function(ch) { - return '%' + ch.charCodeAt(0).toString(16).toUpperCase(); + (0, command_1.issueCommand)('set-env', { name }, convertedVal); +} +/** + * Registers a secret which will get masked from logs + * + * @param secret - Value of the secret to be masked + * @remarks + * This function instructs the Actions runner to mask the specified value in any + * logs produced during the workflow run. Once registered, the secret value will + * be replaced with asterisks (***) whenever it appears in console output, logs, + * or error messages. + * + * This is useful for protecting sensitive information such as: + * - API keys + * - Access tokens + * - Authentication credentials + * - URL parameters containing signatures (SAS tokens) + * + * Note that masking only affects future logs; any previous appearances of the + * secret in logs before calling this function will remain unmasked. + * + * @example + * ```typescript + * // Register an API token as a secret + * const apiToken = "abc123xyz456"; + * setSecret(apiToken); + * + * // Now any logs containing this value will show *** instead + * console.log(`Using token: ${apiToken}`); // Outputs: "Using token: ***" + * ``` + */ +function setSecret(secret) { + (0, command_1.issueCommand)('add-mask', {}, secret); +} +/** + * Prepends inputPath to the PATH (for this action and future actions) + * @param inputPath + */ +function addPath(inputPath) { + const filePath = process.env['GITHUB_PATH'] || ''; + if (filePath) { + (0, file_command_1.issueFileCommand)('PATH', inputPath); + } + else { + (0, command_1.issueCommand)('add-path', {}, inputPath); + } + process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`; +} +/** + * Gets the value of an input. + * Unless trimWhitespace is set to false in InputOptions, the value is also trimmed. + * Returns an empty string if the value is not defined. + * + * @param name name of the input to get + * @param options optional. See InputOptions. + * @returns string + */ +function getInput(name, options) { + const val = process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] || ''; + if (options && options.required && !val) { + throw new Error(`Input required and not supplied: ${name}`); + } + if (options && options.trimWhitespace === false) { + return val; + } + return val.trim(); +} +/** + * Gets the values of an multiline input. Each value is also trimmed. + * + * @param name name of the input to get + * @param options optional. See InputOptions. + * @returns string[] + * + */ +function getMultilineInput(name, options) { + const inputs = getInput(name, options) + .split('\n') + .filter(x => x !== ''); + if (options && options.trimWhitespace === false) { + return inputs; + } + return inputs.map(input => input.trim()); +} +/** + * Gets the input value of the boolean type in the YAML 1.2 "core schema" specification. + * Support boolean input list: `true | True | TRUE | false | False | FALSE` . + * The return value is also in boolean type. + * ref: https://yaml.org/spec/1.2/spec.html#id2804923 + * + * @param name name of the input to get + * @param options optional. See InputOptions. + * @returns boolean + */ +function getBooleanInput(name, options) { + const trueValue = ['true', 'True', 'TRUE']; + const falseValue = ['false', 'False', 'FALSE']; + const val = getInput(name, options); + if (trueValue.includes(val)) + return true; + if (falseValue.includes(val)) + return false; + throw new TypeError(`Input does not meet YAML 1.2 "Core Schema" specification: ${name}\n` + + `Support boolean input list: \`true | True | TRUE | false | False | FALSE\``); +} +/** + * Sets the value of an output. + * + * @param name name of the output to set + * @param value value to store. Non-string values will be converted to a string via JSON.stringify + */ +// eslint-disable-next-line @typescript-eslint/no-explicit-any +function setOutput(name, value) { + const filePath = process.env['GITHUB_OUTPUT'] || ''; + if (filePath) { + return (0, file_command_1.issueFileCommand)('OUTPUT', (0, file_command_1.prepareKeyValueMessage)(name, value)); + } + process.stdout.write(os.EOL); + (0, command_1.issueCommand)('set-output', { name }, (0, utils_1.toCommandValue)(value)); +} +/** + * Enables or disables the echoing of commands into stdout for the rest of the step. + * Echoing is disabled by default if ACTIONS_STEP_DEBUG is not set. + * + */ +function setCommandEcho(enabled) { + (0, command_1.issue)('echo', enabled ? 'on' : 'off'); +} +//----------------------------------------------------------------------- +// Results +//----------------------------------------------------------------------- +/** + * Sets the action status to failed. + * When the action exits it will be with an exit code of 1 + * @param message add error issue message + */ +function setFailed(message) { + process.exitCode = ExitCode.Failure; + error(message); +} +//----------------------------------------------------------------------- +// Logging Commands +//----------------------------------------------------------------------- +/** + * Gets whether Actions Step Debug is on or not + */ +function isDebug() { + return process.env['RUNNER_DEBUG'] === '1'; +} +/** + * Writes debug message to user log + * @param message debug message + */ +function debug(message) { + (0, command_1.issueCommand)('debug', {}, message); +} +/** + * Adds an error issue + * @param message error issue message. Errors will be converted to string via toString() + * @param properties optional properties to add to the annotation. + */ +function error(message, properties = {}) { + (0, command_1.issueCommand)('error', (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message); +} +/** + * Adds a warning issue + * @param message warning issue message. Errors will be converted to string via toString() + * @param properties optional properties to add to the annotation. + */ +function warning(message, properties = {}) { + (0, command_1.issueCommand)('warning', (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message); +} +/** + * Adds a notice issue + * @param message notice issue message. Errors will be converted to string via toString() + * @param properties optional properties to add to the annotation. + */ +function notice(message, properties = {}) { + (0, command_1.issueCommand)('notice', (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message); +} +/** + * Writes info to log with console.log. + * @param message info message + */ +function info(message) { + process.stdout.write(message + os.EOL); +} +/** + * Begin an output group. + * + * Output until the next `groupEnd` will be foldable in this group + * + * @param name The name of the output group + */ +function startGroup(name) { + (0, command_1.issue)('group', name); +} +/** + * End an output group. + */ +function endGroup() { + (0, command_1.issue)('endgroup'); +} +/** + * Wrap an asynchronous function call in a group. + * + * Returns the same type as the function itself. + * + * @param name The name of the group + * @param fn The function to wrap in the group + */ +function group(name, fn) { + return __awaiter(this, void 0, void 0, function* () { + startGroup(name); + let result; + try { + result = yield fn(); + } + finally { + endGroup(); + } + return result; }); - - return output; - }, - - uriEscapePath: function uriEscapePath(string) { - var parts = []; - util.arrayEach(string.split('/'), function (part) { - parts.push(util.uriEscape(part)); +} +//----------------------------------------------------------------------- +// Wrapper action state +//----------------------------------------------------------------------- +/** + * Saves state for current action, the state can only be retrieved by this action's post job execution. + * + * @param name name of the state to store + * @param value value to store. Non-string values will be converted to a string via JSON.stringify + */ +// eslint-disable-next-line @typescript-eslint/no-explicit-any +function saveState(name, value) { + const filePath = process.env['GITHUB_STATE'] || ''; + if (filePath) { + return (0, file_command_1.issueFileCommand)('STATE', (0, file_command_1.prepareKeyValueMessage)(name, value)); + } + (0, command_1.issueCommand)('save-state', { name }, (0, utils_1.toCommandValue)(value)); +} +/** + * Gets the value of an state set by this action's main execution. + * + * @param name name of the state to get + * @returns string + */ +function getState(name) { + return process.env[`STATE_${name}`] || ''; +} +function getIDToken(aud) { + return __awaiter(this, void 0, void 0, function* () { + return yield oidc_utils_1.OidcClient.getIDToken(aud); }); - return parts.join('/'); - }, - - urlParse: function urlParse(url) { - return util.url.parse(url); - }, +} +/** + * Summary exports + */ +var summary_1 = __nccwpck_require__(1847); +Object.defineProperty(exports, "summary", ({ enumerable: true, get: function () { return summary_1.summary; } })); +/** + * @deprecated use core.summary + */ +var summary_2 = __nccwpck_require__(1847); +Object.defineProperty(exports, "markdownSummary", ({ enumerable: true, get: function () { return summary_2.markdownSummary; } })); +/** + * Path exports + */ +var path_utils_1 = __nccwpck_require__(1976); +Object.defineProperty(exports, "toPosixPath", ({ enumerable: true, get: function () { return path_utils_1.toPosixPath; } })); +Object.defineProperty(exports, "toWin32Path", ({ enumerable: true, get: function () { return path_utils_1.toWin32Path; } })); +Object.defineProperty(exports, "toPlatformPath", ({ enumerable: true, get: function () { return path_utils_1.toPlatformPath; } })); +/** + * Platform utilities exports + */ +exports.platform = __importStar(__nccwpck_require__(8968)); +//# sourceMappingURL=core.js.map - urlFormat: function urlFormat(url) { - return util.url.format(url); - }, +/***/ }), - queryStringParse: function queryStringParse(qs) { - return util.querystring.parse(qs); - }, +/***/ 4753: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - queryParamsToString: function queryParamsToString(params) { - var items = []; - var escape = util.uriEscape; - var sortedKeys = Object.keys(params).sort(); +"use strict"; - util.arrayEach(sortedKeys, function(name) { - var value = params[name]; - var ename = escape(name); - var result = ename + '='; - if (Array.isArray(value)) { - var vals = []; - util.arrayEach(value, function(item) { vals.push(escape(item)); }); - result = ename + '=' + vals.sort().join('&' + ename + '='); - } else if (value !== undefined && value !== null) { - result = ename + '=' + escape(value); - } - items.push(result); +// For internal use, subject to change. +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 })); +exports.issueFileCommand = issueFileCommand; +exports.prepareKeyValueMessage = prepareKeyValueMessage; +// We use any as a valid input type +/* eslint-disable @typescript-eslint/no-explicit-any */ +const crypto = __importStar(__nccwpck_require__(6982)); +const fs = __importStar(__nccwpck_require__(9896)); +const os = __importStar(__nccwpck_require__(857)); +const utils_1 = __nccwpck_require__(302); +function issueFileCommand(command, message) { + const filePath = process.env[`GITHUB_${command}`]; + if (!filePath) { + throw new Error(`Unable to find environment variable for file command ${command}`); + } + if (!fs.existsSync(filePath)) { + throw new Error(`Missing file at path: ${filePath}`); + } + fs.appendFileSync(filePath, `${(0, utils_1.toCommandValue)(message)}${os.EOL}`, { + encoding: 'utf8' }); +} +function prepareKeyValueMessage(key, value) { + const delimiter = `ghadelimiter_${crypto.randomUUID()}`; + const convertedValue = (0, utils_1.toCommandValue)(value); + // These should realistically never happen, but just in case someone finds a + // way to exploit uuid generation let's not allow keys or values that contain + // the delimiter. + if (key.includes(delimiter)) { + throw new Error(`Unexpected input: name should not contain the delimiter "${delimiter}"`); + } + if (convertedValue.includes(delimiter)) { + throw new Error(`Unexpected input: value should not contain the delimiter "${delimiter}"`); + } + return `${key}<<${delimiter}${os.EOL}${convertedValue}${os.EOL}${delimiter}`; +} +//# sourceMappingURL=file-command.js.map - return items.join('&'); - }, - - readFileSync: function readFileSync(path) { - if (util.isBrowser()) return null; - return __webpack_require__(5747).readFileSync(path, 'utf-8'); - }, - - base64: { - encode: function encode64(string) { - if (typeof string === 'number') { - throw util.error(new Error('Cannot base64 encode number ' + string)); - } - if (string === null || typeof string === 'undefined') { - return string; - } - var buf = util.buffer.toBuffer(string); - return buf.toString('base64'); - }, +/***/ }), - decode: function decode64(string) { - if (typeof string === 'number') { - throw util.error(new Error('Cannot base64 decode number ' + string)); - } - if (string === null || typeof string === 'undefined') { - return string; - } - return util.buffer.toBuffer(string, 'base64'); - } +/***/ 5306: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - }, +"use strict"; - buffer: { - /** - * Buffer constructor for Node buffer and buffer pollyfill - */ - toBuffer: function(data, encoding) { - return (typeof util.Buffer.from === 'function' && util.Buffer.from !== Uint8Array.from) ? - util.Buffer.from(data, encoding) : new util.Buffer(data, encoding); - }, - - alloc: function(size, fill, encoding) { - if (typeof size !== 'number') { - throw new Error('size passed to alloc must be a number.'); - } - if (typeof util.Buffer.alloc === 'function') { - return util.Buffer.alloc(size, fill, encoding); - } else { - var buf = new util.Buffer(size); - if (fill !== undefined && typeof buf.fill === 'function') { - buf.fill(fill, undefined, undefined, encoding); +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.OidcClient = void 0; +const http_client_1 = __nccwpck_require__(4844); +const auth_1 = __nccwpck_require__(4552); +const core_1 = __nccwpck_require__(7484); +class OidcClient { + static createHttpClient(allowRetry = true, maxRetry = 10) { + const requestOptions = { + allowRetries: allowRetry, + maxRetries: maxRetry + }; + return new http_client_1.HttpClient('actions/oidc-client', [new auth_1.BearerCredentialHandler(OidcClient.getRequestToken())], requestOptions); + } + static getRequestToken() { + const token = process.env['ACTIONS_ID_TOKEN_REQUEST_TOKEN']; + if (!token) { + throw new Error('Unable to get ACTIONS_ID_TOKEN_REQUEST_TOKEN env variable'); } - return buf; - } - }, - - toStream: function toStream(buffer) { - if (!util.Buffer.isBuffer(buffer)) buffer = util.buffer.toBuffer(buffer); + return token; + } + static getIDTokenUrl() { + const runtimeUrl = process.env['ACTIONS_ID_TOKEN_REQUEST_URL']; + if (!runtimeUrl) { + throw new Error('Unable to get ACTIONS_ID_TOKEN_REQUEST_URL env variable'); + } + return runtimeUrl; + } + static getCall(id_token_url) { + return __awaiter(this, void 0, void 0, function* () { + var _a; + const httpclient = OidcClient.createHttpClient(); + const res = yield httpclient + .getJson(id_token_url) + .catch(error => { + throw new Error(`Failed to get ID Token. \n + Error Code : ${error.statusCode}\n + Error Message: ${error.message}`); + }); + const id_token = (_a = res.result) === null || _a === void 0 ? void 0 : _a.value; + if (!id_token) { + throw new Error('Response json body do not have ID Token field'); + } + return id_token; + }); + } + static getIDToken(audience) { + return __awaiter(this, void 0, void 0, function* () { + try { + // New ID Token is requested from action service + let id_token_url = OidcClient.getIDTokenUrl(); + if (audience) { + const encodedAudience = encodeURIComponent(audience); + id_token_url = `${id_token_url}&audience=${encodedAudience}`; + } + (0, core_1.debug)(`ID token url is ${id_token_url}`); + const id_token = yield OidcClient.getCall(id_token_url); + (0, core_1.setSecret)(id_token); + return id_token; + } + catch (error) { + throw new Error(`Error message: ${error.message}`); + } + }); + } +} +exports.OidcClient = OidcClient; +//# sourceMappingURL=oidc-utils.js.map - var readable = new (util.stream.Readable)(); - var pos = 0; - readable._read = function(size) { - if (pos >= buffer.length) return readable.push(null); +/***/ }), - var end = pos + size; - if (end > buffer.length) end = buffer.length; - readable.push(buffer.slice(pos, end)); - pos = end; - }; +/***/ 1976: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - return readable; - }, +"use strict"; - /** - * Concatenates a list of Buffer objects. - */ - concat: function(buffers) { - var length = 0, - offset = 0, - buffer = null, i; +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 })); +exports.toPosixPath = toPosixPath; +exports.toWin32Path = toWin32Path; +exports.toPlatformPath = toPlatformPath; +const path = __importStar(__nccwpck_require__(6928)); +/** + * toPosixPath converts the given path to the posix form. On Windows, \\ will be + * replaced with /. + * + * @param pth. Path to transform. + * @return string Posix path. + */ +function toPosixPath(pth) { + return pth.replace(/[\\]/g, '/'); +} +/** + * toWin32Path converts the given path to the win32 form. On Linux, / will be + * replaced with \\. + * + * @param pth. Path to transform. + * @return string Win32 path. + */ +function toWin32Path(pth) { + return pth.replace(/[/]/g, '\\'); +} +/** + * toPlatformPath converts the given path to a platform-specific path. It does + * this by replacing instances of / and \ with the platform-specific path + * separator. + * + * @param pth The path to platformize. + * @return string The platform-specific path. + */ +function toPlatformPath(pth) { + return pth.replace(/[/\\]/g, path.sep); +} +//# sourceMappingURL=path-utils.js.map - for (i = 0; i < buffers.length; i++) { - length += buffers[i].length; - } +/***/ }), - buffer = util.buffer.alloc(length); +/***/ 8968: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - for (i = 0; i < buffers.length; i++) { - buffers[i].copy(buffer, offset); - offset += buffers[i].length; - } +"use strict"; - return buffer; +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]; } }; } - }, - - string: { - byteLength: function byteLength(string) { - if (string === null || string === undefined) return 0; - if (typeof string === 'string') string = util.buffer.toBuffer(string); - - if (typeof string.byteLength === 'number') { - return string.byteLength; - } else if (typeof string.length === 'number') { - return string.length; - } else if (typeof string.size === 'number') { - return string.size; - } else if (typeof string.path === 'string') { - return __webpack_require__(5747).lstatSync(string.path).size; - } else { - throw util.error(new Error('Cannot determine length of ' + string), - { object: string }); - } - }, + 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; + }; +})(); +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.isLinux = exports.isMacOS = exports.isWindows = exports.arch = exports.platform = void 0; +exports.getDetails = getDetails; +const os_1 = __importDefault(__nccwpck_require__(857)); +const exec = __importStar(__nccwpck_require__(5236)); +const getWindowsInfo = () => __awaiter(void 0, void 0, void 0, function* () { + const { stdout: version } = yield exec.getExecOutput('powershell -command "(Get-CimInstance -ClassName Win32_OperatingSystem).Version"', undefined, { + silent: true + }); + const { stdout: name } = yield exec.getExecOutput('powershell -command "(Get-CimInstance -ClassName Win32_OperatingSystem).Caption"', undefined, { + silent: true + }); + return { + name: name.trim(), + version: version.trim() + }; +}); +const getMacOsInfo = () => __awaiter(void 0, void 0, void 0, function* () { + var _a, _b, _c, _d; + const { stdout } = yield exec.getExecOutput('sw_vers', undefined, { + silent: true + }); + const version = (_b = (_a = stdout.match(/ProductVersion:\s*(.+)/)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : ''; + const name = (_d = (_c = stdout.match(/ProductName:\s*(.+)/)) === null || _c === void 0 ? void 0 : _c[1]) !== null && _d !== void 0 ? _d : ''; + return { + name, + version + }; +}); +const getLinuxInfo = () => __awaiter(void 0, void 0, void 0, function* () { + const { stdout } = yield exec.getExecOutput('lsb_release', ['-i', '-r', '-s'], { + silent: true + }); + const [name, version] = stdout.trim().split('\n'); + return { + name, + version + }; +}); +exports.platform = os_1.default.platform(); +exports.arch = os_1.default.arch(); +exports.isWindows = exports.platform === 'win32'; +exports.isMacOS = exports.platform === 'darwin'; +exports.isLinux = exports.platform === 'linux'; +function getDetails() { + return __awaiter(this, void 0, void 0, function* () { + return Object.assign(Object.assign({}, (yield (exports.isWindows + ? getWindowsInfo() + : exports.isMacOS + ? getMacOsInfo() + : getLinuxInfo()))), { platform: exports.platform, + arch: exports.arch, + isWindows: exports.isWindows, + isMacOS: exports.isMacOS, + isLinux: exports.isLinux }); + }); +} +//# sourceMappingURL=platform.js.map - upperFirst: function upperFirst(string) { - return string[0].toUpperCase() + string.substr(1); - }, +/***/ }), - lowerFirst: function lowerFirst(string) { - return string[0].toLowerCase() + string.substr(1); - } - }, +/***/ 1847: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - ini: { - parse: function string(ini) { - var currentSection, map = {}; - util.arrayEach(ini.split(/\r?\n/), function(line) { - line = line.split(/(^|\s)[;#]/)[0]; // remove comments - var section = line.match(/^\s*\[([^\[\]]+)\]\s*$/); - if (section) { - currentSection = section[1]; - } else if (currentSection) { - var item = line.match(/^\s*(.+?)\s*=\s*(.+?)\s*$/); - if (item) { - map[currentSection] = map[currentSection] || {}; - map[currentSection][item[1]] = item[2]; - } - } - }); +"use strict"; - return map; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.summary = exports.markdownSummary = exports.SUMMARY_DOCS_URL = exports.SUMMARY_ENV_VAR = void 0; +const os_1 = __nccwpck_require__(857); +const fs_1 = __nccwpck_require__(9896); +const { access, appendFile, writeFile } = fs_1.promises; +exports.SUMMARY_ENV_VAR = 'GITHUB_STEP_SUMMARY'; +exports.SUMMARY_DOCS_URL = 'https://docs.github.com/actions/using-workflows/workflow-commands-for-github-actions#adding-a-job-summary'; +class Summary { + constructor() { + this._buffer = ''; } - }, - - fn: { - noop: function() {}, - callback: function (err) { if (err) throw err; }, - /** - * Turn a synchronous function into as "async" function by making it call - * a callback. The underlying function is called with all but the last argument, - * which is treated as the callback. The callback is passed passed a first argument - * of null on success to mimick standard node callbacks. + * Finds the summary file path from the environment, rejects if env var is not found or file does not exist + * Also checks r/w permissions. + * + * @returns step summary file path */ - makeAsync: function makeAsync(fn, expectedArgs) { - if (expectedArgs && expectedArgs <= fn.length) { - return fn; - } - - return function() { - var args = Array.prototype.slice.call(arguments, 0); - var callback = args.pop(); - var result = fn.apply(null, args); - callback(result); - }; + filePath() { + return __awaiter(this, void 0, void 0, function* () { + if (this._filePath) { + return this._filePath; + } + const pathFromEnv = process.env[exports.SUMMARY_ENV_VAR]; + if (!pathFromEnv) { + throw new Error(`Unable to find environment variable for $${exports.SUMMARY_ENV_VAR}. Check if your runtime environment supports job summaries.`); + } + try { + yield access(pathFromEnv, fs_1.constants.R_OK | fs_1.constants.W_OK); + } + catch (_a) { + throw new Error(`Unable to access summary file: '${pathFromEnv}'. Check if the file has correct read/write permissions.`); + } + this._filePath = pathFromEnv; + return this._filePath; + }); } - }, - - /** - * Date and time utility functions. - */ - date: { - /** - * @return [Date] the current JavaScript date object. Since all - * AWS services rely on this date object, you can override - * this function to provide a special time value to AWS service - * requests. + * Wraps content in an HTML tag, adding any HTML attributes + * + * @param {string} tag HTML tag to wrap + * @param {string | null} content content within the tag + * @param {[attribute: string]: string} attrs key-value list of HTML attributes to add + * + * @returns {string} content wrapped in HTML element */ - getDate: function getDate() { - if (!AWS) AWS = __webpack_require__(395); - if (AWS.config.systemClockOffset) { // use offset when non-zero - return new Date(new Date().getTime() + AWS.config.systemClockOffset); - } else { - return new Date(); - } - }, - + wrap(tag, content, attrs = {}) { + const htmlAttrs = Object.entries(attrs) + .map(([key, value]) => ` ${key}="${value}"`) + .join(''); + if (!content) { + return `<${tag}${htmlAttrs}>`; + } + return `<${tag}${htmlAttrs}>${content}`; + } /** - * @return [String] the date in ISO-8601 format + * Writes text in the buffer to the summary buffer file and empties buffer. Will append by default. + * + * @param {SummaryWriteOptions} [options] (optional) options for write operation + * + * @returns {Promise} summary instance */ - iso8601: function iso8601(date) { - if (date === undefined) { date = util.date.getDate(); } - return date.toISOString().replace(/\.\d{3}Z$/, 'Z'); - }, - + write(options) { + return __awaiter(this, void 0, void 0, function* () { + const overwrite = !!(options === null || options === void 0 ? void 0 : options.overwrite); + const filePath = yield this.filePath(); + const writeFunc = overwrite ? writeFile : appendFile; + yield writeFunc(filePath, this._buffer, { encoding: 'utf8' }); + return this.emptyBuffer(); + }); + } /** - * @return [String] the date in RFC 822 format + * Clears the summary buffer and wipes the summary file + * + * @returns {Summary} summary instance */ - rfc822: function rfc822(date) { - if (date === undefined) { date = util.date.getDate(); } - return date.toUTCString(); - }, - + clear() { + return __awaiter(this, void 0, void 0, function* () { + return this.emptyBuffer().write({ overwrite: true }); + }); + } /** - * @return [Integer] the UNIX timestamp value for the current time + * Returns the current summary buffer as a string + * + * @returns {string} string of summary buffer */ - unixTimestamp: function unixTimestamp(date) { - if (date === undefined) { date = util.date.getDate(); } - return date.getTime() / 1000; - }, - + stringify() { + return this._buffer; + } /** - * @param [String,number,Date] date - * @return [Date] + * If the summary buffer is empty + * + * @returns {boolen} true if the buffer is empty */ - from: function format(date) { - if (typeof date === 'number') { - return new Date(date * 1000); // unix timestamp - } else { - return new Date(date); - } - }, - + isEmptyBuffer() { + return this._buffer.length === 0; + } /** - * Given a Date or date-like value, this function formats the - * date into a string of the requested value. - * @param [String,number,Date] date - * @param [String] formatter Valid formats are: - # * 'iso8601' - # * 'rfc822' - # * 'unixTimestamp' - * @return [String] + * Resets the summary buffer without writing to summary file + * + * @returns {Summary} summary instance */ - format: function format(date, formatter) { - if (!formatter) formatter = 'iso8601'; - return util.date[formatter](util.date.from(date)); - }, - - parseTimestamp: function parseTimestamp(value) { - if (typeof value === 'number') { // unix timestamp (number) - return new Date(value * 1000); - } else if (value.match(/^\d+$/)) { // unix timestamp - return new Date(value * 1000); - } else if (value.match(/^\d{4}/)) { // iso8601 - return new Date(value); - } else if (value.match(/^\w{3},/)) { // rfc822 - return new Date(value); - } else { - throw util.error( - new Error('unhandled timestamp format: ' + value), - {code: 'TimestampParserError'}); - } + emptyBuffer() { + this._buffer = ''; + return this; } - - }, - - crypto: { - crc32Table: [ - 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, - 0x706AF48F, 0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, - 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, - 0x90BF1D91, 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, - 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856, - 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, - 0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4, - 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, - 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, - 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 0x26D930AC, 0x51DE003A, - 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, - 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, - 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190, - 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, - 0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2, 0x0F00F934, 0x9609A88E, - 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, - 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, - 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950, - 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, - 0xFBD44C65, 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, - 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A, - 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, - 0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA, 0xBE0B1010, - 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, - 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, - 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, - 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, - 0x73DC1683, 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, - 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 0xF00F9344, - 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, - 0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, - 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, - 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, - 0xA6BC5767, 0x3FB506DD, 0x48B2364B, 0xD80D2BDA, 0xAF0A1B4C, - 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, - 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, - 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE, - 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, - 0x2CD99E8B, 0x5BDEAE1D, 0x9B64C2B0, 0xEC63F226, 0x756AA39C, - 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, - 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, - 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242, - 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, - 0x18B74777, 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, - 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, 0xA00AE278, - 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, - 0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, - 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, - 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, - 0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, - 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, - 0x2D02EF8D], - - crc32: function crc32(data) { - var tbl = util.crypto.crc32Table; - var crc = 0 ^ -1; - - if (typeof data === 'string') { - data = util.buffer.toBuffer(data); - } - - for (var i = 0; i < data.length; i++) { - var code = data.readUInt8(i); - crc = (crc >>> 8) ^ tbl[(crc ^ code) & 0xFF]; - } - return (crc ^ -1) >>> 0; - }, - - hmac: function hmac(key, string, digest, fn) { - if (!digest) digest = 'binary'; - if (digest === 'buffer') { digest = undefined; } - if (!fn) fn = 'sha256'; - if (typeof string === 'string') string = util.buffer.toBuffer(string); - return util.crypto.lib.createHmac(fn, key).update(string).digest(digest); - }, - - md5: function md5(data, digest, callback) { - return util.crypto.hash('md5', data, digest, callback); - }, - - sha256: function sha256(data, digest, callback) { - return util.crypto.hash('sha256', data, digest, callback); - }, - - hash: function(algorithm, data, digest, callback) { - var hash = util.crypto.createHash(algorithm); - if (!digest) { digest = 'binary'; } - if (digest === 'buffer') { digest = undefined; } - if (typeof data === 'string') data = util.buffer.toBuffer(data); - var sliceFn = util.arraySliceFn(data); - var isBuffer = util.Buffer.isBuffer(data); - //Identifying objects with an ArrayBuffer as buffers - if (util.isBrowser() && typeof ArrayBuffer !== 'undefined' && data && data.buffer instanceof ArrayBuffer) isBuffer = true; - - if (callback && typeof data === 'object' && - typeof data.on === 'function' && !isBuffer) { - data.on('data', function(chunk) { hash.update(chunk); }); - data.on('error', function(err) { callback(err); }); - data.on('end', function() { callback(null, hash.digest(digest)); }); - } else if (callback && sliceFn && !isBuffer && - typeof FileReader !== 'undefined') { - // this might be a File/Blob - var index = 0, size = 1024 * 512; - var reader = new FileReader(); - reader.onerror = function() { - callback(new Error('Failed to read data.')); - }; - reader.onload = function() { - var buf = new util.Buffer(new Uint8Array(reader.result)); - hash.update(buf); - index += buf.length; - reader._continueReading(); - }; - reader._continueReading = function() { - if (index >= data.size) { - callback(null, hash.digest(digest)); - return; - } - - var back = index + size; - if (back > data.size) back = data.size; - reader.readAsArrayBuffer(sliceFn.call(data, index, back)); - }; - - reader._continueReading(); - } else { - if (util.isBrowser() && typeof data === 'object' && !isBuffer) { - data = new util.Buffer(new Uint8Array(data)); - } - var out = hash.update(data).digest(digest); - if (callback) callback(null, out); - return out; - } - }, - - toHex: function toHex(data) { - var out = []; - for (var i = 0; i < data.length; i++) { - out.push(('0' + data.charCodeAt(i).toString(16)).substr(-2, 2)); - } - return out.join(''); - }, - - createHash: function createHash(algorithm) { - return util.crypto.lib.createHash(algorithm); + /** + * Adds raw text to the summary buffer + * + * @param {string} text content to add + * @param {boolean} [addEOL=false] (optional) append an EOL to the raw text (default: false) + * + * @returns {Summary} summary instance + */ + addRaw(text, addEOL = false) { + this._buffer += text; + return addEOL ? this.addEOL() : this; } - - }, - - /** @!ignore */ - - /* Abort constant */ - abort: {}, - - each: function each(object, iterFunction) { - for (var key in object) { - if (Object.prototype.hasOwnProperty.call(object, key)) { - var ret = iterFunction.call(this, key, object[key]); - if (ret === util.abort) break; - } + /** + * Adds the operating system-specific end-of-line marker to the buffer + * + * @returns {Summary} summary instance + */ + addEOL() { + return this.addRaw(os_1.EOL); } - }, - - arrayEach: function arrayEach(array, iterFunction) { - for (var idx in array) { - if (Object.prototype.hasOwnProperty.call(array, idx)) { - var ret = iterFunction.call(this, array[idx], parseInt(idx, 10)); - if (ret === util.abort) break; - } + /** + * Adds an HTML codeblock to the summary buffer + * + * @param {string} code content to render within fenced code block + * @param {string} lang (optional) language to syntax highlight code + * + * @returns {Summary} summary instance + */ + addCodeBlock(code, lang) { + const attrs = Object.assign({}, (lang && { lang })); + const element = this.wrap('pre', this.wrap('code', code), attrs); + return this.addRaw(element).addEOL(); } - }, - - update: function update(obj1, obj2) { - util.each(obj2, function iterator(key, item) { - obj1[key] = item; - }); - return obj1; - }, - - merge: function merge(obj1, obj2) { - return util.update(util.copy(obj1), obj2); - }, - - copy: function copy(object) { - if (object === null || object === undefined) return object; - var dupe = {}; - // jshint forin:false - for (var key in object) { - dupe[key] = object[key]; + /** + * Adds an HTML list to the summary buffer + * + * @param {string[]} items list of items to render + * @param {boolean} [ordered=false] (optional) if the rendered list should be ordered or not (default: false) + * + * @returns {Summary} summary instance + */ + addList(items, ordered = false) { + const tag = ordered ? 'ol' : 'ul'; + const listItems = items.map(item => this.wrap('li', item)).join(''); + const element = this.wrap(tag, listItems); + return this.addRaw(element).addEOL(); } - return dupe; - }, - - isEmpty: function isEmpty(obj) { - for (var prop in obj) { - if (Object.prototype.hasOwnProperty.call(obj, prop)) { - return false; - } + /** + * Adds an HTML table to the summary buffer + * + * @param {SummaryTableCell[]} rows table rows + * + * @returns {Summary} summary instance + */ + addTable(rows) { + const tableBody = rows + .map(row => { + const cells = row + .map(cell => { + if (typeof cell === 'string') { + return this.wrap('td', cell); + } + const { header, data, colspan, rowspan } = cell; + const tag = header ? 'th' : 'td'; + const attrs = Object.assign(Object.assign({}, (colspan && { colspan })), (rowspan && { rowspan })); + return this.wrap(tag, data, attrs); + }) + .join(''); + return this.wrap('tr', cells); + }) + .join(''); + const element = this.wrap('table', tableBody); + return this.addRaw(element).addEOL(); } - return true; - }, - - arraySliceFn: function arraySliceFn(obj) { - var fn = obj.slice || obj.webkitSlice || obj.mozSlice; - return typeof fn === 'function' ? fn : null; - }, - - isType: function isType(obj, type) { - // handle cross-"frame" objects - if (typeof type === 'function') type = util.typeName(type); - return Object.prototype.toString.call(obj) === '[object ' + type + ']'; - }, - - typeName: function typeName(type) { - if (Object.prototype.hasOwnProperty.call(type, 'name')) return type.name; - var str = type.toString(); - var match = str.match(/^\s*function (.+)\(/); - return match ? match[1] : str; - }, - - error: function error(err, options) { - var originalError = null; - if (typeof err.message === 'string' && err.message !== '') { - if (typeof options === 'string' || (options && options.message)) { - originalError = util.copy(err); - originalError.message = err.message; - } - } - err.message = err.message || null; - - if (typeof options === 'string') { - err.message = options; - } else if (typeof options === 'object' && options !== null) { - util.update(err, options); - if (options.message) - err.message = options.message; - if (options.code || options.name) - err.code = options.code || options.name; - if (options.stack) - err.stack = options.stack; - } - - if (typeof Object.defineProperty === 'function') { - Object.defineProperty(err, 'name', {writable: true, enumerable: false}); - Object.defineProperty(err, 'message', {enumerable: true}); - } - - err.name = String(options && options.name || err.name || err.code || 'Error'); - err.time = new Date(); - - if (originalError) err.originalError = originalError; - - return err; - }, - - /** - * @api private - */ - inherit: function inherit(klass, features) { - var newObject = null; - if (features === undefined) { - features = klass; - klass = Object; - newObject = {}; - } else { - var ctor = function ConstructorWrapper() {}; - ctor.prototype = klass.prototype; - newObject = new ctor(); - } - - // constructor not supplied, create pass-through ctor - if (features.constructor === Object) { - features.constructor = function() { - if (klass !== Object) { - return klass.apply(this, arguments); - } - }; - } - - features.constructor.prototype = newObject; - util.update(features.constructor.prototype, features); - features.constructor.__super__ = klass; - return features.constructor; - }, - - /** - * @api private - */ - mixin: function mixin() { - var klass = arguments[0]; - for (var i = 1; i < arguments.length; i++) { - // jshint forin:false - for (var prop in arguments[i].prototype) { - var fn = arguments[i].prototype[prop]; - if (prop !== 'constructor') { - klass.prototype[prop] = fn; - } - } - } - return klass; - }, - - /** - * @api private - */ - hideProperties: function hideProperties(obj, props) { - if (typeof Object.defineProperty !== 'function') return; - - util.arrayEach(props, function (key) { - Object.defineProperty(obj, key, { - enumerable: false, writable: true, configurable: true }); - }); - }, - - /** - * @api private - */ - property: function property(obj, name, value, enumerable, isValue) { - var opts = { - configurable: true, - enumerable: enumerable !== undefined ? enumerable : true - }; - if (typeof value === 'function' && !isValue) { - opts.get = value; - } - else { - opts.value = value; opts.writable = true; - } - - Object.defineProperty(obj, name, opts); - }, - - /** - * @api private - */ - memoizedProperty: function memoizedProperty(obj, name, get, enumerable) { - var cachedValue = null; - - // build enumerable attribute for each value with lazy accessor. - util.property(obj, name, function() { - if (cachedValue === null) { - cachedValue = get(); - } - return cachedValue; - }, enumerable); - }, - - /** - * TODO Remove in major version revision - * This backfill populates response data without the - * top-level payload name. - * - * @api private - */ - hoistPayloadMember: function hoistPayloadMember(resp) { - var req = resp.request; - var operationName = req.operation; - var operation = req.service.api.operations[operationName]; - var output = operation.output; - if (output.payload && !operation.hasEventOutput) { - var payloadMember = output.members[output.payload]; - var responsePayload = resp.data[output.payload]; - if (payloadMember.type === 'structure') { - util.each(responsePayload, function(key, value) { - util.property(resp.data, key, value, false); - }); - } - } - }, - - /** - * Compute SHA-256 checksums of streams - * - * @api private - */ - computeSha256: function computeSha256(body, done) { - if (util.isNode()) { - var Stream = util.stream.Stream; - var fs = __webpack_require__(5747); - if (typeof Stream === 'function' && body instanceof Stream) { - if (typeof body.path === 'string') { // assume file object - var settings = {}; - if (typeof body.start === 'number') { - settings.start = body.start; - } - if (typeof body.end === 'number') { - settings.end = body.end; - } - body = fs.createReadStream(body.path, settings); - } else { // TODO support other stream types - return done(new Error('Non-file stream objects are ' + - 'not supported with SigV4')); - } - } - } - - util.crypto.sha256(body, 'hex', function(err, sha) { - if (err) done(err); - else done(null, sha); - }); - }, - - /** - * @api private - */ - isClockSkewed: function isClockSkewed(serverTime) { - if (serverTime) { - util.property(AWS.config, 'isClockSkewed', - Math.abs(new Date().getTime() - serverTime) >= 300000, false); - return AWS.config.isClockSkewed; - } - }, - - applyClockOffset: function applyClockOffset(serverTime) { - if (serverTime) - AWS.config.systemClockOffset = serverTime - new Date().getTime(); - }, - - /** - * @api private - */ - extractRequestId: function extractRequestId(resp) { - var requestId = resp.httpResponse.headers['x-amz-request-id'] || - resp.httpResponse.headers['x-amzn-requestid']; - - if (!requestId && resp.data && resp.data.ResponseMetadata) { - requestId = resp.data.ResponseMetadata.RequestId; + /** + * Adds a collapsable HTML details element to the summary buffer + * + * @param {string} label text for the closed state + * @param {string} content collapsable content + * + * @returns {Summary} summary instance + */ + addDetails(label, content) { + const element = this.wrap('details', this.wrap('summary', label) + content); + return this.addRaw(element).addEOL(); } - - if (requestId) { - resp.requestId = requestId; + /** + * Adds an HTML image tag to the summary buffer + * + * @param {string} src path to the image you to embed + * @param {string} alt text description of the image + * @param {SummaryImageOptions} options (optional) addition image attributes + * + * @returns {Summary} summary instance + */ + addImage(src, alt, options) { + const { width, height } = options || {}; + const attrs = Object.assign(Object.assign({}, (width && { width })), (height && { height })); + const element = this.wrap('img', null, Object.assign({ src, alt }, attrs)); + return this.addRaw(element).addEOL(); } - - if (resp.error) { - resp.error.requestId = requestId; + /** + * Adds an HTML section heading element + * + * @param {string} text heading text + * @param {number | string} [level=1] (optional) the heading level, default: 1 + * + * @returns {Summary} summary instance + */ + addHeading(text, level) { + const tag = `h${level}`; + const allowedTag = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'].includes(tag) + ? tag + : 'h1'; + const element = this.wrap(allowedTag, text); + return this.addRaw(element).addEOL(); } - }, - - /** - * @api private - */ - addPromises: function addPromises(constructors, PromiseDependency) { - var deletePromises = false; - if (PromiseDependency === undefined && AWS && AWS.config) { - PromiseDependency = AWS.config.getPromisesDependency(); + /** + * Adds an HTML thematic break (
) to the summary buffer + * + * @returns {Summary} summary instance + */ + addSeparator() { + const element = this.wrap('hr', null); + return this.addRaw(element).addEOL(); } - if (PromiseDependency === undefined && typeof Promise !== 'undefined') { - PromiseDependency = Promise; + /** + * Adds an HTML line break (
) to the summary buffer + * + * @returns {Summary} summary instance + */ + addBreak() { + const element = this.wrap('br', null); + return this.addRaw(element).addEOL(); } - if (typeof PromiseDependency !== 'function') deletePromises = true; - if (!Array.isArray(constructors)) constructors = [constructors]; - - for (var ind = 0; ind < constructors.length; ind++) { - var constructor = constructors[ind]; - if (deletePromises) { - if (constructor.deletePromisesFromClass) { - constructor.deletePromisesFromClass(); - } - } else if (constructor.addPromisesToClass) { - constructor.addPromisesToClass(PromiseDependency); - } + /** + * Adds an HTML blockquote to the summary buffer + * + * @param {string} text quote text + * @param {string} cite (optional) citation url + * + * @returns {Summary} summary instance + */ + addQuote(text, cite) { + const attrs = Object.assign({}, (cite && { cite })); + const element = this.wrap('blockquote', text, attrs); + return this.addRaw(element).addEOL(); } - }, - - /** - * @api private - * Return a function that will return a promise whose fate is decided by the - * callback behavior of the given method with `methodName`. The method to be - * promisified should conform to node.js convention of accepting a callback as - * last argument and calling that callback with error as the first argument - * and success value on the second argument. - */ - promisifyMethod: function promisifyMethod(methodName, PromiseDependency) { - return function promise() { - var self = this; - var args = Array.prototype.slice.call(arguments); - return new PromiseDependency(function(resolve, reject) { - args.push(function(err, data) { - if (err) { - reject(err); - } else { - resolve(data); - } - }); - self[methodName].apply(self, args); - }); - }; - }, - - /** - * @api private - */ - isDualstackAvailable: function isDualstackAvailable(service) { - if (!service) return false; - var metadata = __webpack_require__(1694); - if (typeof service !== 'string') service = service.serviceIdentifier; - if (typeof service !== 'string' || !metadata.hasOwnProperty(service)) return false; - return !!metadata[service].dualstackAvailable; - }, - - /** - * @api private - */ - calculateRetryDelay: function calculateRetryDelay(retryCount, retryDelayOptions, err) { - if (!retryDelayOptions) retryDelayOptions = {}; - var customBackoff = retryDelayOptions.customBackoff || null; - if (typeof customBackoff === 'function') { - return customBackoff(retryCount, err); - } - var base = typeof retryDelayOptions.base === 'number' ? retryDelayOptions.base : 100; - var delay = Math.random() * (Math.pow(2, retryCount) * base); - return delay; - }, - - /** - * @api private - */ - handleRequestWithRetries: function handleRequestWithRetries(httpRequest, options, cb) { - if (!options) options = {}; - var http = AWS.HttpClient.getInstance(); - var httpOptions = options.httpOptions || {}; - var retryCount = 0; - - var errCallback = function(err) { - var maxRetries = options.maxRetries || 0; - if (err && err.code === 'TimeoutError') err.retryable = true; - var delay = util.calculateRetryDelay(retryCount, options.retryDelayOptions, err); - if (err && err.retryable && retryCount < maxRetries && delay >= 0) { - retryCount++; - setTimeout(sendRequest, delay + (err.retryAfter || 0)); - } else { - cb(err); - } - }; - - var sendRequest = function() { - var data = ''; - http.handleRequest(httpRequest, httpOptions, function(httpResponse) { - httpResponse.on('data', function(chunk) { data += chunk.toString(); }); - httpResponse.on('end', function() { - var statusCode = httpResponse.statusCode; - if (statusCode < 300) { - cb(null, data); - } else { - var retryAfter = parseInt(httpResponse.headers['retry-after'], 10) * 1000 || 0; - var err = util.error(new Error(), - { - statusCode: statusCode, - retryable: statusCode >= 500 || statusCode === 429 - } - ); - if (retryAfter && err.retryable) err.retryAfter = retryAfter; - errCallback(err); - } - }); - }, errCallback); - }; - - AWS.util.defer(sendRequest); - }, - - /** - * @api private - */ - uuid: { - v4: function uuidV4() { - return __webpack_require__(6898).v4(); + /** + * Adds an HTML anchor tag to the summary buffer + * + * @param {string} text link text/content + * @param {string} href hyperlink + * + * @returns {Summary} summary instance + */ + addLink(text, href) { + const element = this.wrap('a', text, { href }); + return this.addRaw(element).addEOL(); } - }, +} +const _summary = new Summary(); +/** + * @deprecated use `core.summary` + */ +exports.markdownSummary = _summary; +exports.summary = _summary; +//# sourceMappingURL=summary.js.map - /** - * @api private - */ - convertPayloadToString: function convertPayloadToString(resp) { - var req = resp.request; - var operation = req.operation; - var rules = req.service.api.operations[operation].output || {}; - if (rules.payload && resp.data[rules.payload]) { - resp.data[rules.payload] = resp.data[rules.payload].toString(); - } - }, +/***/ }), - /** - * @api private - */ - defer: function defer(callback) { - if (typeof process === 'object' && typeof process.nextTick === 'function') { - process.nextTick(callback); - } else if (typeof setImmediate === 'function') { - setImmediate(callback); - } else { - setTimeout(callback, 0); - } - }, +/***/ 302: +/***/ ((__unused_webpack_module, exports) => { - /** - * @api private - */ - getRequestPayloadShape: function getRequestPayloadShape(req) { - var operations = req.service.api.operations; - if (!operations) return undefined; - var operation = (operations || {})[req.operation]; - if (!operation || !operation.input || !operation.input.payload) return undefined; - return operation.input.members[operation.input.payload]; - }, +"use strict"; - getProfilesFromSharedConfig: function getProfilesFromSharedConfig(iniLoader, filename) { - var profiles = {}; - var profilesFromConfig = {}; - if (process.env[util.configOptInEnv]) { - var profilesFromConfig = iniLoader.loadFrom({ - isConfig: true, - filename: process.env[util.sharedConfigFileEnv] - }); - } - var profilesFromCreds = iniLoader.loadFrom({ - filename: filename || - (process.env[util.configOptInEnv] && process.env[util.sharedCredentialsFileEnv]) - }); - for (var i = 0, profileNames = Object.keys(profilesFromConfig); i < profileNames.length; i++) { - profiles[profileNames[i]] = profilesFromConfig[profileNames[i]]; - } - for (var i = 0, profileNames = Object.keys(profilesFromCreds); i < profileNames.length; i++) { - profiles[profileNames[i]] = profilesFromCreds[profileNames[i]]; +// We use any as a valid input type +/* eslint-disable @typescript-eslint/no-explicit-any */ +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.toCommandValue = toCommandValue; +exports.toCommandProperties = toCommandProperties; +/** + * Sanitizes an input into a string so it can be passed into issueCommand safely + * @param input input to sanitize into a string + */ +function toCommandValue(input) { + if (input === null || input === undefined) { + return ''; } - return profiles; - }, - - /** - * @api private - */ - ARN: { - validate: function validateARN(str) { - return str && str.indexOf('arn:') === 0 && str.split(':').length >= 6; - }, - parse: function parseARN(arn) { - var matched = arn.split(':'); - return { - partition: matched[1], - service: matched[2], - region: matched[3], - accountId: matched[4], - resource: matched.slice(5).join(':') - }; - }, - build: function buildARN(arnObject) { - if ( - arnObject.service === undefined || - arnObject.region === undefined || - arnObject.accountId === undefined || - arnObject.resource === undefined - ) throw util.error(new Error('Input ARN object is invalid')); - return 'arn:'+ (arnObject.partition || 'aws') + ':' + arnObject.service + - ':' + arnObject.region + ':' + arnObject.accountId + ':' + arnObject.resource; + else if (typeof input === 'string' || input instanceof String) { + return input; } - }, - - /** - * @api private - */ - defaultProfile: 'default', - - /** - * @api private - */ - configOptInEnv: 'AWS_SDK_LOAD_CONFIG', - - /** - * @api private - */ - sharedCredentialsFileEnv: 'AWS_SHARED_CREDENTIALS_FILE', - - /** - * @api private - */ - sharedConfigFileEnv: 'AWS_CONFIG_FILE', - - /** - * @api private - */ - imdsDisabledEnv: 'AWS_EC2_METADATA_DISABLED' -}; - + return JSON.stringify(input); +} /** - * @api private + * + * @param annotationProperties + * @returns The command properties to send with the actual annotation command + * See IssueCommandProperties: https://github.com/actions/runner/blob/main/src/Runner.Worker/ActionCommandManager.cs#L646 */ -module.exports = util; - - -/***/ }), - -/***/ 155: -/***/ (function(module) { - -module.exports = {"version":2,"waiters":{"DistributionDeployed":{"delay":60,"operation":"GetDistribution","maxAttempts":25,"description":"Wait until a distribution is deployed.","acceptors":[{"expected":"Deployed","matcher":"path","state":"success","argument":"Distribution.Status"}]},"InvalidationCompleted":{"delay":20,"operation":"GetInvalidation","maxAttempts":30,"description":"Wait until an invalidation has completed.","acceptors":[{"expected":"Completed","matcher":"path","state":"success","argument":"Invalidation.Status"}]},"StreamingDistributionDeployed":{"delay":60,"operation":"GetStreamingDistribution","maxAttempts":25,"description":"Wait until a streaming distribution is deployed.","acceptors":[{"expected":"Deployed","matcher":"path","state":"success","argument":"StreamingDistribution.Status"}]}}}; - -/***/ }), - -/***/ 160: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['dlm'] = {}; -AWS.DLM = Service.defineService('dlm', ['2018-01-12']); -Object.defineProperty(apiLoader.services['dlm'], '2018-01-12', { - get: function get() { - var model = __webpack_require__(1890); - model.paginators = __webpack_require__(9459).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.DLM; - - -/***/ }), - -/***/ 170: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['applicationautoscaling'] = {}; -AWS.ApplicationAutoScaling = Service.defineService('applicationautoscaling', ['2016-02-06']); -Object.defineProperty(apiLoader.services['applicationautoscaling'], '2016-02-06', { - get: function get() { - var model = __webpack_require__(7359); - model.paginators = __webpack_require__(4666).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.ApplicationAutoScaling; - - -/***/ }), - -/***/ 184: -/***/ (function(module) { - -module.exports = {"pagination":{"DescribeAddresses":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Addresses"},"ListJobs":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"JobListEntries"}}}; +function toCommandProperties(annotationProperties) { + if (!Object.keys(annotationProperties).length) { + return {}; + } + return { + title: annotationProperties.title, + file: annotationProperties.file, + line: annotationProperties.startLine, + endLine: annotationProperties.endLine, + col: annotationProperties.startColumn, + endColumn: annotationProperties.endColumn + }; +} +//# sourceMappingURL=utils.js.map /***/ }), -/***/ 198: -/***/ (function(__unusedmodule, exports, __webpack_require__) { +/***/ 5236: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { "use strict"; var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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]; @@ -1446,13 +1230,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? ( }) : function(o, v) { o["default"] = v; }); -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); - __setModuleDefault(result, mod); - return result; -}; +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; + }; +})(); var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } return new (P || (P = Promise))(function (resolve, reject) { @@ -1462,16355 +1256,29890 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge step((generator = generator.apply(thisArg, _arguments || [])).next()); }); }; -Object.defineProperty(exports, "__esModule", { value: true }); -exports.run = void 0; -const path = __importStar(__webpack_require__(5622)); -const core = __importStar(__webpack_require__(6470)); -const aws = __importStar(__webpack_require__(9350)); -const fs = __importStar(__webpack_require__(5747)); -const deploy_1 = __webpack_require__(4253); -const utils_1 = __webpack_require__(6611); -// The custom client configuration for the CloudFormation clients. -const clientConfiguration = { - customUserAgent: 'aws-cloudformation-github-deploy-for-github-actions' -}; -function run() { +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.exec = exec; +exports.getExecOutput = getExecOutput; +const string_decoder_1 = __nccwpck_require__(3193); +const tr = __importStar(__nccwpck_require__(6665)); +/** + * Exec a command. + * Output will be streamed to the live console. + * Returns promise with return code + * + * @param commandLine command to execute (can include additional args). Must be correctly escaped. + * @param args optional arguments for tool. Escaping is handled by the lib. + * @param options optional exec options. See ExecOptions + * @returns Promise exit code + */ +function exec(commandLine, args, options) { + return __awaiter(this, void 0, void 0, function* () { + const commandArgs = tr.argStringToArray(commandLine); + if (commandArgs.length === 0) { + throw new Error(`Parameter 'commandLine' cannot be null or empty.`); + } + // Path to tool to execute should be first arg + const toolPath = commandArgs[0]; + args = commandArgs.slice(1).concat(args || []); + const runner = new tr.ToolRunner(toolPath, args, options); + return runner.exec(); + }); +} +/** + * Exec a command and get the output. + * Output will be streamed to the live console. + * Returns promise with the exit code and collected stdout and stderr + * + * @param commandLine command to execute (can include additional args). Must be correctly escaped. + * @param args optional arguments for tool. Escaping is handled by the lib. + * @param options optional exec options. See ExecOptions + * @returns Promise exit code, stdout, and stderr + */ +function getExecOutput(commandLine, args, options) { return __awaiter(this, void 0, void 0, function* () { + var _a, _b; + let stdout = ''; + let stderr = ''; + //Using string decoder covers the case where a mult-byte character is split + const stdoutDecoder = new string_decoder_1.StringDecoder('utf8'); + const stderrDecoder = new string_decoder_1.StringDecoder('utf8'); + const originalStdoutListener = (_a = options === null || options === void 0 ? void 0 : options.listeners) === null || _a === void 0 ? void 0 : _a.stdout; + const originalStdErrListener = (_b = options === null || options === void 0 ? void 0 : options.listeners) === null || _b === void 0 ? void 0 : _b.stderr; + const stdErrListener = (data) => { + stderr += stderrDecoder.write(data); + if (originalStdErrListener) { + originalStdErrListener(data); + } + }; + const stdOutListener = (data) => { + stdout += stdoutDecoder.write(data); + if (originalStdoutListener) { + originalStdoutListener(data); + } + }; + const listeners = Object.assign(Object.assign({}, options === null || options === void 0 ? void 0 : options.listeners), { stdout: stdOutListener, stderr: stdErrListener }); + const exitCode = yield exec(commandLine, args, Object.assign(Object.assign({}, options), { listeners })); + //flush any remaining characters + stdout += stdoutDecoder.end(); + stderr += stderrDecoder.end(); + return { + exitCode, + stdout, + stderr + }; + }); +} +//# sourceMappingURL=exec.js.map + +/***/ }), + +/***/ 6665: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"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; + }; +})(); +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ToolRunner = void 0; +exports.argStringToArray = argStringToArray; +const os = __importStar(__nccwpck_require__(857)); +const events = __importStar(__nccwpck_require__(4434)); +const child = __importStar(__nccwpck_require__(5317)); +const path = __importStar(__nccwpck_require__(6928)); +const io = __importStar(__nccwpck_require__(4994)); +const ioUtil = __importStar(__nccwpck_require__(5207)); +const timers_1 = __nccwpck_require__(3557); +/* eslint-disable @typescript-eslint/unbound-method */ +const IS_WINDOWS = process.platform === 'win32'; +/* + * Class for running command line tools. Handles quoting and arg parsing in a platform agnostic way. + */ +class ToolRunner extends events.EventEmitter { + constructor(toolPath, args, options) { + super(); + if (!toolPath) { + throw new Error("Parameter 'toolPath' cannot be null or empty."); + } + this.toolPath = toolPath; + this.args = args || []; + this.options = options || {}; + } + _debug(message) { + if (this.options.listeners && this.options.listeners.debug) { + this.options.listeners.debug(message); + } + } + _getCommandString(options, noPrefix) { + const toolPath = this._getSpawnFileName(); + const args = this._getSpawnArgs(options); + let cmd = noPrefix ? '' : '[command]'; // omit prefix when piped to a second tool + if (IS_WINDOWS) { + // Windows + cmd file + if (this._isCmdFile()) { + cmd += toolPath; + for (const a of args) { + cmd += ` ${a}`; + } + } + // Windows + verbatim + else if (options.windowsVerbatimArguments) { + cmd += `"${toolPath}"`; + for (const a of args) { + cmd += ` ${a}`; + } + } + // Windows (regular) + else { + cmd += this._windowsQuoteCmdArg(toolPath); + for (const a of args) { + cmd += ` ${this._windowsQuoteCmdArg(a)}`; + } + } + } + else { + // OSX/Linux - this can likely be improved with some form of quoting. + // creating processes on Unix is fundamentally different than Windows. + // on Unix, execvp() takes an arg array. + cmd += toolPath; + for (const a of args) { + cmd += ` ${a}`; + } + } + return cmd; + } + _processLineBuffer(data, strBuffer, onLine) { try { - const cfn = new aws.CloudFormation(Object.assign({}, clientConfiguration)); - const { GITHUB_WORKSPACE = __dirname } = process.env; - // Get inputs - const template = core.getInput('template', { required: true }); - const stackName = core.getInput('name', { required: true }); - const capabilities = core.getInput('capabilities', { - required: false - }); - const parametersFile = core.getInput('parameters-file', { - required: false - }); - const parameterOverrides = core.getInput('parameter-overrides', { - required: false - }); - const changesetPostfix = core.getInput('changeset-postfix', { - required: false - }); - const noEmptyChangeSet = !!+core.getInput('no-fail-on-empty-changeset', { - required: false - }); - const noExecuteChageSet = !!+core.getInput('no-execute-changeset', { - required: false - }); - const noDeleteFailedChangeSet = !!+core.getInput('no-delete-failed-changeset', { - required: false - }); - const disableRollback = !!+core.getInput('disable-rollback', { - required: false - }); - const timeoutInMinutes = utils_1.parseNumber(core.getInput('timeout-in-minutes', { - required: false - })); - const notificationARNs = utils_1.parseARNs(core.getInput('notification-arns', { - required: false - })); - const roleARN = utils_1.parseString(core.getInput('role-arn', { - required: false - })); - const tags = utils_1.parseTags(core.getInput('tags', { - required: false - })); - const terminationProtections = !!+core.getInput('termination-protection', { - required: false - }); - // Setup CloudFormation Stack - let templateBody; - let templateUrl; - if (utils_1.isUrl(template)) { - core.debug('Using CloudFormation Stack from Amazon S3 Bucket'); - templateUrl = template; + let s = strBuffer + data.toString(); + let n = s.indexOf(os.EOL); + while (n > -1) { + const line = s.substring(0, n); + onLine(line); + // the rest of the string ... + s = s.substring(n + os.EOL.length); + n = s.indexOf(os.EOL); + } + return s; + } + catch (err) { + // streaming lines to console is best effort. Don't fail a build. + this._debug(`error processing line. Failed with error ${err}`); + return ''; + } + } + _getSpawnFileName() { + if (IS_WINDOWS) { + if (this._isCmdFile()) { + return process.env['COMSPEC'] || 'cmd.exe'; + } + } + return this.toolPath; + } + _getSpawnArgs(options) { + if (IS_WINDOWS) { + if (this._isCmdFile()) { + let argline = `/D /S /C "${this._windowsQuoteCmdArg(this.toolPath)}`; + for (const a of this.args) { + argline += ' '; + argline += options.windowsVerbatimArguments + ? a + : this._windowsQuoteCmdArg(a); + } + argline += '"'; + return [argline]; + } + } + return this.args; + } + _endsWith(str, end) { + return str.endsWith(end); + } + _isCmdFile() { + const upperToolPath = this.toolPath.toUpperCase(); + return (this._endsWith(upperToolPath, '.CMD') || + this._endsWith(upperToolPath, '.BAT')); + } + _windowsQuoteCmdArg(arg) { + // for .exe, apply the normal quoting rules that libuv applies + if (!this._isCmdFile()) { + return this._uvQuoteCmdArg(arg); + } + // otherwise apply quoting rules specific to the cmd.exe command line parser. + // the libuv rules are generic and are not designed specifically for cmd.exe + // command line parser. + // + // for a detailed description of the cmd.exe command line parser, refer to + // http://stackoverflow.com/questions/4094699/how-does-the-windows-command-interpreter-cmd-exe-parse-scripts/7970912#7970912 + // need quotes for empty arg + if (!arg) { + return '""'; + } + // determine whether the arg needs to be quoted + const cmdSpecialChars = [ + ' ', + '\t', + '&', + '(', + ')', + '[', + ']', + '{', + '}', + '^', + '=', + ';', + '!', + "'", + '+', + ',', + '`', + '~', + '|', + '<', + '>', + '"' + ]; + let needsQuotes = false; + for (const char of arg) { + if (cmdSpecialChars.some(x => x === char)) { + needsQuotes = true; + break; + } + } + // short-circuit if quotes not needed + if (!needsQuotes) { + return arg; + } + // the following quoting rules are very similar to the rules that by libuv applies. + // + // 1) wrap the string in quotes + // + // 2) double-up quotes - i.e. " => "" + // + // this is different from the libuv quoting rules. libuv replaces " with \", which unfortunately + // doesn't work well with a cmd.exe command line. + // + // note, replacing " with "" also works well if the arg is passed to a downstream .NET console app. + // for example, the command line: + // foo.exe "myarg:""my val""" + // is parsed by a .NET console app into an arg array: + // [ "myarg:\"my val\"" ] + // which is the same end result when applying libuv quoting rules. although the actual + // command line from libuv quoting rules would look like: + // foo.exe "myarg:\"my val\"" + // + // 3) double-up slashes that precede a quote, + // e.g. hello \world => "hello \world" + // hello\"world => "hello\\""world" + // hello\\"world => "hello\\\\""world" + // hello world\ => "hello world\\" + // + // technically this is not required for a cmd.exe command line, or the batch argument parser. + // the reasons for including this as a .cmd quoting rule are: + // + // a) this is optimized for the scenario where the argument is passed from the .cmd file to an + // external program. many programs (e.g. .NET console apps) rely on the slash-doubling rule. + // + // b) it's what we've been doing previously (by deferring to node default behavior) and we + // haven't heard any complaints about that aspect. + // + // note, a weakness of the quoting rules chosen here, is that % is not escaped. in fact, % cannot be + // escaped when used on the command line directly - even though within a .cmd file % can be escaped + // by using %%. + // + // the saving grace is, on the command line, %var% is left as-is if var is not defined. this contrasts + // the line parsing rules within a .cmd file, where if var is not defined it is replaced with nothing. + // + // one option that was explored was replacing % with ^% - i.e. %var% => ^%var^%. this hack would + // often work, since it is unlikely that var^ would exist, and the ^ character is removed when the + // variable is used. the problem, however, is that ^ is not removed when %* is used to pass the args + // to an external program. + // + // an unexplored potential solution for the % escaping problem, is to create a wrapper .cmd file. + // % can be escaped within a .cmd file. + let reverse = '"'; + let quoteHit = true; + for (let i = arg.length; i > 0; i--) { + // walk the string in reverse + reverse += arg[i - 1]; + if (quoteHit && arg[i - 1] === '\\') { + reverse += '\\'; // double the slash + } + else if (arg[i - 1] === '"') { + quoteHit = true; + reverse += '"'; // double the quote } else { - core.debug('Loading CloudFormation Stack template'); - const templateFilePath = path.isAbsolute(template) - ? template - : path.join(GITHUB_WORKSPACE, template); - templateBody = fs.readFileSync(templateFilePath, 'utf8'); + quoteHit = false; } - // CloudFormation Stack Parameter for the creation or update - const params = { - StackName: stackName, - Capabilities: [...capabilities.split(',').map(cap => cap.trim())], - RoleARN: roleARN, - NotificationARNs: notificationARNs, - DisableRollback: disableRollback, - TimeoutInMinutes: timeoutInMinutes, - TemplateBody: templateBody, - TemplateURL: templateUrl, - Tags: tags, - EnableTerminationProtection: terminationProtections - }; - if (parameterOverrides) { - params.Parameters = utils_1.parseParameters(parameterOverrides === null || parameterOverrides === void 0 ? void 0 : parameterOverrides.trim(), parametersFile === null || parametersFile === void 0 ? void 0 : parametersFile.trim()); - core.debug(`Parameters: ${JSON.stringify(params.Parameters)}`); + } + reverse += '"'; + return reverse.split('').reverse().join(''); + } + _uvQuoteCmdArg(arg) { + // Tool runner wraps child_process.spawn() and needs to apply the same quoting as + // Node in certain cases where the undocumented spawn option windowsVerbatimArguments + // is used. + // + // Since this function is a port of quote_cmd_arg from Node 4.x (technically, lib UV, + // see https://github.com/nodejs/node/blob/v4.x/deps/uv/src/win/process.c for details), + // pasting copyright notice from Node within this function: + // + // Copyright Joyent, Inc. and other Node contributors. All rights reserved. + // + // Permission is hereby granted, free of charge, to any person obtaining a copy + // of this software and associated documentation files (the "Software"), to + // deal in the Software without restriction, including without limitation the + // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + // sell copies of the Software, and to permit persons to whom the Software is + // furnished to do so, subject to the following conditions: + // + // The above copyright notice and this permission notice shall be included in + // all copies or substantial portions of the Software. + // + // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + // IN THE SOFTWARE. + if (!arg) { + // Need double quotation for empty argument + return '""'; + } + if (!arg.includes(' ') && !arg.includes('\t') && !arg.includes('"')) { + // No quotation needed + return arg; + } + if (!arg.includes('"') && !arg.includes('\\')) { + // No embedded double quotes or backslashes, so I can just wrap + // quote marks around the whole thing. + return `"${arg}"`; + } + // Expected input/output: + // input : hello"world + // output: "hello\"world" + // input : hello""world + // output: "hello\"\"world" + // input : hello\world + // output: hello\world + // input : hello\\world + // output: hello\\world + // input : hello\"world + // output: "hello\\\"world" + // input : hello\\"world + // output: "hello\\\\\"world" + // input : hello world\ + // output: "hello world\\" - note the comment in libuv actually reads "hello world\" + // but it appears the comment is wrong, it should be "hello world\\" + let reverse = '"'; + let quoteHit = true; + for (let i = arg.length; i > 0; i--) { + // walk the string in reverse + reverse += arg[i - 1]; + if (quoteHit && arg[i - 1] === '\\') { + reverse += '\\'; + } + else if (arg[i - 1] === '"') { + quoteHit = true; + reverse += '\\'; + } + else { + quoteHit = false; + } + } + reverse += '"'; + return reverse.split('').reverse().join(''); + } + _cloneExecOptions(options) { + options = options || {}; + const result = { + cwd: options.cwd || process.cwd(), + env: options.env || process.env, + silent: options.silent || false, + windowsVerbatimArguments: options.windowsVerbatimArguments || false, + failOnStdErr: options.failOnStdErr || false, + ignoreReturnCode: options.ignoreReturnCode || false, + delay: options.delay || 10000 + }; + result.outStream = options.outStream || process.stdout; + result.errStream = options.errStream || process.stderr; + return result; + } + _getSpawnOptions(options, toolPath) { + options = options || {}; + const result = {}; + result.cwd = options.cwd; + result.env = options.env; + result['windowsVerbatimArguments'] = + options.windowsVerbatimArguments || this._isCmdFile(); + if (options.windowsVerbatimArguments) { + result.argv0 = `"${toolPath}"`; + } + return result; + } + /** + * Exec a tool. + * Output will be streamed to the live console. + * Returns promise with return code + * + * @param tool path to tool to exec + * @param options optional exec options. See ExecOptions + * @returns number + */ + exec() { + return __awaiter(this, void 0, void 0, function* () { + // root the tool path if it is unrooted and contains relative pathing + if (!ioUtil.isRooted(this.toolPath) && + (this.toolPath.includes('/') || + (IS_WINDOWS && this.toolPath.includes('\\')))) { + // prefer options.cwd if it is specified, however options.cwd may also need to be rooted + this.toolPath = path.resolve(process.cwd(), this.options.cwd || process.cwd(), this.toolPath); } - const stackId = yield deploy_1.deployStack(cfn, params, noEmptyChangeSet, noExecuteChageSet, noDeleteFailedChangeSet, changesetPostfix); - core.setOutput('stack-id', stackId || 'UNKNOWN'); - if (stackId) { - const outputs = yield deploy_1.getStackOutputs(cfn, stackId); - for (const [key, value] of outputs) { - core.setOutput(key, value); - console.log(`> Output ${key}: ${value}`); + // if the tool is only a file name, then resolve it from the PATH + // otherwise verify it exists (add extension on Windows if necessary) + this.toolPath = yield io.which(this.toolPath, true); + return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () { + this._debug(`exec tool: ${this.toolPath}`); + this._debug('arguments:'); + for (const arg of this.args) { + this._debug(` ${arg}`); + } + const optionsNonNull = this._cloneExecOptions(this.options); + if (!optionsNonNull.silent && optionsNonNull.outStream) { + optionsNonNull.outStream.write(this._getCommandString(optionsNonNull) + os.EOL); + } + const state = new ExecState(optionsNonNull, this.toolPath); + state.on('debug', (message) => { + this._debug(message); + }); + if (this.options.cwd && !(yield ioUtil.exists(this.options.cwd))) { + return reject(new Error(`The cwd: ${this.options.cwd} does not exist!`)); + } + const fileName = this._getSpawnFileName(); + const cp = child.spawn(fileName, this._getSpawnArgs(optionsNonNull), this._getSpawnOptions(this.options, fileName)); + let stdbuffer = ''; + if (cp.stdout) { + cp.stdout.on('data', (data) => { + if (this.options.listeners && this.options.listeners.stdout) { + this.options.listeners.stdout(data); + } + if (!optionsNonNull.silent && optionsNonNull.outStream) { + optionsNonNull.outStream.write(data); + } + stdbuffer = this._processLineBuffer(data, stdbuffer, (line) => { + if (this.options.listeners && this.options.listeners.stdline) { + this.options.listeners.stdline(line); + } + }); + }); + } + let errbuffer = ''; + if (cp.stderr) { + cp.stderr.on('data', (data) => { + state.processStderr = true; + if (this.options.listeners && this.options.listeners.stderr) { + this.options.listeners.stderr(data); + } + if (!optionsNonNull.silent && + optionsNonNull.errStream && + optionsNonNull.outStream) { + const s = optionsNonNull.failOnStdErr + ? optionsNonNull.errStream + : optionsNonNull.outStream; + s.write(data); + } + errbuffer = this._processLineBuffer(data, errbuffer, (line) => { + if (this.options.listeners && this.options.listeners.errline) { + this.options.listeners.errline(line); + } + }); + }); + } + cp.on('error', (err) => { + state.processError = err.message; + state.processExited = true; + state.processClosed = true; + state.CheckComplete(); + }); + cp.on('exit', (code) => { + state.processExitCode = code; + state.processExited = true; + this._debug(`Exit code ${code} received from tool '${this.toolPath}'`); + state.CheckComplete(); + }); + cp.on('close', (code) => { + state.processExitCode = code; + state.processExited = true; + state.processClosed = true; + this._debug(`STDIO streams have closed for tool '${this.toolPath}'`); + state.CheckComplete(); + }); + state.on('done', (error, exitCode) => { + if (stdbuffer.length > 0) { + this.emit('stdline', stdbuffer); + } + if (errbuffer.length > 0) { + this.emit('errline', errbuffer); + } + cp.removeAllListeners(); + if (error) { + reject(error); + } + else { + resolve(exitCode); + } + }); + if (this.options.input) { + if (!cp.stdin) { + throw new Error('child process missing stdin'); + } + cp.stdin.end(this.options.input); } + })); + }); + } +} +exports.ToolRunner = ToolRunner; +/** + * Convert an arg string to an array of args. Handles escaping + * + * @param argString string of arguments + * @returns string[] array of arguments + */ +function argStringToArray(argString) { + const args = []; + let inQuotes = false; + let escaped = false; + let arg = ''; + function append(c) { + // we only escape double quotes. + if (escaped && c !== '"') { + arg += '\\'; + } + arg += c; + escaped = false; + } + for (let i = 0; i < argString.length; i++) { + const c = argString.charAt(i); + if (c === '"') { + if (!escaped) { + inQuotes = !inQuotes; + } + else { + append(c); } + continue; } - catch (err) { - core.setFailed(err.message); - core.debug(err.stack); + if (c === '\\' && escaped) { + append(c); + continue; } - }); + if (c === '\\' && inQuotes) { + escaped = true; + continue; + } + if (c === ' ' && !inQuotes) { + if (arg.length > 0) { + args.push(arg); + arg = ''; + } + continue; + } + append(c); + } + if (arg.length > 0) { + args.push(arg.trim()); + } + return args; } -exports.run = run; -/* istanbul ignore next */ -if (require.main === require.cache[eval('__filename')]) { - run(); +class ExecState extends events.EventEmitter { + constructor(options, toolPath) { + super(); + this.processClosed = false; // tracks whether the process has exited and stdio is closed + this.processError = ''; + this.processExitCode = 0; + this.processExited = false; // tracks whether the process has exited + this.processStderr = false; // tracks whether stderr was written to + this.delay = 10000; // 10 seconds + this.done = false; + this.timeout = null; + if (!toolPath) { + throw new Error('toolPath must not be empty'); + } + this.options = options; + this.toolPath = toolPath; + if (options.delay) { + this.delay = options.delay; + } + } + CheckComplete() { + if (this.done) { + return; + } + if (this.processClosed) { + this._setResult(); + } + else if (this.processExited) { + this.timeout = (0, timers_1.setTimeout)(ExecState.HandleTimeout, this.delay, this); + } + } + _debug(message) { + this.emit('debug', message); + } + _setResult() { + // determine whether there is an error + let error; + if (this.processExited) { + if (this.processError) { + error = new Error(`There was an error when attempting to execute the process '${this.toolPath}'. This may indicate the process failed to start. Error: ${this.processError}`); + } + else if (this.processExitCode !== 0 && !this.options.ignoreReturnCode) { + error = new Error(`The process '${this.toolPath}' failed with exit code ${this.processExitCode}`); + } + else if (this.processStderr && this.options.failOnStdErr) { + error = new Error(`The process '${this.toolPath}' failed because one or more lines were written to the STDERR stream`); + } + } + // clear the timeout + if (this.timeout) { + clearTimeout(this.timeout); + this.timeout = null; + } + this.done = true; + this.emit('done', error, this.processExitCode); + } + static HandleTimeout(state) { + if (state.done) { + return; + } + if (!state.processClosed && state.processExited) { + const message = `The STDIO streams did not close within ${state.delay / 1000} seconds of the exit event from process '${state.toolPath}'. This may indicate a child process inherited the STDIO streams and has not yet exited.`; + state._debug(message); + } + state._setResult(); + } } - +//# sourceMappingURL=toolrunner.js.map /***/ }), -/***/ 215: -/***/ (function(module, __unusedexports, __webpack_require__) { +/***/ 4552: +/***/ (function(__unused_webpack_module, exports) { -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +"use strict"; -apiLoader.services['resourcegroups'] = {}; -AWS.ResourceGroups = Service.defineService('resourcegroups', ['2017-11-27']); -Object.defineProperty(apiLoader.services['resourcegroups'], '2017-11-27', { - get: function get() { - var model = __webpack_require__(223); - model.paginators = __webpack_require__(8096).pagination; - return model; - }, - enumerable: true, - configurable: true -}); +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.PersonalAccessTokenCredentialHandler = exports.BearerCredentialHandler = exports.BasicCredentialHandler = void 0; +class BasicCredentialHandler { + constructor(username, password) { + this.username = username; + this.password = password; + } + prepareRequest(options) { + if (!options.headers) { + throw Error('The request has no headers'); + } + options.headers['Authorization'] = `Basic ${Buffer.from(`${this.username}:${this.password}`).toString('base64')}`; + } + // This handler cannot handle 401 + canHandleAuthentication() { + return false; + } + handleAuthentication() { + return __awaiter(this, void 0, void 0, function* () { + throw new Error('not implemented'); + }); + } +} +exports.BasicCredentialHandler = BasicCredentialHandler; +class BearerCredentialHandler { + constructor(token) { + this.token = token; + } + // currently implements pre-authorization + // TODO: support preAuth = false where it hooks on 401 + prepareRequest(options) { + if (!options.headers) { + throw Error('The request has no headers'); + } + options.headers['Authorization'] = `Bearer ${this.token}`; + } + // This handler cannot handle 401 + canHandleAuthentication() { + return false; + } + handleAuthentication() { + return __awaiter(this, void 0, void 0, function* () { + throw new Error('not implemented'); + }); + } +} +exports.BearerCredentialHandler = BearerCredentialHandler; +class PersonalAccessTokenCredentialHandler { + constructor(token) { + this.token = token; + } + // currently implements pre-authorization + // TODO: support preAuth = false where it hooks on 401 + prepareRequest(options) { + if (!options.headers) { + throw Error('The request has no headers'); + } + options.headers['Authorization'] = `Basic ${Buffer.from(`PAT:${this.token}`).toString('base64')}`; + } + // This handler cannot handle 401 + canHandleAuthentication() { + return false; + } + handleAuthentication() { + return __awaiter(this, void 0, void 0, function* () { + throw new Error('not implemented'); + }); + } +} +exports.PersonalAccessTokenCredentialHandler = PersonalAccessTokenCredentialHandler; +//# sourceMappingURL=auth.js.map -module.exports = AWS.ResourceGroups; +/***/ }), +/***/ 4844: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { -/***/ }), - -/***/ 216: -/***/ (function(module) { - -module.exports = {"pagination":{"DescribeBackups":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"DescribeClusters":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListTags":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"}}}; - -/***/ }), - -/***/ 223: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2017-11-27","endpointPrefix":"resource-groups","protocol":"rest-json","serviceAbbreviation":"Resource Groups","serviceFullName":"AWS Resource Groups","serviceId":"Resource Groups","signatureVersion":"v4","signingName":"resource-groups","uid":"resource-groups-2017-11-27"},"operations":{"CreateGroup":{"http":{"requestUri":"/groups"},"input":{"type":"structure","required":["Name"],"members":{"Name":{},"Description":{},"ResourceQuery":{"shape":"S4"},"Tags":{"shape":"S7"},"Configuration":{"shape":"Sa"}}},"output":{"type":"structure","members":{"Group":{"shape":"Sj"},"ResourceQuery":{"shape":"S4"},"Tags":{"shape":"S7"},"GroupConfiguration":{"shape":"Sl"}}}},"DeleteGroup":{"http":{"requestUri":"/delete-group"},"input":{"type":"structure","members":{"GroupName":{"deprecated":true,"deprecatedMessage":"This field is deprecated, use Group instead."},"Group":{}}},"output":{"type":"structure","members":{"Group":{"shape":"Sj"}}}},"GetGroup":{"http":{"requestUri":"/get-group"},"input":{"type":"structure","members":{"GroupName":{"deprecated":true,"deprecatedMessage":"This field is deprecated, use Group instead."},"Group":{}}},"output":{"type":"structure","members":{"Group":{"shape":"Sj"}}}},"GetGroupConfiguration":{"http":{"requestUri":"/get-group-configuration"},"input":{"type":"structure","members":{"Group":{}}},"output":{"type":"structure","members":{"GroupConfiguration":{"shape":"Sl"}}}},"GetGroupQuery":{"http":{"requestUri":"/get-group-query"},"input":{"type":"structure","members":{"GroupName":{"deprecated":true,"deprecatedMessage":"This field is deprecated, use Group instead."},"Group":{}}},"output":{"type":"structure","members":{"GroupQuery":{"shape":"Sx"}}}},"GetTags":{"http":{"method":"GET","requestUri":"/resources/{Arn}/tags"},"input":{"type":"structure","required":["Arn"],"members":{"Arn":{"location":"uri","locationName":"Arn"}}},"output":{"type":"structure","members":{"Arn":{},"Tags":{"shape":"S7"}}}},"GroupResources":{"http":{"requestUri":"/group-resources"},"input":{"type":"structure","required":["Group","ResourceArns"],"members":{"Group":{},"ResourceArns":{"shape":"S11"}}},"output":{"type":"structure","members":{"Succeeded":{"shape":"S11"},"Failed":{"shape":"S14"}}}},"ListGroupResources":{"http":{"requestUri":"/list-group-resources"},"input":{"type":"structure","members":{"GroupName":{"deprecated":true,"deprecatedMessage":"This field is deprecated, use Group instead."},"Group":{},"Filters":{"type":"list","member":{"type":"structure","required":["Name","Values"],"members":{"Name":{},"Values":{"type":"list","member":{}}}}},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"ResourceIdentifiers":{"shape":"S1h"},"NextToken":{},"QueryErrors":{"shape":"S1k"}}}},"ListGroups":{"http":{"requestUri":"/groups-list"},"input":{"type":"structure","members":{"Filters":{"type":"list","member":{"type":"structure","required":["Name","Values"],"members":{"Name":{},"Values":{"type":"list","member":{}}}}},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"GroupIdentifiers":{"type":"list","member":{"type":"structure","members":{"GroupName":{},"GroupArn":{}}}},"Groups":{"deprecated":true,"deprecatedMessage":"This field is deprecated, use GroupIdentifiers instead.","type":"list","member":{"shape":"Sj"}},"NextToken":{}}}},"SearchResources":{"http":{"requestUri":"/resources/search"},"input":{"type":"structure","required":["ResourceQuery"],"members":{"ResourceQuery":{"shape":"S4"},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"ResourceIdentifiers":{"shape":"S1h"},"NextToken":{},"QueryErrors":{"shape":"S1k"}}}},"Tag":{"http":{"method":"PUT","requestUri":"/resources/{Arn}/tags"},"input":{"type":"structure","required":["Arn","Tags"],"members":{"Arn":{"location":"uri","locationName":"Arn"},"Tags":{"shape":"S7"}}},"output":{"type":"structure","members":{"Arn":{},"Tags":{"shape":"S7"}}}},"UngroupResources":{"http":{"requestUri":"/ungroup-resources"},"input":{"type":"structure","required":["Group","ResourceArns"],"members":{"Group":{},"ResourceArns":{"shape":"S11"}}},"output":{"type":"structure","members":{"Succeeded":{"shape":"S11"},"Failed":{"shape":"S14"}}}},"Untag":{"http":{"method":"PATCH","requestUri":"/resources/{Arn}/tags"},"input":{"type":"structure","required":["Arn","Keys"],"members":{"Arn":{"location":"uri","locationName":"Arn"},"Keys":{"shape":"S25"}}},"output":{"type":"structure","members":{"Arn":{},"Keys":{"shape":"S25"}}}},"UpdateGroup":{"http":{"requestUri":"/update-group"},"input":{"type":"structure","members":{"GroupName":{"deprecated":true,"deprecatedMessage":"This field is deprecated, use Group instead."},"Group":{},"Description":{}}},"output":{"type":"structure","members":{"Group":{"shape":"Sj"}}}},"UpdateGroupQuery":{"http":{"requestUri":"/update-group-query"},"input":{"type":"structure","required":["ResourceQuery"],"members":{"GroupName":{"deprecated":true,"deprecatedMessage":"This field is deprecated, use Group instead."},"Group":{},"ResourceQuery":{"shape":"S4"}}},"output":{"type":"structure","members":{"GroupQuery":{"shape":"Sx"}}}}},"shapes":{"S4":{"type":"structure","required":["Type","Query"],"members":{"Type":{},"Query":{}}},"S7":{"type":"map","key":{},"value":{}},"Sa":{"type":"list","member":{"type":"structure","required":["Type"],"members":{"Type":{},"Parameters":{"type":"list","member":{"type":"structure","required":["Name"],"members":{"Name":{},"Values":{"type":"list","member":{}}}}}}}},"Sj":{"type":"structure","required":["GroupArn","Name"],"members":{"GroupArn":{},"Name":{},"Description":{}}},"Sl":{"type":"structure","members":{"Configuration":{"shape":"Sa"},"ProposedConfiguration":{"shape":"Sa"},"Status":{},"FailureReason":{}}},"Sx":{"type":"structure","required":["GroupName","ResourceQuery"],"members":{"GroupName":{},"ResourceQuery":{"shape":"S4"}}},"S11":{"type":"list","member":{}},"S14":{"type":"list","member":{"type":"structure","members":{"ResourceArn":{},"ErrorMessage":{},"ErrorCode":{}}}},"S1h":{"type":"list","member":{"type":"structure","members":{"ResourceArn":{},"ResourceType":{}}}},"S1k":{"type":"list","member":{"type":"structure","members":{"ErrorCode":{},"Message":{}}}},"S25":{"type":"list","member":{}}}}; - -/***/ }), - -/***/ 232: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2017-10-26","endpointPrefix":"transcribe","jsonVersion":"1.1","protocol":"json","serviceFullName":"Amazon Transcribe Service","serviceId":"Transcribe","signatureVersion":"v4","signingName":"transcribe","targetPrefix":"Transcribe","uid":"transcribe-2017-10-26"},"operations":{"CreateMedicalVocabulary":{"input":{"type":"structure","required":["VocabularyName","LanguageCode","VocabularyFileUri"],"members":{"VocabularyName":{},"LanguageCode":{},"VocabularyFileUri":{}}},"output":{"type":"structure","members":{"VocabularyName":{},"LanguageCode":{},"VocabularyState":{},"LastModifiedTime":{"type":"timestamp"},"FailureReason":{}}}},"CreateVocabulary":{"input":{"type":"structure","required":["VocabularyName","LanguageCode"],"members":{"VocabularyName":{},"LanguageCode":{},"Phrases":{"shape":"Sa"},"VocabularyFileUri":{}}},"output":{"type":"structure","members":{"VocabularyName":{},"LanguageCode":{},"VocabularyState":{},"LastModifiedTime":{"type":"timestamp"},"FailureReason":{}}}},"CreateVocabularyFilter":{"input":{"type":"structure","required":["VocabularyFilterName","LanguageCode"],"members":{"VocabularyFilterName":{},"LanguageCode":{},"Words":{"shape":"Sf"},"VocabularyFilterFileUri":{}}},"output":{"type":"structure","members":{"VocabularyFilterName":{},"LanguageCode":{},"LastModifiedTime":{"type":"timestamp"}}}},"DeleteMedicalTranscriptionJob":{"input":{"type":"structure","required":["MedicalTranscriptionJobName"],"members":{"MedicalTranscriptionJobName":{}}}},"DeleteMedicalVocabulary":{"input":{"type":"structure","required":["VocabularyName"],"members":{"VocabularyName":{}}}},"DeleteTranscriptionJob":{"input":{"type":"structure","required":["TranscriptionJobName"],"members":{"TranscriptionJobName":{}}}},"DeleteVocabulary":{"input":{"type":"structure","required":["VocabularyName"],"members":{"VocabularyName":{}}}},"DeleteVocabularyFilter":{"input":{"type":"structure","required":["VocabularyFilterName"],"members":{"VocabularyFilterName":{}}}},"GetMedicalTranscriptionJob":{"input":{"type":"structure","required":["MedicalTranscriptionJobName"],"members":{"MedicalTranscriptionJobName":{}}},"output":{"type":"structure","members":{"MedicalTranscriptionJob":{"shape":"Sq"}}}},"GetMedicalVocabulary":{"input":{"type":"structure","required":["VocabularyName"],"members":{"VocabularyName":{}}},"output":{"type":"structure","members":{"VocabularyName":{},"LanguageCode":{},"VocabularyState":{},"LastModifiedTime":{"type":"timestamp"},"FailureReason":{},"DownloadUri":{}}}},"GetTranscriptionJob":{"input":{"type":"structure","required":["TranscriptionJobName"],"members":{"TranscriptionJobName":{}}},"output":{"type":"structure","members":{"TranscriptionJob":{"shape":"S16"}}}},"GetVocabulary":{"input":{"type":"structure","required":["VocabularyName"],"members":{"VocabularyName":{}}},"output":{"type":"structure","members":{"VocabularyName":{},"LanguageCode":{},"VocabularyState":{},"LastModifiedTime":{"type":"timestamp"},"FailureReason":{},"DownloadUri":{}}}},"GetVocabularyFilter":{"input":{"type":"structure","required":["VocabularyFilterName"],"members":{"VocabularyFilterName":{}}},"output":{"type":"structure","members":{"VocabularyFilterName":{},"LanguageCode":{},"LastModifiedTime":{"type":"timestamp"},"DownloadUri":{}}}},"ListMedicalTranscriptionJobs":{"input":{"type":"structure","members":{"Status":{},"JobNameContains":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"Status":{},"NextToken":{},"MedicalTranscriptionJobSummaries":{"type":"list","member":{"type":"structure","members":{"MedicalTranscriptionJobName":{},"CreationTime":{"type":"timestamp"},"StartTime":{"type":"timestamp"},"CompletionTime":{"type":"timestamp"},"LanguageCode":{},"TranscriptionJobStatus":{},"FailureReason":{},"OutputLocationType":{},"Specialty":{},"Type":{}}}}}}},"ListMedicalVocabularies":{"input":{"type":"structure","members":{"NextToken":{},"MaxResults":{"type":"integer"},"StateEquals":{},"NameContains":{}}},"output":{"type":"structure","members":{"Status":{},"NextToken":{},"Vocabularies":{"shape":"S1s"}}}},"ListTranscriptionJobs":{"input":{"type":"structure","members":{"Status":{},"JobNameContains":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"Status":{},"NextToken":{},"TranscriptionJobSummaries":{"type":"list","member":{"type":"structure","members":{"TranscriptionJobName":{},"CreationTime":{"type":"timestamp"},"StartTime":{"type":"timestamp"},"CompletionTime":{"type":"timestamp"},"LanguageCode":{},"TranscriptionJobStatus":{},"FailureReason":{},"OutputLocationType":{},"ContentRedaction":{"shape":"S1c"}}}}}}},"ListVocabularies":{"input":{"type":"structure","members":{"NextToken":{},"MaxResults":{"type":"integer"},"StateEquals":{},"NameContains":{}}},"output":{"type":"structure","members":{"Status":{},"NextToken":{},"Vocabularies":{"shape":"S1s"}}}},"ListVocabularyFilters":{"input":{"type":"structure","members":{"NextToken":{},"MaxResults":{"type":"integer"},"NameContains":{}}},"output":{"type":"structure","members":{"NextToken":{},"VocabularyFilters":{"type":"list","member":{"type":"structure","members":{"VocabularyFilterName":{},"LanguageCode":{},"LastModifiedTime":{"type":"timestamp"}}}}}}},"StartMedicalTranscriptionJob":{"input":{"type":"structure","required":["MedicalTranscriptionJobName","LanguageCode","Media","OutputBucketName","Specialty","Type"],"members":{"MedicalTranscriptionJobName":{},"LanguageCode":{},"MediaSampleRateHertz":{"type":"integer"},"MediaFormat":{},"Media":{"shape":"Su"},"OutputBucketName":{},"OutputEncryptionKMSKeyId":{},"Settings":{"shape":"Sw"},"Specialty":{},"Type":{}}},"output":{"type":"structure","members":{"MedicalTranscriptionJob":{"shape":"Sq"}}}},"StartTranscriptionJob":{"input":{"type":"structure","required":["TranscriptionJobName","LanguageCode","Media"],"members":{"TranscriptionJobName":{},"LanguageCode":{},"MediaSampleRateHertz":{"type":"integer"},"MediaFormat":{},"Media":{"shape":"Su"},"OutputBucketName":{},"OutputEncryptionKMSKeyId":{},"Settings":{"shape":"S18"},"JobExecutionSettings":{"shape":"S1a"},"ContentRedaction":{"shape":"S1c"}}},"output":{"type":"structure","members":{"TranscriptionJob":{"shape":"S16"}}}},"UpdateMedicalVocabulary":{"input":{"type":"structure","required":["VocabularyName","LanguageCode"],"members":{"VocabularyName":{},"LanguageCode":{},"VocabularyFileUri":{}}},"output":{"type":"structure","members":{"VocabularyName":{},"LanguageCode":{},"LastModifiedTime":{"type":"timestamp"},"VocabularyState":{}}}},"UpdateVocabulary":{"input":{"type":"structure","required":["VocabularyName","LanguageCode"],"members":{"VocabularyName":{},"LanguageCode":{},"Phrases":{"shape":"Sa"},"VocabularyFileUri":{}}},"output":{"type":"structure","members":{"VocabularyName":{},"LanguageCode":{},"LastModifiedTime":{"type":"timestamp"},"VocabularyState":{}}}},"UpdateVocabularyFilter":{"input":{"type":"structure","required":["VocabularyFilterName"],"members":{"VocabularyFilterName":{},"Words":{"shape":"Sf"},"VocabularyFilterFileUri":{}}},"output":{"type":"structure","members":{"VocabularyFilterName":{},"LanguageCode":{},"LastModifiedTime":{"type":"timestamp"}}}}},"shapes":{"Sa":{"type":"list","member":{}},"Sf":{"type":"list","member":{}},"Sq":{"type":"structure","members":{"MedicalTranscriptionJobName":{},"TranscriptionJobStatus":{},"LanguageCode":{},"MediaSampleRateHertz":{"type":"integer"},"MediaFormat":{},"Media":{"shape":"Su"},"Transcript":{"type":"structure","members":{"TranscriptFileUri":{}}},"StartTime":{"type":"timestamp"},"CreationTime":{"type":"timestamp"},"CompletionTime":{"type":"timestamp"},"FailureReason":{},"Settings":{"shape":"Sw"},"Specialty":{},"Type":{}}},"Su":{"type":"structure","members":{"MediaFileUri":{}}},"Sw":{"type":"structure","members":{"ShowSpeakerLabels":{"type":"boolean"},"MaxSpeakerLabels":{"type":"integer"},"ChannelIdentification":{"type":"boolean"},"ShowAlternatives":{"type":"boolean"},"MaxAlternatives":{"type":"integer"},"VocabularyName":{}}},"S16":{"type":"structure","members":{"TranscriptionJobName":{},"TranscriptionJobStatus":{},"LanguageCode":{},"MediaSampleRateHertz":{"type":"integer"},"MediaFormat":{},"Media":{"shape":"Su"},"Transcript":{"type":"structure","members":{"TranscriptFileUri":{},"RedactedTranscriptFileUri":{}}},"StartTime":{"type":"timestamp"},"CreationTime":{"type":"timestamp"},"CompletionTime":{"type":"timestamp"},"FailureReason":{},"Settings":{"shape":"S18"},"JobExecutionSettings":{"shape":"S1a"},"ContentRedaction":{"shape":"S1c"}}},"S18":{"type":"structure","members":{"VocabularyName":{},"ShowSpeakerLabels":{"type":"boolean"},"MaxSpeakerLabels":{"type":"integer"},"ChannelIdentification":{"type":"boolean"},"ShowAlternatives":{"type":"boolean"},"MaxAlternatives":{"type":"integer"},"VocabularyFilterName":{},"VocabularyFilterMethod":{}}},"S1a":{"type":"structure","members":{"AllowDeferredExecution":{"type":"boolean"},"DataAccessRoleArn":{}}},"S1c":{"type":"structure","required":["RedactionType","RedactionOutput"],"members":{"RedactionType":{},"RedactionOutput":{}}},"S1s":{"type":"list","member":{"type":"structure","members":{"VocabularyName":{},"LanguageCode":{},"LastModifiedTime":{"type":"timestamp"},"VocabularyState":{}}}}}}; - -/***/ }), - -/***/ 240: -/***/ (function(module) { - -module.exports = {"pagination":{"DescribeJobFlows":{"result_key":"JobFlows"},"ListBootstrapActions":{"input_token":"Marker","output_token":"Marker","result_key":"BootstrapActions"},"ListClusters":{"input_token":"Marker","output_token":"Marker","result_key":"Clusters"},"ListInstanceFleets":{"input_token":"Marker","output_token":"Marker","result_key":"InstanceFleets"},"ListInstanceGroups":{"input_token":"Marker","output_token":"Marker","result_key":"InstanceGroups"},"ListInstances":{"input_token":"Marker","output_token":"Marker","result_key":"Instances"},"ListSecurityConfigurations":{"input_token":"Marker","output_token":"Marker","result_key":"SecurityConfigurations"},"ListSteps":{"input_token":"Marker","output_token":"Marker","result_key":"Steps"}}}; - -/***/ }), - -/***/ 280: -/***/ (function(module) { - -module.exports = {"pagination":{}}; - -/***/ }), - -/***/ 287: -/***/ (function(module) { +"use strict"; -module.exports = {"version":"2.0","metadata":{"apiVersion":"2012-10-29","endpointPrefix":"datapipeline","jsonVersion":"1.1","serviceFullName":"AWS Data Pipeline","serviceId":"Data Pipeline","signatureVersion":"v4","targetPrefix":"DataPipeline","protocol":"json","uid":"datapipeline-2012-10-29"},"operations":{"ActivatePipeline":{"input":{"type":"structure","required":["pipelineId"],"members":{"pipelineId":{},"parameterValues":{"shape":"S3"},"startTimestamp":{"type":"timestamp"}}},"output":{"type":"structure","members":{}}},"AddTags":{"input":{"type":"structure","required":["pipelineId","tags"],"members":{"pipelineId":{},"tags":{"shape":"Sa"}}},"output":{"type":"structure","members":{}}},"CreatePipeline":{"input":{"type":"structure","required":["name","uniqueId"],"members":{"name":{},"uniqueId":{},"description":{},"tags":{"shape":"Sa"}}},"output":{"type":"structure","required":["pipelineId"],"members":{"pipelineId":{}}}},"DeactivatePipeline":{"input":{"type":"structure","required":["pipelineId"],"members":{"pipelineId":{},"cancelActive":{"type":"boolean"}}},"output":{"type":"structure","members":{}}},"DeletePipeline":{"input":{"type":"structure","required":["pipelineId"],"members":{"pipelineId":{}}}},"DescribeObjects":{"input":{"type":"structure","required":["pipelineId","objectIds"],"members":{"pipelineId":{},"objectIds":{"shape":"Sn"},"evaluateExpressions":{"type":"boolean"},"marker":{}}},"output":{"type":"structure","required":["pipelineObjects"],"members":{"pipelineObjects":{"shape":"Sq"},"marker":{},"hasMoreResults":{"type":"boolean"}}}},"DescribePipelines":{"input":{"type":"structure","required":["pipelineIds"],"members":{"pipelineIds":{"shape":"Sn"}}},"output":{"type":"structure","required":["pipelineDescriptionList"],"members":{"pipelineDescriptionList":{"type":"list","member":{"type":"structure","required":["pipelineId","name","fields"],"members":{"pipelineId":{},"name":{},"fields":{"shape":"Ss"},"description":{},"tags":{"shape":"Sa"}}}}}}},"EvaluateExpression":{"input":{"type":"structure","required":["pipelineId","objectId","expression"],"members":{"pipelineId":{},"objectId":{},"expression":{}}},"output":{"type":"structure","required":["evaluatedExpression"],"members":{"evaluatedExpression":{}}}},"GetPipelineDefinition":{"input":{"type":"structure","required":["pipelineId"],"members":{"pipelineId":{},"version":{}}},"output":{"type":"structure","members":{"pipelineObjects":{"shape":"Sq"},"parameterObjects":{"shape":"S13"},"parameterValues":{"shape":"S3"}}}},"ListPipelines":{"input":{"type":"structure","members":{"marker":{}}},"output":{"type":"structure","required":["pipelineIdList"],"members":{"pipelineIdList":{"type":"list","member":{"type":"structure","members":{"id":{},"name":{}}}},"marker":{},"hasMoreResults":{"type":"boolean"}}}},"PollForTask":{"input":{"type":"structure","required":["workerGroup"],"members":{"workerGroup":{},"hostname":{},"instanceIdentity":{"type":"structure","members":{"document":{},"signature":{}}}}},"output":{"type":"structure","members":{"taskObject":{"type":"structure","members":{"taskId":{},"pipelineId":{},"attemptId":{},"objects":{"type":"map","key":{},"value":{"shape":"Sr"}}}}}}},"PutPipelineDefinition":{"input":{"type":"structure","required":["pipelineId","pipelineObjects"],"members":{"pipelineId":{},"pipelineObjects":{"shape":"Sq"},"parameterObjects":{"shape":"S13"},"parameterValues":{"shape":"S3"}}},"output":{"type":"structure","required":["errored"],"members":{"validationErrors":{"shape":"S1l"},"validationWarnings":{"shape":"S1p"},"errored":{"type":"boolean"}}}},"QueryObjects":{"input":{"type":"structure","required":["pipelineId","sphere"],"members":{"pipelineId":{},"query":{"type":"structure","members":{"selectors":{"type":"list","member":{"type":"structure","members":{"fieldName":{},"operator":{"type":"structure","members":{"type":{},"values":{"shape":"S1x"}}}}}}}},"sphere":{},"marker":{},"limit":{"type":"integer"}}},"output":{"type":"structure","members":{"ids":{"shape":"Sn"},"marker":{},"hasMoreResults":{"type":"boolean"}}}},"RemoveTags":{"input":{"type":"structure","required":["pipelineId","tagKeys"],"members":{"pipelineId":{},"tagKeys":{"shape":"S1x"}}},"output":{"type":"structure","members":{}}},"ReportTaskProgress":{"input":{"type":"structure","required":["taskId"],"members":{"taskId":{},"fields":{"shape":"Ss"}}},"output":{"type":"structure","required":["canceled"],"members":{"canceled":{"type":"boolean"}}}},"ReportTaskRunnerHeartbeat":{"input":{"type":"structure","required":["taskrunnerId"],"members":{"taskrunnerId":{},"workerGroup":{},"hostname":{}}},"output":{"type":"structure","required":["terminate"],"members":{"terminate":{"type":"boolean"}}}},"SetStatus":{"input":{"type":"structure","required":["pipelineId","objectIds","status"],"members":{"pipelineId":{},"objectIds":{"shape":"Sn"},"status":{}}}},"SetTaskStatus":{"input":{"type":"structure","required":["taskId","taskStatus"],"members":{"taskId":{},"taskStatus":{},"errorId":{},"errorMessage":{},"errorStackTrace":{}}},"output":{"type":"structure","members":{}}},"ValidatePipelineDefinition":{"input":{"type":"structure","required":["pipelineId","pipelineObjects"],"members":{"pipelineId":{},"pipelineObjects":{"shape":"Sq"},"parameterObjects":{"shape":"S13"},"parameterValues":{"shape":"S3"}}},"output":{"type":"structure","required":["errored"],"members":{"validationErrors":{"shape":"S1l"},"validationWarnings":{"shape":"S1p"},"errored":{"type":"boolean"}}}}},"shapes":{"S3":{"type":"list","member":{"type":"structure","required":["id","stringValue"],"members":{"id":{},"stringValue":{}}}},"Sa":{"type":"list","member":{"type":"structure","required":["key","value"],"members":{"key":{},"value":{}}}},"Sn":{"type":"list","member":{}},"Sq":{"type":"list","member":{"shape":"Sr"}},"Sr":{"type":"structure","required":["id","name","fields"],"members":{"id":{},"name":{},"fields":{"shape":"Ss"}}},"Ss":{"type":"list","member":{"type":"structure","required":["key"],"members":{"key":{},"stringValue":{},"refValue":{}}}},"S13":{"type":"list","member":{"type":"structure","required":["id","attributes"],"members":{"id":{},"attributes":{"type":"list","member":{"type":"structure","required":["key","stringValue"],"members":{"key":{},"stringValue":{}}}}}}},"S1l":{"type":"list","member":{"type":"structure","members":{"id":{},"errors":{"shape":"S1n"}}}},"S1n":{"type":"list","member":{}},"S1p":{"type":"list","member":{"type":"structure","members":{"id":{},"warnings":{"shape":"S1n"}}}},"S1x":{"type":"list","member":{}}}}; +/* eslint-disable @typescript-eslint/no-explicit-any */ +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; + }; +})(); +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.HttpClient = exports.HttpClientResponse = exports.HttpClientError = exports.MediaTypes = exports.Headers = exports.HttpCodes = void 0; +exports.getProxyUrl = getProxyUrl; +exports.isHttps = isHttps; +const http = __importStar(__nccwpck_require__(8611)); +const https = __importStar(__nccwpck_require__(5692)); +const pm = __importStar(__nccwpck_require__(4988)); +const tunnel = __importStar(__nccwpck_require__(770)); +const undici_1 = __nccwpck_require__(6752); +var HttpCodes; +(function (HttpCodes) { + HttpCodes[HttpCodes["OK"] = 200] = "OK"; + HttpCodes[HttpCodes["MultipleChoices"] = 300] = "MultipleChoices"; + HttpCodes[HttpCodes["MovedPermanently"] = 301] = "MovedPermanently"; + HttpCodes[HttpCodes["ResourceMoved"] = 302] = "ResourceMoved"; + HttpCodes[HttpCodes["SeeOther"] = 303] = "SeeOther"; + HttpCodes[HttpCodes["NotModified"] = 304] = "NotModified"; + HttpCodes[HttpCodes["UseProxy"] = 305] = "UseProxy"; + HttpCodes[HttpCodes["SwitchProxy"] = 306] = "SwitchProxy"; + HttpCodes[HttpCodes["TemporaryRedirect"] = 307] = "TemporaryRedirect"; + HttpCodes[HttpCodes["PermanentRedirect"] = 308] = "PermanentRedirect"; + HttpCodes[HttpCodes["BadRequest"] = 400] = "BadRequest"; + HttpCodes[HttpCodes["Unauthorized"] = 401] = "Unauthorized"; + HttpCodes[HttpCodes["PaymentRequired"] = 402] = "PaymentRequired"; + HttpCodes[HttpCodes["Forbidden"] = 403] = "Forbidden"; + HttpCodes[HttpCodes["NotFound"] = 404] = "NotFound"; + HttpCodes[HttpCodes["MethodNotAllowed"] = 405] = "MethodNotAllowed"; + HttpCodes[HttpCodes["NotAcceptable"] = 406] = "NotAcceptable"; + HttpCodes[HttpCodes["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired"; + HttpCodes[HttpCodes["RequestTimeout"] = 408] = "RequestTimeout"; + HttpCodes[HttpCodes["Conflict"] = 409] = "Conflict"; + HttpCodes[HttpCodes["Gone"] = 410] = "Gone"; + HttpCodes[HttpCodes["TooManyRequests"] = 429] = "TooManyRequests"; + HttpCodes[HttpCodes["InternalServerError"] = 500] = "InternalServerError"; + HttpCodes[HttpCodes["NotImplemented"] = 501] = "NotImplemented"; + HttpCodes[HttpCodes["BadGateway"] = 502] = "BadGateway"; + HttpCodes[HttpCodes["ServiceUnavailable"] = 503] = "ServiceUnavailable"; + HttpCodes[HttpCodes["GatewayTimeout"] = 504] = "GatewayTimeout"; +})(HttpCodes || (exports.HttpCodes = HttpCodes = {})); +var Headers; +(function (Headers) { + Headers["Accept"] = "accept"; + Headers["ContentType"] = "content-type"; +})(Headers || (exports.Headers = Headers = {})); +var MediaTypes; +(function (MediaTypes) { + MediaTypes["ApplicationJson"] = "application/json"; +})(MediaTypes || (exports.MediaTypes = MediaTypes = {})); +/** + * Returns the proxy URL, depending upon the supplied url and proxy environment variables. + * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com + */ +function getProxyUrl(serverUrl) { + const proxyUrl = pm.getProxyUrl(new URL(serverUrl)); + return proxyUrl ? proxyUrl.href : ''; +} +const HttpRedirectCodes = [ + HttpCodes.MovedPermanently, + HttpCodes.ResourceMoved, + HttpCodes.SeeOther, + HttpCodes.TemporaryRedirect, + HttpCodes.PermanentRedirect +]; +const HttpResponseRetryCodes = [ + HttpCodes.BadGateway, + HttpCodes.ServiceUnavailable, + HttpCodes.GatewayTimeout +]; +const RetryableHttpVerbs = ['OPTIONS', 'GET', 'DELETE', 'HEAD']; +const ExponentialBackoffCeiling = 10; +const ExponentialBackoffTimeSlice = 5; +class HttpClientError extends Error { + constructor(message, statusCode) { + super(message); + this.name = 'HttpClientError'; + this.statusCode = statusCode; + Object.setPrototypeOf(this, HttpClientError.prototype); + } +} +exports.HttpClientError = HttpClientError; +class HttpClientResponse { + constructor(message) { + this.message = message; + } + readBody() { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () { + let output = Buffer.alloc(0); + this.message.on('data', (chunk) => { + output = Buffer.concat([output, chunk]); + }); + this.message.on('end', () => { + resolve(output.toString()); + }); + })); + }); + } + readBodyBuffer() { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () { + const chunks = []; + this.message.on('data', (chunk) => { + chunks.push(chunk); + }); + this.message.on('end', () => { + resolve(Buffer.concat(chunks)); + }); + })); + }); + } +} +exports.HttpClientResponse = HttpClientResponse; +function isHttps(requestUrl) { + const parsedUrl = new URL(requestUrl); + return parsedUrl.protocol === 'https:'; +} +class HttpClient { + constructor(userAgent, handlers, requestOptions) { + this._ignoreSslError = false; + this._allowRedirects = true; + this._allowRedirectDowngrade = false; + this._maxRedirects = 50; + this._allowRetries = false; + this._maxRetries = 1; + this._keepAlive = false; + this._disposed = false; + this.userAgent = this._getUserAgentWithOrchestrationId(userAgent); + this.handlers = handlers || []; + this.requestOptions = requestOptions; + if (requestOptions) { + if (requestOptions.ignoreSslError != null) { + this._ignoreSslError = requestOptions.ignoreSslError; + } + this._socketTimeout = requestOptions.socketTimeout; + if (requestOptions.allowRedirects != null) { + this._allowRedirects = requestOptions.allowRedirects; + } + if (requestOptions.allowRedirectDowngrade != null) { + this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade; + } + if (requestOptions.maxRedirects != null) { + this._maxRedirects = Math.max(requestOptions.maxRedirects, 0); + } + if (requestOptions.keepAlive != null) { + this._keepAlive = requestOptions.keepAlive; + } + if (requestOptions.allowRetries != null) { + this._allowRetries = requestOptions.allowRetries; + } + if (requestOptions.maxRetries != null) { + this._maxRetries = requestOptions.maxRetries; + } + } + } + options(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request('OPTIONS', requestUrl, null, additionalHeaders || {}); + }); + } + get(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request('GET', requestUrl, null, additionalHeaders || {}); + }); + } + del(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request('DELETE', requestUrl, null, additionalHeaders || {}); + }); + } + post(requestUrl, data, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request('POST', requestUrl, data, additionalHeaders || {}); + }); + } + patch(requestUrl, data, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request('PATCH', requestUrl, data, additionalHeaders || {}); + }); + } + put(requestUrl, data, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request('PUT', requestUrl, data, additionalHeaders || {}); + }); + } + head(requestUrl, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request('HEAD', requestUrl, null, additionalHeaders || {}); + }); + } + sendStream(verb, requestUrl, stream, additionalHeaders) { + return __awaiter(this, void 0, void 0, function* () { + return this.request(verb, requestUrl, stream, additionalHeaders); + }); + } + /** + * Gets a typed object from an endpoint + * Be aware that not found returns a null. Other errors (4xx, 5xx) reject the promise + */ + getJson(requestUrl_1) { + return __awaiter(this, arguments, void 0, function* (requestUrl, additionalHeaders = {}) { + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + const res = yield this.get(requestUrl, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + postJson(requestUrl_1, obj_1) { + return __awaiter(this, arguments, void 0, function* (requestUrl, obj, additionalHeaders = {}) { + const data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers.ContentType] = + this._getExistingOrDefaultContentTypeHeader(additionalHeaders, MediaTypes.ApplicationJson); + const res = yield this.post(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + putJson(requestUrl_1, obj_1) { + return __awaiter(this, arguments, void 0, function* (requestUrl, obj, additionalHeaders = {}) { + const data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers.ContentType] = + this._getExistingOrDefaultContentTypeHeader(additionalHeaders, MediaTypes.ApplicationJson); + const res = yield this.put(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + patchJson(requestUrl_1, obj_1) { + return __awaiter(this, arguments, void 0, function* (requestUrl, obj, additionalHeaders = {}) { + const data = JSON.stringify(obj, null, 2); + additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson); + additionalHeaders[Headers.ContentType] = + this._getExistingOrDefaultContentTypeHeader(additionalHeaders, MediaTypes.ApplicationJson); + const res = yield this.patch(requestUrl, data, additionalHeaders); + return this._processResponse(res, this.requestOptions); + }); + } + /** + * Makes a raw http request. + * All other methods such as get, post, patch, and request ultimately call this. + * Prefer get, del, post and patch + */ + request(verb, requestUrl, data, headers) { + return __awaiter(this, void 0, void 0, function* () { + if (this._disposed) { + throw new Error('Client has already been disposed.'); + } + const parsedUrl = new URL(requestUrl); + let info = this._prepareRequest(verb, parsedUrl, headers); + // Only perform retries on reads since writes may not be idempotent. + const maxTries = this._allowRetries && RetryableHttpVerbs.includes(verb) + ? this._maxRetries + 1 + : 1; + let numTries = 0; + let response; + do { + response = yield this.requestRaw(info, data); + // Check if it's an authentication challenge + if (response && + response.message && + response.message.statusCode === HttpCodes.Unauthorized) { + let authenticationHandler; + for (const handler of this.handlers) { + if (handler.canHandleAuthentication(response)) { + authenticationHandler = handler; + break; + } + } + if (authenticationHandler) { + return authenticationHandler.handleAuthentication(this, info, data); + } + else { + // We have received an unauthorized response but have no handlers to handle it. + // Let the response return to the caller. + return response; + } + } + let redirectsRemaining = this._maxRedirects; + while (response.message.statusCode && + HttpRedirectCodes.includes(response.message.statusCode) && + this._allowRedirects && + redirectsRemaining > 0) { + const redirectUrl = response.message.headers['location']; + if (!redirectUrl) { + // if there's no location to redirect to, we won't + break; + } + const parsedRedirectUrl = new URL(redirectUrl); + if (parsedUrl.protocol === 'https:' && + parsedUrl.protocol !== parsedRedirectUrl.protocol && + !this._allowRedirectDowngrade) { + throw new Error('Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true.'); + } + // we need to finish reading the response before reassigning response + // which will leak the open socket. + yield response.readBody(); + // strip authorization header if redirected to a different hostname + if (parsedRedirectUrl.hostname !== parsedUrl.hostname) { + for (const header in headers) { + // header names are case insensitive + if (header.toLowerCase() === 'authorization') { + delete headers[header]; + } + } + } + // let's make the request with the new redirectUrl + info = this._prepareRequest(verb, parsedRedirectUrl, headers); + response = yield this.requestRaw(info, data); + redirectsRemaining--; + } + if (!response.message.statusCode || + !HttpResponseRetryCodes.includes(response.message.statusCode)) { + // If not a retry code, return immediately instead of retrying + return response; + } + numTries += 1; + if (numTries < maxTries) { + yield response.readBody(); + yield this._performExponentialBackoff(numTries); + } + } while (numTries < maxTries); + return response; + }); + } + /** + * Needs to be called if keepAlive is set to true in request options. + */ + dispose() { + if (this._agent) { + this._agent.destroy(); + } + this._disposed = true; + } + /** + * Raw request. + * @param info + * @param data + */ + requestRaw(info, data) { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve, reject) => { + function callbackForResult(err, res) { + if (err) { + reject(err); + } + else if (!res) { + // If `err` is not passed, then `res` must be passed. + reject(new Error('Unknown error')); + } + else { + resolve(res); + } + } + this.requestRawWithCallback(info, data, callbackForResult); + }); + }); + } + /** + * Raw request with callback. + * @param info + * @param data + * @param onResult + */ + requestRawWithCallback(info, data, onResult) { + if (typeof data === 'string') { + if (!info.options.headers) { + info.options.headers = {}; + } + info.options.headers['Content-Length'] = Buffer.byteLength(data, 'utf8'); + } + let callbackCalled = false; + function handleResult(err, res) { + if (!callbackCalled) { + callbackCalled = true; + onResult(err, res); + } + } + const req = info.httpModule.request(info.options, (msg) => { + const res = new HttpClientResponse(msg); + handleResult(undefined, res); + }); + let socket; + req.on('socket', sock => { + socket = sock; + }); + // If we ever get disconnected, we want the socket to timeout eventually + req.setTimeout(this._socketTimeout || 3 * 60000, () => { + if (socket) { + socket.end(); + } + handleResult(new Error(`Request timeout: ${info.options.path}`)); + }); + req.on('error', function (err) { + // err has statusCode property + // res should have headers + handleResult(err); + }); + if (data && typeof data === 'string') { + req.write(data, 'utf8'); + } + if (data && typeof data !== 'string') { + data.on('close', function () { + req.end(); + }); + data.pipe(req); + } + else { + req.end(); + } + } + /** + * Gets an http agent. This function is useful when you need an http agent that handles + * routing through a proxy server - depending upon the url and proxy environment variables. + * @param serverUrl The server URL where the request will be sent. For example, https://api.github.com + */ + getAgent(serverUrl) { + const parsedUrl = new URL(serverUrl); + return this._getAgent(parsedUrl); + } + getAgentDispatcher(serverUrl) { + const parsedUrl = new URL(serverUrl); + const proxyUrl = pm.getProxyUrl(parsedUrl); + const useProxy = proxyUrl && proxyUrl.hostname; + if (!useProxy) { + return; + } + return this._getProxyAgentDispatcher(parsedUrl, proxyUrl); + } + _prepareRequest(method, requestUrl, headers) { + const info = {}; + info.parsedUrl = requestUrl; + const usingSsl = info.parsedUrl.protocol === 'https:'; + info.httpModule = usingSsl ? https : http; + const defaultPort = usingSsl ? 443 : 80; + info.options = {}; + info.options.host = info.parsedUrl.hostname; + info.options.port = info.parsedUrl.port + ? parseInt(info.parsedUrl.port) + : defaultPort; + info.options.path = + (info.parsedUrl.pathname || '') + (info.parsedUrl.search || ''); + info.options.method = method; + info.options.headers = this._mergeHeaders(headers); + if (this.userAgent != null) { + info.options.headers['user-agent'] = this.userAgent; + } + info.options.agent = this._getAgent(info.parsedUrl); + // gives handlers an opportunity to participate + if (this.handlers) { + for (const handler of this.handlers) { + handler.prepareRequest(info.options); + } + } + return info; + } + _mergeHeaders(headers) { + if (this.requestOptions && this.requestOptions.headers) { + return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers || {})); + } + return lowercaseKeys(headers || {}); + } + /** + * Gets an existing header value or returns a default. + * Handles converting number header values to strings since HTTP headers must be strings. + * Note: This returns string | string[] since some headers can have multiple values. + * For headers that must always be a single string (like Content-Type), use the + * specialized _getExistingOrDefaultContentTypeHeader method instead. + */ + _getExistingOrDefaultHeader(additionalHeaders, header, _default) { + let clientHeader; + if (this.requestOptions && this.requestOptions.headers) { + const headerValue = lowercaseKeys(this.requestOptions.headers)[header]; + if (headerValue) { + clientHeader = + typeof headerValue === 'number' ? headerValue.toString() : headerValue; + } + } + const additionalValue = additionalHeaders[header]; + if (additionalValue !== undefined) { + return typeof additionalValue === 'number' + ? additionalValue.toString() + : additionalValue; + } + if (clientHeader !== undefined) { + return clientHeader; + } + return _default; + } + /** + * Specialized version of _getExistingOrDefaultHeader for Content-Type header. + * Always returns a single string (not an array) since Content-Type should be a single value. + * Converts arrays to comma-separated strings and numbers to strings to ensure type safety. + * This was split from _getExistingOrDefaultHeader to provide stricter typing for callers + * that assign the result to places expecting a string (e.g., additionalHeaders[Headers.ContentType]). + */ + _getExistingOrDefaultContentTypeHeader(additionalHeaders, _default) { + let clientHeader; + if (this.requestOptions && this.requestOptions.headers) { + const headerValue = lowercaseKeys(this.requestOptions.headers)[Headers.ContentType]; + if (headerValue) { + if (typeof headerValue === 'number') { + clientHeader = String(headerValue); + } + else if (Array.isArray(headerValue)) { + clientHeader = headerValue.join(', '); + } + else { + clientHeader = headerValue; + } + } + } + const additionalValue = additionalHeaders[Headers.ContentType]; + // Return the first non-undefined value, converting numbers or arrays to strings if necessary + if (additionalValue !== undefined) { + if (typeof additionalValue === 'number') { + return String(additionalValue); + } + else if (Array.isArray(additionalValue)) { + return additionalValue.join(', '); + } + else { + return additionalValue; + } + } + if (clientHeader !== undefined) { + return clientHeader; + } + return _default; + } + _getAgent(parsedUrl) { + let agent; + const proxyUrl = pm.getProxyUrl(parsedUrl); + const useProxy = proxyUrl && proxyUrl.hostname; + if (this._keepAlive && useProxy) { + agent = this._proxyAgent; + } + if (!useProxy) { + agent = this._agent; + } + // if agent is already assigned use that agent. + if (agent) { + return agent; + } + const usingSsl = parsedUrl.protocol === 'https:'; + let maxSockets = 100; + if (this.requestOptions) { + maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets; + } + // This is `useProxy` again, but we need to check `proxyURl` directly for TypeScripts's flow analysis. + if (proxyUrl && proxyUrl.hostname) { + const agentOptions = { + maxSockets, + keepAlive: this._keepAlive, + proxy: Object.assign(Object.assign({}, ((proxyUrl.username || proxyUrl.password) && { + proxyAuth: `${proxyUrl.username}:${proxyUrl.password}` + })), { host: proxyUrl.hostname, port: proxyUrl.port }) + }; + let tunnelAgent; + const overHttps = proxyUrl.protocol === 'https:'; + if (usingSsl) { + tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp; + } + else { + tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp; + } + agent = tunnelAgent(agentOptions); + this._proxyAgent = agent; + } + // if tunneling agent isn't assigned create a new agent + if (!agent) { + const options = { keepAlive: this._keepAlive, maxSockets }; + agent = usingSsl ? new https.Agent(options) : new http.Agent(options); + this._agent = agent; + } + if (usingSsl && this._ignoreSslError) { + // we don't want to set NODE_TLS_REJECT_UNAUTHORIZED=0 since that will affect request for entire process + // http.RequestOptions doesn't expose a way to modify RequestOptions.agent.options + // we have to cast it to any and change it directly + agent.options = Object.assign(agent.options || {}, { + rejectUnauthorized: false + }); + } + return agent; + } + _getProxyAgentDispatcher(parsedUrl, proxyUrl) { + let proxyAgent; + if (this._keepAlive) { + proxyAgent = this._proxyAgentDispatcher; + } + // if agent is already assigned use that agent. + if (proxyAgent) { + return proxyAgent; + } + const usingSsl = parsedUrl.protocol === 'https:'; + proxyAgent = new undici_1.ProxyAgent(Object.assign({ uri: proxyUrl.href, pipelining: !this._keepAlive ? 0 : 1 }, ((proxyUrl.username || proxyUrl.password) && { + token: `Basic ${Buffer.from(`${proxyUrl.username}:${proxyUrl.password}`).toString('base64')}` + }))); + this._proxyAgentDispatcher = proxyAgent; + if (usingSsl && this._ignoreSslError) { + // we don't want to set NODE_TLS_REJECT_UNAUTHORIZED=0 since that will affect request for entire process + // http.RequestOptions doesn't expose a way to modify RequestOptions.agent.options + // we have to cast it to any and change it directly + proxyAgent.options = Object.assign(proxyAgent.options.requestTls || {}, { + rejectUnauthorized: false + }); + } + return proxyAgent; + } + _getUserAgentWithOrchestrationId(userAgent) { + const baseUserAgent = userAgent || 'actions/http-client'; + const orchId = process.env['ACTIONS_ORCHESTRATION_ID']; + if (orchId) { + // Sanitize the orchestration ID to ensure it contains only valid characters + // Valid characters: 0-9, a-z, _, -, . + const sanitizedId = orchId.replace(/[^a-z0-9_.-]/gi, '_'); + return `${baseUserAgent} actions_orchestration_id/${sanitizedId}`; + } + return baseUserAgent; + } + _performExponentialBackoff(retryNumber) { + return __awaiter(this, void 0, void 0, function* () { + retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber); + const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber); + return new Promise(resolve => setTimeout(() => resolve(), ms)); + }); + } + _processResponse(res, options) { + return __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () { + const statusCode = res.message.statusCode || 0; + const response = { + statusCode, + result: null, + headers: {} + }; + // not found leads to null obj returned + if (statusCode === HttpCodes.NotFound) { + resolve(response); + } + // get the result from the body + function dateTimeDeserializer(key, value) { + if (typeof value === 'string') { + const a = new Date(value); + if (!isNaN(a.valueOf())) { + return a; + } + } + return value; + } + let obj; + let contents; + try { + contents = yield res.readBody(); + if (contents && contents.length > 0) { + if (options && options.deserializeDates) { + obj = JSON.parse(contents, dateTimeDeserializer); + } + else { + obj = JSON.parse(contents); + } + response.result = obj; + } + response.headers = res.message.headers; + } + catch (err) { + // Invalid resource (contents not json); leaving result obj null + } + // note that 3xx redirects are handled by the http layer. + if (statusCode > 299) { + let msg; + // if exception/error in body, attempt to get better error + if (obj && obj.message) { + msg = obj.message; + } + else if (contents && contents.length > 0) { + // it may be the case that the exception is in the body message as string + msg = contents; + } + else { + msg = `Failed request: (${statusCode})`; + } + const err = new HttpClientError(msg, statusCode); + err.result = response.result; + reject(err); + } + else { + resolve(response); + } + })); + }); + } +} +exports.HttpClient = HttpClient; +const lowercaseKeys = (obj) => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {}); +//# sourceMappingURL=index.js.map /***/ }), -/***/ 312: -/***/ (function(module, __unusedexports, __webpack_require__) { - -// Generated by CoffeeScript 1.12.7 -(function() { - var XMLDocument, XMLDocumentCB, XMLStreamWriter, XMLStringWriter, assign, isFunction, ref; - - ref = __webpack_require__(8582), assign = ref.assign, isFunction = ref.isFunction; +/***/ 4988: +/***/ ((__unused_webpack_module, exports) => { - XMLDocument = __webpack_require__(8559); - - XMLDocumentCB = __webpack_require__(9768); - - XMLStringWriter = __webpack_require__(2750); - - XMLStreamWriter = __webpack_require__(3458); +"use strict"; - module.exports.create = function(name, xmldec, doctype, options) { - var doc, root; - if (name == null) { - throw new Error("Root element needs a name"); +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getProxyUrl = getProxyUrl; +exports.checkBypass = checkBypass; +function getProxyUrl(reqUrl) { + const usingSsl = reqUrl.protocol === 'https:'; + if (checkBypass(reqUrl)) { + return undefined; + } + const proxyVar = (() => { + if (usingSsl) { + return process.env['https_proxy'] || process.env['HTTPS_PROXY']; + } + else { + return process.env['http_proxy'] || process.env['HTTP_PROXY']; + } + })(); + if (proxyVar) { + try { + return new DecodedURL(proxyVar); + } + catch (_a) { + if (!proxyVar.startsWith('http://') && !proxyVar.startsWith('https://')) + return new DecodedURL(`http://${proxyVar}`); + } } - options = assign({}, xmldec, doctype, options); - doc = new XMLDocument(options); - root = doc.element(name); - if (!options.headless) { - doc.declaration(options); - if ((options.pubID != null) || (options.sysID != null)) { - doc.doctype(options); - } + else { + return undefined; } - return root; - }; - - module.exports.begin = function(options, onData, onEnd) { - var ref1; - if (isFunction(options)) { - ref1 = [options, onData], onData = ref1[0], onEnd = ref1[1]; - options = {}; +} +function checkBypass(reqUrl) { + if (!reqUrl.hostname) { + return false; } - if (onData) { - return new XMLDocumentCB(options, onData, onEnd); - } else { - return new XMLDocument(options); + const reqHost = reqUrl.hostname; + if (isLoopbackAddress(reqHost)) { + return true; } - }; - - module.exports.stringWriter = function(options) { - return new XMLStringWriter(options); - }; + const noProxy = process.env['no_proxy'] || process.env['NO_PROXY'] || ''; + if (!noProxy) { + return false; + } + // Determine the request port + let reqPort; + if (reqUrl.port) { + reqPort = Number(reqUrl.port); + } + else if (reqUrl.protocol === 'http:') { + reqPort = 80; + } + else if (reqUrl.protocol === 'https:') { + reqPort = 443; + } + // Format the request hostname and hostname with port + const upperReqHosts = [reqUrl.hostname.toUpperCase()]; + if (typeof reqPort === 'number') { + upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`); + } + // Compare request host against noproxy + for (const upperNoProxyItem of noProxy + .split(',') + .map(x => x.trim().toUpperCase()) + .filter(x => x)) { + if (upperNoProxyItem === '*' || + upperReqHosts.some(x => x === upperNoProxyItem || + x.endsWith(`.${upperNoProxyItem}`) || + (upperNoProxyItem.startsWith('.') && + x.endsWith(`${upperNoProxyItem}`)))) { + return true; + } + } + return false; +} +function isLoopbackAddress(host) { + const hostLower = host.toLowerCase(); + return (hostLower === 'localhost' || + hostLower.startsWith('127.') || + hostLower.startsWith('[::1]') || + hostLower.startsWith('[0:0:0:0:0:0:0:1]')); +} +class DecodedURL extends URL { + constructor(url, base) { + super(url, base); + this._decodedUsername = decodeURIComponent(super.username); + this._decodedPassword = decodeURIComponent(super.password); + } + get username() { + return this._decodedUsername; + } + get password() { + return this._decodedPassword; + } +} +//# sourceMappingURL=proxy.js.map - module.exports.streamWriter = function(stream, options) { - return new XMLStreamWriter(stream, options); - }; +/***/ }), -}).call(this); +/***/ 5207: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { +"use strict"; -/***/ }), - -/***/ 320: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2019-07-11","endpointPrefix":"session.qldb","jsonVersion":"1.0","protocol":"json","serviceAbbreviation":"QLDB Session","serviceFullName":"Amazon QLDB Session","serviceId":"QLDB Session","signatureVersion":"v4","signingName":"qldb","targetPrefix":"QLDBSession","uid":"qldb-session-2019-07-11"},"operations":{"SendCommand":{"input":{"type":"structure","members":{"SessionToken":{},"StartSession":{"type":"structure","required":["LedgerName"],"members":{"LedgerName":{}}},"StartTransaction":{"type":"structure","members":{}},"EndSession":{"type":"structure","members":{}},"CommitTransaction":{"type":"structure","required":["TransactionId","CommitDigest"],"members":{"TransactionId":{},"CommitDigest":{"type":"blob"}}},"AbortTransaction":{"type":"structure","members":{}},"ExecuteStatement":{"type":"structure","required":["TransactionId","Statement"],"members":{"TransactionId":{},"Statement":{},"Parameters":{"type":"list","member":{"shape":"Se"}}}},"FetchPage":{"type":"structure","required":["TransactionId","NextPageToken"],"members":{"TransactionId":{},"NextPageToken":{}}}}},"output":{"type":"structure","members":{"StartSession":{"type":"structure","members":{"SessionToken":{}}},"StartTransaction":{"type":"structure","members":{"TransactionId":{}}},"EndSession":{"type":"structure","members":{}},"CommitTransaction":{"type":"structure","members":{"TransactionId":{},"CommitDigest":{"type":"blob"}}},"AbortTransaction":{"type":"structure","members":{}},"ExecuteStatement":{"type":"structure","members":{"FirstPage":{"shape":"Sq"}}},"FetchPage":{"type":"structure","members":{"Page":{"shape":"Sq"}}}}}}},"shapes":{"Se":{"type":"structure","members":{"IonBinary":{"type":"blob"},"IonText":{}}},"Sq":{"type":"structure","members":{"Values":{"type":"list","member":{"shape":"Se"}},"NextPageToken":{}}}}}; - -/***/ }), - -/***/ 324: -/***/ (function(module) { - -module.exports = {"pagination":{"ListTerminologies":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"ListTextTranslationJobs":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"}}}; +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; + }; +})(); +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var _a; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.READONLY = exports.UV_FS_O_EXLOCK = exports.IS_WINDOWS = exports.unlink = exports.symlink = exports.stat = exports.rmdir = exports.rm = exports.rename = exports.readdir = exports.open = exports.mkdir = exports.lstat = exports.copyFile = exports.chmod = void 0; +exports.readlink = readlink; +exports.exists = exists; +exports.isDirectory = isDirectory; +exports.isRooted = isRooted; +exports.tryGetExecutablePath = tryGetExecutablePath; +exports.getCmdPath = getCmdPath; +const fs = __importStar(__nccwpck_require__(9896)); +const path = __importStar(__nccwpck_require__(6928)); +_a = fs.promises +// export const {open} = 'fs' +, exports.chmod = _a.chmod, exports.copyFile = _a.copyFile, exports.lstat = _a.lstat, exports.mkdir = _a.mkdir, exports.open = _a.open, exports.readdir = _a.readdir, exports.rename = _a.rename, exports.rm = _a.rm, exports.rmdir = _a.rmdir, exports.stat = _a.stat, exports.symlink = _a.symlink, exports.unlink = _a.unlink; +// export const {open} = 'fs' +exports.IS_WINDOWS = process.platform === 'win32'; +/** + * Custom implementation of readlink to ensure Windows junctions + * maintain trailing backslash for backward compatibility with Node.js < 24 + * + * In Node.js 20, Windows junctions (directory symlinks) always returned paths + * with trailing backslashes. Node.js 24 removed this behavior, which breaks + * code that relied on this format for path operations. + * + * This implementation restores the Node 20 behavior by adding a trailing + * backslash to all junction results on Windows. + */ +function readlink(fsPath) { + return __awaiter(this, void 0, void 0, function* () { + const result = yield fs.promises.readlink(fsPath); + // On Windows, restore Node 20 behavior: add trailing backslash to all results + // since junctions on Windows are always directory links + if (exports.IS_WINDOWS && !result.endsWith('\\')) { + return `${result}\\`; + } + return result; + }); +} +// See https://github.com/nodejs/node/blob/d0153aee367422d0858105abec186da4dff0a0c5/deps/uv/include/uv/win.h#L691 +exports.UV_FS_O_EXLOCK = 0x10000000; +exports.READONLY = fs.constants.O_RDONLY; +function exists(fsPath) { + return __awaiter(this, void 0, void 0, function* () { + try { + yield (0, exports.stat)(fsPath); + } + catch (err) { + if (err.code === 'ENOENT') { + return false; + } + throw err; + } + return true; + }); +} +function isDirectory(fsPath_1) { + return __awaiter(this, arguments, void 0, function* (fsPath, useStat = false) { + const stats = useStat ? yield (0, exports.stat)(fsPath) : yield (0, exports.lstat)(fsPath); + return stats.isDirectory(); + }); +} +/** + * On OSX/Linux, true if path starts with '/'. On Windows, true for paths like: + * \, \hello, \\hello\share, C:, and C:\hello (and corresponding alternate separator cases). + */ +function isRooted(p) { + p = normalizeSeparators(p); + if (!p) { + throw new Error('isRooted() parameter "p" cannot be empty'); + } + if (exports.IS_WINDOWS) { + return (p.startsWith('\\') || /^[A-Z]:/i.test(p) // e.g. \ or \hello or \\hello + ); // e.g. C: or C:\hello + } + return p.startsWith('/'); +} +/** + * Best effort attempt to determine whether a file exists and is executable. + * @param filePath file path to check + * @param extensions additional file extensions to try + * @return if file exists and is executable, returns the file path. otherwise empty string. + */ +function tryGetExecutablePath(filePath, extensions) { + return __awaiter(this, void 0, void 0, function* () { + let stats = undefined; + try { + // test file exists + stats = yield (0, exports.stat)(filePath); + } + catch (err) { + if (err.code !== 'ENOENT') { + // eslint-disable-next-line no-console + console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`); + } + } + if (stats && stats.isFile()) { + if (exports.IS_WINDOWS) { + // on Windows, test for valid extension + const upperExt = path.extname(filePath).toUpperCase(); + if (extensions.some(validExt => validExt.toUpperCase() === upperExt)) { + return filePath; + } + } + else { + if (isUnixExecutable(stats)) { + return filePath; + } + } + } + // try each extension + const originalFilePath = filePath; + for (const extension of extensions) { + filePath = originalFilePath + extension; + stats = undefined; + try { + stats = yield (0, exports.stat)(filePath); + } + catch (err) { + if (err.code !== 'ENOENT') { + // eslint-disable-next-line no-console + console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`); + } + } + if (stats && stats.isFile()) { + if (exports.IS_WINDOWS) { + // preserve the case of the actual file (since an extension was appended) + try { + const directory = path.dirname(filePath); + const upperName = path.basename(filePath).toUpperCase(); + for (const actualName of yield (0, exports.readdir)(directory)) { + if (upperName === actualName.toUpperCase()) { + filePath = path.join(directory, actualName); + break; + } + } + } + catch (err) { + // eslint-disable-next-line no-console + console.log(`Unexpected error attempting to determine the actual case of the file '${filePath}': ${err}`); + } + return filePath; + } + else { + if (isUnixExecutable(stats)) { + return filePath; + } + } + } + } + return ''; + }); +} +function normalizeSeparators(p) { + p = p || ''; + if (exports.IS_WINDOWS) { + // convert slashes on Windows + p = p.replace(/\//g, '\\'); + // remove redundant slashes + return p.replace(/\\\\+/g, '\\'); + } + // remove redundant slashes + return p.replace(/\/\/+/g, '/'); +} +// on Mac/Linux, test the execute bit +// R W X R W X R W X +// 256 128 64 32 16 8 4 2 1 +function isUnixExecutable(stats) { + return ((stats.mode & 1) > 0 || + ((stats.mode & 8) > 0 && + process.getgid !== undefined && + stats.gid === process.getgid()) || + ((stats.mode & 64) > 0 && + process.getuid !== undefined && + stats.uid === process.getuid())); +} +// Get the path of cmd.exe in windows +function getCmdPath() { + var _a; + return (_a = process.env['COMSPEC']) !== null && _a !== void 0 ? _a : `cmd.exe`; +} +//# sourceMappingURL=io-util.js.map /***/ }), -/***/ 332: -/***/ (function(module, __unusedexports, __webpack_require__) { +/***/ 4994: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +"use strict"; -apiLoader.services['costexplorer'] = {}; -AWS.CostExplorer = Service.defineService('costexplorer', ['2017-10-25']); -Object.defineProperty(apiLoader.services['costexplorer'], '2017-10-25', { - get: function get() { - var model = __webpack_require__(6279); - model.paginators = __webpack_require__(8755).pagination; - return model; - }, - enumerable: true, - configurable: true +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; }); - -module.exports = AWS.CostExplorer; - +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; + }; +})(); +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.cp = cp; +exports.mv = mv; +exports.rmRF = rmRF; +exports.mkdirP = mkdirP; +exports.which = which; +exports.findInPath = findInPath; +const assert_1 = __nccwpck_require__(2613); +const path = __importStar(__nccwpck_require__(6928)); +const ioUtil = __importStar(__nccwpck_require__(5207)); +/** + * Copies a file or folder. + * Based off of shelljs - https://github.com/shelljs/shelljs/blob/9237f66c52e5daa40458f94f9565e18e8132f5a6/src/cp.js + * + * @param source source path + * @param dest destination path + * @param options optional. See CopyOptions. + */ +function cp(source_1, dest_1) { + return __awaiter(this, arguments, void 0, function* (source, dest, options = {}) { + const { force, recursive, copySourceDirectory } = readCopyOptions(options); + const destStat = (yield ioUtil.exists(dest)) ? yield ioUtil.stat(dest) : null; + // Dest is an existing file, but not forcing + if (destStat && destStat.isFile() && !force) { + return; + } + // If dest is an existing directory, should copy inside. + const newDest = destStat && destStat.isDirectory() && copySourceDirectory + ? path.join(dest, path.basename(source)) + : dest; + if (!(yield ioUtil.exists(source))) { + throw new Error(`no such file or directory: ${source}`); + } + const sourceStat = yield ioUtil.stat(source); + if (sourceStat.isDirectory()) { + if (!recursive) { + throw new Error(`Failed to copy. ${source} is a directory, but tried to copy without recursive flag.`); + } + else { + yield cpDirRecursive(source, newDest, 0, force); + } + } + else { + if (path.relative(source, newDest) === '') { + // a file cannot be copied to itself + throw new Error(`'${newDest}' and '${source}' are the same file`); + } + yield copyFile(source, newDest, force); + } + }); +} +/** + * Moves a path. + * + * @param source source path + * @param dest destination path + * @param options optional. See MoveOptions. + */ +function mv(source_1, dest_1) { + return __awaiter(this, arguments, void 0, function* (source, dest, options = {}) { + if (yield ioUtil.exists(dest)) { + let destExists = true; + if (yield ioUtil.isDirectory(dest)) { + // If dest is directory copy src into dest + dest = path.join(dest, path.basename(source)); + destExists = yield ioUtil.exists(dest); + } + if (destExists) { + if (options.force == null || options.force) { + yield rmRF(dest); + } + else { + throw new Error('Destination already exists'); + } + } + } + yield mkdirP(path.dirname(dest)); + yield ioUtil.rename(source, dest); + }); +} +/** + * Remove a path recursively with force + * + * @param inputPath path to remove + */ +function rmRF(inputPath) { + return __awaiter(this, void 0, void 0, function* () { + if (ioUtil.IS_WINDOWS) { + // Check for invalid characters + // https://docs.microsoft.com/en-us/windows/win32/fileio/naming-a-file + if (/[*"<>|]/.test(inputPath)) { + throw new Error('File path must not contain `*`, `"`, `<`, `>` or `|` on Windows'); + } + } + try { + // note if path does not exist, error is silent + yield ioUtil.rm(inputPath, { + force: true, + maxRetries: 3, + recursive: true, + retryDelay: 300 + }); + } + catch (err) { + throw new Error(`File was unable to be removed ${err}`); + } + }); +} +/** + * Make a directory. Creates the full path with folders in between + * Will throw if it fails + * + * @param fsPath path to create + * @returns Promise + */ +function mkdirP(fsPath) { + return __awaiter(this, void 0, void 0, function* () { + (0, assert_1.ok)(fsPath, 'a path argument must be provided'); + yield ioUtil.mkdir(fsPath, { recursive: true }); + }); +} +/** + * Returns path of a tool had the tool actually been invoked. Resolves via paths. + * If you check and the tool does not exist, it will throw. + * + * @param tool name of the tool + * @param check whether to check if tool exists + * @returns Promise path to tool + */ +function which(tool, check) { + return __awaiter(this, void 0, void 0, function* () { + if (!tool) { + throw new Error("parameter 'tool' is required"); + } + // recursive when check=true + if (check) { + const result = yield which(tool, false); + if (!result) { + if (ioUtil.IS_WINDOWS) { + throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also verify the file has a valid extension for an executable file.`); + } + else { + throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also check the file mode to verify the file is executable.`); + } + } + return result; + } + const matches = yield findInPath(tool); + if (matches && matches.length > 0) { + return matches[0]; + } + return ''; + }); +} +/** + * Returns a list of all occurrences of the given tool on the system path. + * + * @returns Promise the paths of the tool + */ +function findInPath(tool) { + return __awaiter(this, void 0, void 0, function* () { + if (!tool) { + throw new Error("parameter 'tool' is required"); + } + // build the list of extensions to try + const extensions = []; + if (ioUtil.IS_WINDOWS && process.env['PATHEXT']) { + for (const extension of process.env['PATHEXT'].split(path.delimiter)) { + if (extension) { + extensions.push(extension); + } + } + } + // if it's rooted, return it if exists. otherwise return empty. + if (ioUtil.isRooted(tool)) { + const filePath = yield ioUtil.tryGetExecutablePath(tool, extensions); + if (filePath) { + return [filePath]; + } + return []; + } + // if any path separators, return empty + if (tool.includes(path.sep)) { + return []; + } + // build the list of directories + // + // Note, technically "where" checks the current directory on Windows. From a toolkit perspective, + // it feels like we should not do this. Checking the current directory seems like more of a use + // case of a shell, and the which() function exposed by the toolkit should strive for consistency + // across platforms. + const directories = []; + if (process.env.PATH) { + for (const p of process.env.PATH.split(path.delimiter)) { + if (p) { + directories.push(p); + } + } + } + // find all matches + const matches = []; + for (const directory of directories) { + const filePath = yield ioUtil.tryGetExecutablePath(path.join(directory, tool), extensions); + if (filePath) { + matches.push(filePath); + } + } + return matches; + }); +} +function readCopyOptions(options) { + const force = options.force == null ? true : options.force; + const recursive = Boolean(options.recursive); + const copySourceDirectory = options.copySourceDirectory == null + ? true + : Boolean(options.copySourceDirectory); + return { force, recursive, copySourceDirectory }; +} +function cpDirRecursive(sourceDir, destDir, currentDepth, force) { + return __awaiter(this, void 0, void 0, function* () { + // Ensure there is not a run away recursive copy + if (currentDepth >= 255) + return; + currentDepth++; + yield mkdirP(destDir); + const files = yield ioUtil.readdir(sourceDir); + for (const fileName of files) { + const srcFile = `${sourceDir}/${fileName}`; + const destFile = `${destDir}/${fileName}`; + const srcFileStat = yield ioUtil.lstat(srcFile); + if (srcFileStat.isDirectory()) { + // Recurse + yield cpDirRecursive(srcFile, destFile, currentDepth, force); + } + else { + yield copyFile(srcFile, destFile, force); + } + } + // Change the mode for the newly created directory + yield ioUtil.chmod(destDir, (yield ioUtil.stat(sourceDir)).mode); + }); +} +// Buffered file copy +function copyFile(srcFile, destFile, force) { + return __awaiter(this, void 0, void 0, function* () { + if ((yield ioUtil.lstat(srcFile)).isSymbolicLink()) { + // unlink/re-link it + try { + yield ioUtil.lstat(destFile); + yield ioUtil.unlink(destFile); + } + catch (e) { + // Try to override file permission + if (e.code === 'EPERM') { + yield ioUtil.chmod(destFile, '0666'); + yield ioUtil.unlink(destFile); + } + // other errors = it doesn't exist, no work to do + } + // Copy over symlink + const symlinkFull = yield ioUtil.readlink(srcFile); + yield ioUtil.symlink(symlinkFull, destFile, ioUtil.IS_WINDOWS ? 'junction' : null); + } + else if (!(yield ioUtil.exists(destFile)) || force) { + yield ioUtil.copyFile(srcFile, destFile); + } + }); +} +//# sourceMappingURL=io.js.map /***/ }), -/***/ 337: -/***/ (function(module, __unusedexports, __webpack_require__) { - -var util = __webpack_require__(153); +/***/ 398: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -function JsonBuilder() { } +"use strict"; -JsonBuilder.prototype.build = function(value, shape) { - return JSON.stringify(translate(value, shape)); +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.resolveHttpAuthSchemeConfig = exports.defaultCloudFormationHttpAuthSchemeProvider = exports.defaultCloudFormationHttpAuthSchemeParametersProvider = void 0; +const core_1 = __nccwpck_require__(8704); +const util_middleware_1 = __nccwpck_require__(6324); +const defaultCloudFormationHttpAuthSchemeParametersProvider = async (config, context, input) => { + return { + operation: (0, util_middleware_1.getSmithyContext)(context).operation, + region: (await (0, util_middleware_1.normalizeProvider)(config.region)()) || + (() => { + throw new Error("expected `region` to be configured for `aws.auth#sigv4`"); + })(), + }; }; - -function translate(value, shape) { - if (!shape || value === undefined || value === null) return undefined; - - switch (shape.type) { - case 'structure': return translateStructure(value, shape); - case 'map': return translateMap(value, shape); - case 'list': return translateList(value, shape); - default: return translateScalar(value, shape); - } +exports.defaultCloudFormationHttpAuthSchemeParametersProvider = defaultCloudFormationHttpAuthSchemeParametersProvider; +function createAwsAuthSigv4HttpAuthOption(authParameters) { + return { + schemeId: "aws.auth#sigv4", + signingProperties: { + name: "cloudformation", + region: authParameters.region, + }, + propertiesExtractor: (config, context) => ({ + signingProperties: { + config, + context, + }, + }), + }; } - -function translateStructure(structure, shape) { - var struct = {}; - util.each(structure, function(name, value) { - var memberShape = shape.members[name]; - if (memberShape) { - if (memberShape.location !== 'body') return; - var locationName = memberShape.isLocationName ? memberShape.name : name; - var result = translate(value, memberShape); - if (result !== undefined) struct[locationName] = result; +const defaultCloudFormationHttpAuthSchemeProvider = (authParameters) => { + const options = []; + switch (authParameters.operation) { + default: { + options.push(createAwsAuthSigv4HttpAuthOption(authParameters)); + } } - }); - return struct; -} + return options; +}; +exports.defaultCloudFormationHttpAuthSchemeProvider = defaultCloudFormationHttpAuthSchemeProvider; +const resolveHttpAuthSchemeConfig = (config) => { + const config_0 = (0, core_1.resolveAwsSdkSigV4Config)(config); + return Object.assign(config_0, { + authSchemePreference: (0, util_middleware_1.normalizeProvider)(config.authSchemePreference ?? []), + }); +}; +exports.resolveHttpAuthSchemeConfig = resolveHttpAuthSchemeConfig; -function translateList(list, shape) { - var out = []; - util.arrayEach(list, function(value) { - var result = translate(value, shape.member); - if (result !== undefined) out.push(result); - }); - return out; -} -function translateMap(map, shape) { - var out = {}; - util.each(map, function(key, value) { - var result = translate(value, shape.value); - if (result !== undefined) out[key] = result; - }); - return out; -} +/***/ }), -function translateScalar(value, shape) { - return shape.toWireFormat(value); -} +/***/ 2840: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -/** - * @api private - */ -module.exports = JsonBuilder; +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.defaultEndpointResolver = void 0; +const util_endpoints_1 = __nccwpck_require__(3068); +const util_endpoints_2 = __nccwpck_require__(9674); +const ruleset_1 = __nccwpck_require__(8437); +const cache = new util_endpoints_2.EndpointCache({ + size: 50, + params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"], +}); +const defaultEndpointResolver = (endpointParams, context = {}) => { + return cache.get(endpointParams, () => (0, util_endpoints_2.resolveEndpoint)(ruleset_1.ruleSet, { + endpointParams: endpointParams, + logger: context.logger, + })); +}; +exports.defaultEndpointResolver = defaultEndpointResolver; +util_endpoints_2.customEndpointFunctions.aws = util_endpoints_1.awsEndpointFunctions; /***/ }), -/***/ 349: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2010-12-01","endpointPrefix":"email","protocol":"query","serviceAbbreviation":"Amazon SES","serviceFullName":"Amazon Simple Email Service","serviceId":"SES","signatureVersion":"v4","signingName":"ses","uid":"email-2010-12-01","xmlNamespace":"http://ses.amazonaws.com/doc/2010-12-01/"},"operations":{"CloneReceiptRuleSet":{"input":{"type":"structure","required":["RuleSetName","OriginalRuleSetName"],"members":{"RuleSetName":{},"OriginalRuleSetName":{}}},"output":{"resultWrapper":"CloneReceiptRuleSetResult","type":"structure","members":{}}},"CreateConfigurationSet":{"input":{"type":"structure","required":["ConfigurationSet"],"members":{"ConfigurationSet":{"shape":"S5"}}},"output":{"resultWrapper":"CreateConfigurationSetResult","type":"structure","members":{}}},"CreateConfigurationSetEventDestination":{"input":{"type":"structure","required":["ConfigurationSetName","EventDestination"],"members":{"ConfigurationSetName":{},"EventDestination":{"shape":"S9"}}},"output":{"resultWrapper":"CreateConfigurationSetEventDestinationResult","type":"structure","members":{}}},"CreateConfigurationSetTrackingOptions":{"input":{"type":"structure","required":["ConfigurationSetName","TrackingOptions"],"members":{"ConfigurationSetName":{},"TrackingOptions":{"shape":"Sp"}}},"output":{"resultWrapper":"CreateConfigurationSetTrackingOptionsResult","type":"structure","members":{}}},"CreateCustomVerificationEmailTemplate":{"input":{"type":"structure","required":["TemplateName","FromEmailAddress","TemplateSubject","TemplateContent","SuccessRedirectionURL","FailureRedirectionURL"],"members":{"TemplateName":{},"FromEmailAddress":{},"TemplateSubject":{},"TemplateContent":{},"SuccessRedirectionURL":{},"FailureRedirectionURL":{}}}},"CreateReceiptFilter":{"input":{"type":"structure","required":["Filter"],"members":{"Filter":{"shape":"S10"}}},"output":{"resultWrapper":"CreateReceiptFilterResult","type":"structure","members":{}}},"CreateReceiptRule":{"input":{"type":"structure","required":["RuleSetName","Rule"],"members":{"RuleSetName":{},"After":{},"Rule":{"shape":"S18"}}},"output":{"resultWrapper":"CreateReceiptRuleResult","type":"structure","members":{}}},"CreateReceiptRuleSet":{"input":{"type":"structure","required":["RuleSetName"],"members":{"RuleSetName":{}}},"output":{"resultWrapper":"CreateReceiptRuleSetResult","type":"structure","members":{}}},"CreateTemplate":{"input":{"type":"structure","required":["Template"],"members":{"Template":{"shape":"S20"}}},"output":{"resultWrapper":"CreateTemplateResult","type":"structure","members":{}}},"DeleteConfigurationSet":{"input":{"type":"structure","required":["ConfigurationSetName"],"members":{"ConfigurationSetName":{}}},"output":{"resultWrapper":"DeleteConfigurationSetResult","type":"structure","members":{}}},"DeleteConfigurationSetEventDestination":{"input":{"type":"structure","required":["ConfigurationSetName","EventDestinationName"],"members":{"ConfigurationSetName":{},"EventDestinationName":{}}},"output":{"resultWrapper":"DeleteConfigurationSetEventDestinationResult","type":"structure","members":{}}},"DeleteConfigurationSetTrackingOptions":{"input":{"type":"structure","required":["ConfigurationSetName"],"members":{"ConfigurationSetName":{}}},"output":{"resultWrapper":"DeleteConfigurationSetTrackingOptionsResult","type":"structure","members":{}}},"DeleteCustomVerificationEmailTemplate":{"input":{"type":"structure","required":["TemplateName"],"members":{"TemplateName":{}}}},"DeleteIdentity":{"input":{"type":"structure","required":["Identity"],"members":{"Identity":{}}},"output":{"resultWrapper":"DeleteIdentityResult","type":"structure","members":{}}},"DeleteIdentityPolicy":{"input":{"type":"structure","required":["Identity","PolicyName"],"members":{"Identity":{},"PolicyName":{}}},"output":{"resultWrapper":"DeleteIdentityPolicyResult","type":"structure","members":{}}},"DeleteReceiptFilter":{"input":{"type":"structure","required":["FilterName"],"members":{"FilterName":{}}},"output":{"resultWrapper":"DeleteReceiptFilterResult","type":"structure","members":{}}},"DeleteReceiptRule":{"input":{"type":"structure","required":["RuleSetName","RuleName"],"members":{"RuleSetName":{},"RuleName":{}}},"output":{"resultWrapper":"DeleteReceiptRuleResult","type":"structure","members":{}}},"DeleteReceiptRuleSet":{"input":{"type":"structure","required":["RuleSetName"],"members":{"RuleSetName":{}}},"output":{"resultWrapper":"DeleteReceiptRuleSetResult","type":"structure","members":{}}},"DeleteTemplate":{"input":{"type":"structure","required":["TemplateName"],"members":{"TemplateName":{}}},"output":{"resultWrapper":"DeleteTemplateResult","type":"structure","members":{}}},"DeleteVerifiedEmailAddress":{"input":{"type":"structure","required":["EmailAddress"],"members":{"EmailAddress":{}}}},"DescribeActiveReceiptRuleSet":{"input":{"type":"structure","members":{}},"output":{"resultWrapper":"DescribeActiveReceiptRuleSetResult","type":"structure","members":{"Metadata":{"shape":"S2t"},"Rules":{"shape":"S2v"}}}},"DescribeConfigurationSet":{"input":{"type":"structure","required":["ConfigurationSetName"],"members":{"ConfigurationSetName":{},"ConfigurationSetAttributeNames":{"type":"list","member":{}}}},"output":{"resultWrapper":"DescribeConfigurationSetResult","type":"structure","members":{"ConfigurationSet":{"shape":"S5"},"EventDestinations":{"type":"list","member":{"shape":"S9"}},"TrackingOptions":{"shape":"Sp"},"DeliveryOptions":{"shape":"S31"},"ReputationOptions":{"type":"structure","members":{"SendingEnabled":{"type":"boolean"},"ReputationMetricsEnabled":{"type":"boolean"},"LastFreshStart":{"type":"timestamp"}}}}}},"DescribeReceiptRule":{"input":{"type":"structure","required":["RuleSetName","RuleName"],"members":{"RuleSetName":{},"RuleName":{}}},"output":{"resultWrapper":"DescribeReceiptRuleResult","type":"structure","members":{"Rule":{"shape":"S18"}}}},"DescribeReceiptRuleSet":{"input":{"type":"structure","required":["RuleSetName"],"members":{"RuleSetName":{}}},"output":{"resultWrapper":"DescribeReceiptRuleSetResult","type":"structure","members":{"Metadata":{"shape":"S2t"},"Rules":{"shape":"S2v"}}}},"GetAccountSendingEnabled":{"output":{"resultWrapper":"GetAccountSendingEnabledResult","type":"structure","members":{"Enabled":{"type":"boolean"}}}},"GetCustomVerificationEmailTemplate":{"input":{"type":"structure","required":["TemplateName"],"members":{"TemplateName":{}}},"output":{"resultWrapper":"GetCustomVerificationEmailTemplateResult","type":"structure","members":{"TemplateName":{},"FromEmailAddress":{},"TemplateSubject":{},"TemplateContent":{},"SuccessRedirectionURL":{},"FailureRedirectionURL":{}}}},"GetIdentityDkimAttributes":{"input":{"type":"structure","required":["Identities"],"members":{"Identities":{"shape":"S3c"}}},"output":{"resultWrapper":"GetIdentityDkimAttributesResult","type":"structure","required":["DkimAttributes"],"members":{"DkimAttributes":{"type":"map","key":{},"value":{"type":"structure","required":["DkimEnabled","DkimVerificationStatus"],"members":{"DkimEnabled":{"type":"boolean"},"DkimVerificationStatus":{},"DkimTokens":{"shape":"S3h"}}}}}}},"GetIdentityMailFromDomainAttributes":{"input":{"type":"structure","required":["Identities"],"members":{"Identities":{"shape":"S3c"}}},"output":{"resultWrapper":"GetIdentityMailFromDomainAttributesResult","type":"structure","required":["MailFromDomainAttributes"],"members":{"MailFromDomainAttributes":{"type":"map","key":{},"value":{"type":"structure","required":["MailFromDomain","MailFromDomainStatus","BehaviorOnMXFailure"],"members":{"MailFromDomain":{},"MailFromDomainStatus":{},"BehaviorOnMXFailure":{}}}}}}},"GetIdentityNotificationAttributes":{"input":{"type":"structure","required":["Identities"],"members":{"Identities":{"shape":"S3c"}}},"output":{"resultWrapper":"GetIdentityNotificationAttributesResult","type":"structure","required":["NotificationAttributes"],"members":{"NotificationAttributes":{"type":"map","key":{},"value":{"type":"structure","required":["BounceTopic","ComplaintTopic","DeliveryTopic","ForwardingEnabled"],"members":{"BounceTopic":{},"ComplaintTopic":{},"DeliveryTopic":{},"ForwardingEnabled":{"type":"boolean"},"HeadersInBounceNotificationsEnabled":{"type":"boolean"},"HeadersInComplaintNotificationsEnabled":{"type":"boolean"},"HeadersInDeliveryNotificationsEnabled":{"type":"boolean"}}}}}}},"GetIdentityPolicies":{"input":{"type":"structure","required":["Identity","PolicyNames"],"members":{"Identity":{},"PolicyNames":{"shape":"S3w"}}},"output":{"resultWrapper":"GetIdentityPoliciesResult","type":"structure","required":["Policies"],"members":{"Policies":{"type":"map","key":{},"value":{}}}}},"GetIdentityVerificationAttributes":{"input":{"type":"structure","required":["Identities"],"members":{"Identities":{"shape":"S3c"}}},"output":{"resultWrapper":"GetIdentityVerificationAttributesResult","type":"structure","required":["VerificationAttributes"],"members":{"VerificationAttributes":{"type":"map","key":{},"value":{"type":"structure","required":["VerificationStatus"],"members":{"VerificationStatus":{},"VerificationToken":{}}}}}}},"GetSendQuota":{"output":{"resultWrapper":"GetSendQuotaResult","type":"structure","members":{"Max24HourSend":{"type":"double"},"MaxSendRate":{"type":"double"},"SentLast24Hours":{"type":"double"}}}},"GetSendStatistics":{"output":{"resultWrapper":"GetSendStatisticsResult","type":"structure","members":{"SendDataPoints":{"type":"list","member":{"type":"structure","members":{"Timestamp":{"type":"timestamp"},"DeliveryAttempts":{"type":"long"},"Bounces":{"type":"long"},"Complaints":{"type":"long"},"Rejects":{"type":"long"}}}}}}},"GetTemplate":{"input":{"type":"structure","required":["TemplateName"],"members":{"TemplateName":{}}},"output":{"resultWrapper":"GetTemplateResult","type":"structure","members":{"Template":{"shape":"S20"}}}},"ListConfigurationSets":{"input":{"type":"structure","members":{"NextToken":{},"MaxItems":{"type":"integer"}}},"output":{"resultWrapper":"ListConfigurationSetsResult","type":"structure","members":{"ConfigurationSets":{"type":"list","member":{"shape":"S5"}},"NextToken":{}}}},"ListCustomVerificationEmailTemplates":{"input":{"type":"structure","members":{"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"resultWrapper":"ListCustomVerificationEmailTemplatesResult","type":"structure","members":{"CustomVerificationEmailTemplates":{"type":"list","member":{"type":"structure","members":{"TemplateName":{},"FromEmailAddress":{},"TemplateSubject":{},"SuccessRedirectionURL":{},"FailureRedirectionURL":{}}}},"NextToken":{}}}},"ListIdentities":{"input":{"type":"structure","members":{"IdentityType":{},"NextToken":{},"MaxItems":{"type":"integer"}}},"output":{"resultWrapper":"ListIdentitiesResult","type":"structure","required":["Identities"],"members":{"Identities":{"shape":"S3c"},"NextToken":{}}}},"ListIdentityPolicies":{"input":{"type":"structure","required":["Identity"],"members":{"Identity":{}}},"output":{"resultWrapper":"ListIdentityPoliciesResult","type":"structure","required":["PolicyNames"],"members":{"PolicyNames":{"shape":"S3w"}}}},"ListReceiptFilters":{"input":{"type":"structure","members":{}},"output":{"resultWrapper":"ListReceiptFiltersResult","type":"structure","members":{"Filters":{"type":"list","member":{"shape":"S10"}}}}},"ListReceiptRuleSets":{"input":{"type":"structure","members":{"NextToken":{}}},"output":{"resultWrapper":"ListReceiptRuleSetsResult","type":"structure","members":{"RuleSets":{"type":"list","member":{"shape":"S2t"}},"NextToken":{}}}},"ListTemplates":{"input":{"type":"structure","members":{"NextToken":{},"MaxItems":{"type":"integer"}}},"output":{"resultWrapper":"ListTemplatesResult","type":"structure","members":{"TemplatesMetadata":{"type":"list","member":{"type":"structure","members":{"Name":{},"CreatedTimestamp":{"type":"timestamp"}}}},"NextToken":{}}}},"ListVerifiedEmailAddresses":{"output":{"resultWrapper":"ListVerifiedEmailAddressesResult","type":"structure","members":{"VerifiedEmailAddresses":{"shape":"S54"}}}},"PutConfigurationSetDeliveryOptions":{"input":{"type":"structure","required":["ConfigurationSetName"],"members":{"ConfigurationSetName":{},"DeliveryOptions":{"shape":"S31"}}},"output":{"resultWrapper":"PutConfigurationSetDeliveryOptionsResult","type":"structure","members":{}}},"PutIdentityPolicy":{"input":{"type":"structure","required":["Identity","PolicyName","Policy"],"members":{"Identity":{},"PolicyName":{},"Policy":{}}},"output":{"resultWrapper":"PutIdentityPolicyResult","type":"structure","members":{}}},"ReorderReceiptRuleSet":{"input":{"type":"structure","required":["RuleSetName","RuleNames"],"members":{"RuleSetName":{},"RuleNames":{"type":"list","member":{}}}},"output":{"resultWrapper":"ReorderReceiptRuleSetResult","type":"structure","members":{}}},"SendBounce":{"input":{"type":"structure","required":["OriginalMessageId","BounceSender","BouncedRecipientInfoList"],"members":{"OriginalMessageId":{},"BounceSender":{},"Explanation":{},"MessageDsn":{"type":"structure","required":["ReportingMta"],"members":{"ReportingMta":{},"ArrivalDate":{"type":"timestamp"},"ExtensionFields":{"shape":"S5i"}}},"BouncedRecipientInfoList":{"type":"list","member":{"type":"structure","required":["Recipient"],"members":{"Recipient":{},"RecipientArn":{},"BounceType":{},"RecipientDsnFields":{"type":"structure","required":["Action","Status"],"members":{"FinalRecipient":{},"Action":{},"RemoteMta":{},"Status":{},"DiagnosticCode":{},"LastAttemptDate":{"type":"timestamp"},"ExtensionFields":{"shape":"S5i"}}}}}},"BounceSenderArn":{}}},"output":{"resultWrapper":"SendBounceResult","type":"structure","members":{"MessageId":{}}}},"SendBulkTemplatedEmail":{"input":{"type":"structure","required":["Source","Template","Destinations"],"members":{"Source":{},"SourceArn":{},"ReplyToAddresses":{"shape":"S54"},"ReturnPath":{},"ReturnPathArn":{},"ConfigurationSetName":{},"DefaultTags":{"shape":"S5x"},"Template":{},"TemplateArn":{},"DefaultTemplateData":{},"Destinations":{"type":"list","member":{"type":"structure","required":["Destination"],"members":{"Destination":{"shape":"S64"},"ReplacementTags":{"shape":"S5x"},"ReplacementTemplateData":{}}}}}},"output":{"resultWrapper":"SendBulkTemplatedEmailResult","type":"structure","required":["Status"],"members":{"Status":{"type":"list","member":{"type":"structure","members":{"Status":{},"Error":{},"MessageId":{}}}}}}},"SendCustomVerificationEmail":{"input":{"type":"structure","required":["EmailAddress","TemplateName"],"members":{"EmailAddress":{},"TemplateName":{},"ConfigurationSetName":{}}},"output":{"resultWrapper":"SendCustomVerificationEmailResult","type":"structure","members":{"MessageId":{}}}},"SendEmail":{"input":{"type":"structure","required":["Source","Destination","Message"],"members":{"Source":{},"Destination":{"shape":"S64"},"Message":{"type":"structure","required":["Subject","Body"],"members":{"Subject":{"shape":"S6e"},"Body":{"type":"structure","members":{"Text":{"shape":"S6e"},"Html":{"shape":"S6e"}}}}},"ReplyToAddresses":{"shape":"S54"},"ReturnPath":{},"SourceArn":{},"ReturnPathArn":{},"Tags":{"shape":"S5x"},"ConfigurationSetName":{}}},"output":{"resultWrapper":"SendEmailResult","type":"structure","required":["MessageId"],"members":{"MessageId":{}}}},"SendRawEmail":{"input":{"type":"structure","required":["RawMessage"],"members":{"Source":{},"Destinations":{"shape":"S54"},"RawMessage":{"type":"structure","required":["Data"],"members":{"Data":{"type":"blob"}}},"FromArn":{},"SourceArn":{},"ReturnPathArn":{},"Tags":{"shape":"S5x"},"ConfigurationSetName":{}}},"output":{"resultWrapper":"SendRawEmailResult","type":"structure","required":["MessageId"],"members":{"MessageId":{}}}},"SendTemplatedEmail":{"input":{"type":"structure","required":["Source","Destination","Template","TemplateData"],"members":{"Source":{},"Destination":{"shape":"S64"},"ReplyToAddresses":{"shape":"S54"},"ReturnPath":{},"SourceArn":{},"ReturnPathArn":{},"Tags":{"shape":"S5x"},"ConfigurationSetName":{},"Template":{},"TemplateArn":{},"TemplateData":{}}},"output":{"resultWrapper":"SendTemplatedEmailResult","type":"structure","required":["MessageId"],"members":{"MessageId":{}}}},"SetActiveReceiptRuleSet":{"input":{"type":"structure","members":{"RuleSetName":{}}},"output":{"resultWrapper":"SetActiveReceiptRuleSetResult","type":"structure","members":{}}},"SetIdentityDkimEnabled":{"input":{"type":"structure","required":["Identity","DkimEnabled"],"members":{"Identity":{},"DkimEnabled":{"type":"boolean"}}},"output":{"resultWrapper":"SetIdentityDkimEnabledResult","type":"structure","members":{}}},"SetIdentityFeedbackForwardingEnabled":{"input":{"type":"structure","required":["Identity","ForwardingEnabled"],"members":{"Identity":{},"ForwardingEnabled":{"type":"boolean"}}},"output":{"resultWrapper":"SetIdentityFeedbackForwardingEnabledResult","type":"structure","members":{}}},"SetIdentityHeadersInNotificationsEnabled":{"input":{"type":"structure","required":["Identity","NotificationType","Enabled"],"members":{"Identity":{},"NotificationType":{},"Enabled":{"type":"boolean"}}},"output":{"resultWrapper":"SetIdentityHeadersInNotificationsEnabledResult","type":"structure","members":{}}},"SetIdentityMailFromDomain":{"input":{"type":"structure","required":["Identity"],"members":{"Identity":{},"MailFromDomain":{},"BehaviorOnMXFailure":{}}},"output":{"resultWrapper":"SetIdentityMailFromDomainResult","type":"structure","members":{}}},"SetIdentityNotificationTopic":{"input":{"type":"structure","required":["Identity","NotificationType"],"members":{"Identity":{},"NotificationType":{},"SnsTopic":{}}},"output":{"resultWrapper":"SetIdentityNotificationTopicResult","type":"structure","members":{}}},"SetReceiptRulePosition":{"input":{"type":"structure","required":["RuleSetName","RuleName"],"members":{"RuleSetName":{},"RuleName":{},"After":{}}},"output":{"resultWrapper":"SetReceiptRulePositionResult","type":"structure","members":{}}},"TestRenderTemplate":{"input":{"type":"structure","required":["TemplateName","TemplateData"],"members":{"TemplateName":{},"TemplateData":{}}},"output":{"resultWrapper":"TestRenderTemplateResult","type":"structure","members":{"RenderedTemplate":{}}}},"UpdateAccountSendingEnabled":{"input":{"type":"structure","members":{"Enabled":{"type":"boolean"}}}},"UpdateConfigurationSetEventDestination":{"input":{"type":"structure","required":["ConfigurationSetName","EventDestination"],"members":{"ConfigurationSetName":{},"EventDestination":{"shape":"S9"}}},"output":{"resultWrapper":"UpdateConfigurationSetEventDestinationResult","type":"structure","members":{}}},"UpdateConfigurationSetReputationMetricsEnabled":{"input":{"type":"structure","required":["ConfigurationSetName","Enabled"],"members":{"ConfigurationSetName":{},"Enabled":{"type":"boolean"}}}},"UpdateConfigurationSetSendingEnabled":{"input":{"type":"structure","required":["ConfigurationSetName","Enabled"],"members":{"ConfigurationSetName":{},"Enabled":{"type":"boolean"}}}},"UpdateConfigurationSetTrackingOptions":{"input":{"type":"structure","required":["ConfigurationSetName","TrackingOptions"],"members":{"ConfigurationSetName":{},"TrackingOptions":{"shape":"Sp"}}},"output":{"resultWrapper":"UpdateConfigurationSetTrackingOptionsResult","type":"structure","members":{}}},"UpdateCustomVerificationEmailTemplate":{"input":{"type":"structure","required":["TemplateName"],"members":{"TemplateName":{},"FromEmailAddress":{},"TemplateSubject":{},"TemplateContent":{},"SuccessRedirectionURL":{},"FailureRedirectionURL":{}}}},"UpdateReceiptRule":{"input":{"type":"structure","required":["RuleSetName","Rule"],"members":{"RuleSetName":{},"Rule":{"shape":"S18"}}},"output":{"resultWrapper":"UpdateReceiptRuleResult","type":"structure","members":{}}},"UpdateTemplate":{"input":{"type":"structure","required":["Template"],"members":{"Template":{"shape":"S20"}}},"output":{"resultWrapper":"UpdateTemplateResult","type":"structure","members":{}}},"VerifyDomainDkim":{"input":{"type":"structure","required":["Domain"],"members":{"Domain":{}}},"output":{"resultWrapper":"VerifyDomainDkimResult","type":"structure","required":["DkimTokens"],"members":{"DkimTokens":{"shape":"S3h"}}}},"VerifyDomainIdentity":{"input":{"type":"structure","required":["Domain"],"members":{"Domain":{}}},"output":{"resultWrapper":"VerifyDomainIdentityResult","type":"structure","required":["VerificationToken"],"members":{"VerificationToken":{}}}},"VerifyEmailAddress":{"input":{"type":"structure","required":["EmailAddress"],"members":{"EmailAddress":{}}}},"VerifyEmailIdentity":{"input":{"type":"structure","required":["EmailAddress"],"members":{"EmailAddress":{}}},"output":{"resultWrapper":"VerifyEmailIdentityResult","type":"structure","members":{}}}},"shapes":{"S5":{"type":"structure","required":["Name"],"members":{"Name":{}}},"S9":{"type":"structure","required":["Name","MatchingEventTypes"],"members":{"Name":{},"Enabled":{"type":"boolean"},"MatchingEventTypes":{"type":"list","member":{}},"KinesisFirehoseDestination":{"type":"structure","required":["IAMRoleARN","DeliveryStreamARN"],"members":{"IAMRoleARN":{},"DeliveryStreamARN":{}}},"CloudWatchDestination":{"type":"structure","required":["DimensionConfigurations"],"members":{"DimensionConfigurations":{"type":"list","member":{"type":"structure","required":["DimensionName","DimensionValueSource","DefaultDimensionValue"],"members":{"DimensionName":{},"DimensionValueSource":{},"DefaultDimensionValue":{}}}}}},"SNSDestination":{"type":"structure","required":["TopicARN"],"members":{"TopicARN":{}}}}},"Sp":{"type":"structure","members":{"CustomRedirectDomain":{}}},"S10":{"type":"structure","required":["Name","IpFilter"],"members":{"Name":{},"IpFilter":{"type":"structure","required":["Policy","Cidr"],"members":{"Policy":{},"Cidr":{}}}}},"S18":{"type":"structure","required":["Name"],"members":{"Name":{},"Enabled":{"type":"boolean"},"TlsPolicy":{},"Recipients":{"type":"list","member":{}},"Actions":{"type":"list","member":{"type":"structure","members":{"S3Action":{"type":"structure","required":["BucketName"],"members":{"TopicArn":{},"BucketName":{},"ObjectKeyPrefix":{},"KmsKeyArn":{}}},"BounceAction":{"type":"structure","required":["SmtpReplyCode","Message","Sender"],"members":{"TopicArn":{},"SmtpReplyCode":{},"StatusCode":{},"Message":{},"Sender":{}}},"WorkmailAction":{"type":"structure","required":["OrganizationArn"],"members":{"TopicArn":{},"OrganizationArn":{}}},"LambdaAction":{"type":"structure","required":["FunctionArn"],"members":{"TopicArn":{},"FunctionArn":{},"InvocationType":{}}},"StopAction":{"type":"structure","required":["Scope"],"members":{"Scope":{},"TopicArn":{}}},"AddHeaderAction":{"type":"structure","required":["HeaderName","HeaderValue"],"members":{"HeaderName":{},"HeaderValue":{}}},"SNSAction":{"type":"structure","required":["TopicArn"],"members":{"TopicArn":{},"Encoding":{}}}}}},"ScanEnabled":{"type":"boolean"}}},"S20":{"type":"structure","required":["TemplateName"],"members":{"TemplateName":{},"SubjectPart":{},"TextPart":{},"HtmlPart":{}}},"S2t":{"type":"structure","members":{"Name":{},"CreatedTimestamp":{"type":"timestamp"}}},"S2v":{"type":"list","member":{"shape":"S18"}},"S31":{"type":"structure","members":{"TlsPolicy":{}}},"S3c":{"type":"list","member":{}},"S3h":{"type":"list","member":{}},"S3w":{"type":"list","member":{}},"S54":{"type":"list","member":{}},"S5i":{"type":"list","member":{"type":"structure","required":["Name","Value"],"members":{"Name":{},"Value":{}}}},"S5x":{"type":"list","member":{"type":"structure","required":["Name","Value"],"members":{"Name":{},"Value":{}}}},"S64":{"type":"structure","members":{"ToAddresses":{"shape":"S54"},"CcAddresses":{"shape":"S54"},"BccAddresses":{"shape":"S54"}}},"S6e":{"type":"structure","required":["Data"],"members":{"Data":{},"Charset":{}}}}}; +/***/ 8437: +/***/ ((__unused_webpack_module, exports) => { -/***/ }), +"use strict"; -/***/ 370: -/***/ (function(module) { +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ruleSet = void 0; +const u = "required", v = "fn", w = "argv", x = "ref"; +const a = true, b = "isSet", c = "booleanEquals", d = "error", e = "endpoint", f = "tree", g = "PartitionResult", h = "getAttr", i = { [u]: false, "type": "string" }, j = { [u]: true, "default": false, "type": "boolean" }, k = { [x]: "Endpoint" }, l = { [v]: c, [w]: [{ [x]: "UseFIPS" }, true] }, m = { [v]: c, [w]: [{ [x]: "UseDualStack" }, true] }, n = {}, o = { [v]: h, [w]: [{ [x]: g }, "supportsFIPS"] }, p = { [x]: g }, q = { [v]: c, [w]: [true, { [v]: h, [w]: [p, "supportsDualStack"] }] }, r = [l], s = [m], t = [{ [x]: "Region" }]; +const _data = { version: "1.0", parameters: { Region: i, UseDualStack: j, UseFIPS: j, Endpoint: i }, rules: [{ conditions: [{ [v]: b, [w]: [k] }], rules: [{ conditions: r, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: d }, { conditions: s, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: d }, { endpoint: { url: k, properties: n, headers: n }, type: e }], type: f }, { conditions: [{ [v]: b, [w]: t }], rules: [{ conditions: [{ [v]: "aws.partition", [w]: t, assign: g }], rules: [{ conditions: [l, m], rules: [{ conditions: [{ [v]: c, [w]: [a, o] }, q], rules: [{ endpoint: { url: "https://cloudformation-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: n, headers: n }, type: e }], type: f }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: d }], type: f }, { conditions: r, rules: [{ conditions: [{ [v]: c, [w]: [o, a] }], rules: [{ conditions: [{ [v]: "stringEquals", [w]: [{ [v]: h, [w]: [p, "name"] }, "aws-us-gov"] }], endpoint: { url: "https://cloudformation.{Region}.amazonaws.com", properties: n, headers: n }, type: e }, { endpoint: { url: "https://cloudformation-fips.{Region}.{PartitionResult#dnsSuffix}", properties: n, headers: n }, type: e }], type: f }, { error: "FIPS is enabled but this partition does not support FIPS", type: d }], type: f }, { conditions: s, rules: [{ conditions: [q], rules: [{ endpoint: { url: "https://cloudformation.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: n, headers: n }, type: e }], type: f }, { error: "DualStack is enabled but this partition does not support DualStack", type: d }], type: f }, { endpoint: { url: "https://cloudformation.{Region}.{PartitionResult#dnsSuffix}", properties: n, headers: n }, type: e }], type: f }], type: f }, { error: "Invalid Configuration: Missing Region", type: d }] }; +exports.ruleSet = _data; -module.exports = {"pagination":{"ListApplicationStates":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"ApplicationStateList"},"ListCreatedArtifacts":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"CreatedArtifactList"},"ListDiscoveredResources":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"DiscoveredResourceList"},"ListMigrationTasks":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"MigrationTaskSummaryList"},"ListProgressUpdateStreams":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"ProgressUpdateStreamSummaryList"}}}; /***/ }), -/***/ 395: -/***/ (function(module, __unusedexports, __webpack_require__) { +/***/ 3805: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -/** - * The main AWS namespace - */ -var AWS = { util: __webpack_require__(153) }; +"use strict"; -/** - * @api private - * @!macro [new] nobrowser - * @note This feature is not supported in the browser environment of the SDK. - */ -var _hidden = {}; _hidden.toString(); // hack to parse macro -/** - * @api private - */ -module.exports = AWS; - -AWS.util.update(AWS, { - - /** - * @constant - */ - VERSION: '2.725.0', - - /** - * @api private - */ - Signers: {}, - - /** - * @api private - */ - Protocol: { - Json: __webpack_require__(9912), - Query: __webpack_require__(576), - Rest: __webpack_require__(4618), - RestJson: __webpack_require__(3315), - RestXml: __webpack_require__(9002) - }, - - /** - * @api private - */ - XML: { - Builder: __webpack_require__(2492), - Parser: null // conditionally set based on environment - }, - - /** - * @api private - */ - JSON: { - Builder: __webpack_require__(337), - Parser: __webpack_require__(9806) - }, - - /** - * @api private - */ - Model: { - Api: __webpack_require__(7788), - Operation: __webpack_require__(3964), - Shape: __webpack_require__(3682), - Paginator: __webpack_require__(6265), - ResourceWaiter: __webpack_require__(3624) - }, - - /** - * @api private - */ - apiLoader: __webpack_require__(6165), - - /** - * @api private - */ - EndpointCache: __webpack_require__(4120).EndpointCache -}); -__webpack_require__(8610); -__webpack_require__(3503); -__webpack_require__(3187); -__webpack_require__(3711); -__webpack_require__(8606); -__webpack_require__(2453); -__webpack_require__(9828); -__webpack_require__(4904); -__webpack_require__(7835); -__webpack_require__(3977); - -/** - * @readonly - * @return [AWS.SequentialExecutor] a collection of global event listeners that - * are attached to every sent request. - * @see AWS.Request AWS.Request for a list of events to listen for - * @example Logging the time taken to send a request - * AWS.events.on('send', function startSend(resp) { - * resp.startTime = new Date().getTime(); - * }).on('complete', function calculateTime(resp) { - * var time = (new Date().getTime() - resp.startTime) / 1000; - * console.log('Request took ' + time + ' seconds'); - * }); - * - * new AWS.S3().listBuckets(); // prints 'Request took 0.285 seconds' - */ -AWS.events = new AWS.SequentialExecutor(); - -//create endpoint cache lazily -AWS.util.memoizedProperty(AWS, 'endpointCache', function() { - return new AWS.EndpointCache(AWS.config.endpointCacheSize); -}, true); - - -/***/ }), - -/***/ 398: -/***/ (function(module) { +var middlewareHostHeader = __nccwpck_require__(2590); +var middlewareLogger = __nccwpck_require__(5242); +var middlewareRecursionDetection = __nccwpck_require__(1568); +var middlewareUserAgent = __nccwpck_require__(2959); +var configResolver = __nccwpck_require__(9316); +var core = __nccwpck_require__(402); +var schema = __nccwpck_require__(6890); +var middlewareContentLength = __nccwpck_require__(7212); +var middlewareEndpoint = __nccwpck_require__(99); +var middlewareRetry = __nccwpck_require__(9618); +var smithyClient = __nccwpck_require__(1411); +var httpAuthSchemeProvider = __nccwpck_require__(398); +var runtimeConfig = __nccwpck_require__(7079); +var regionConfigResolver = __nccwpck_require__(6463); +var protocolHttp = __nccwpck_require__(2356); +var utilWaiter = __nccwpck_require__(5290); + +const resolveClientEndpointParameters = (options) => { + return Object.assign(options, { + useDualstackEndpoint: options.useDualstackEndpoint ?? false, + useFipsEndpoint: options.useFipsEndpoint ?? false, + defaultSigningName: "cloudformation", + }); +}; +const commonParams = { + UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" }, + Endpoint: { type: "builtInParams", name: "endpoint" }, + Region: { type: "builtInParams", name: "region" }, + UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }, +}; -module.exports = {"pagination":{"ListJobsByPipeline":{"input_token":"PageToken","output_token":"NextPageToken","result_key":"Jobs"},"ListJobsByStatus":{"input_token":"PageToken","output_token":"NextPageToken","result_key":"Jobs"},"ListPipelines":{"input_token":"PageToken","output_token":"NextPageToken","result_key":"Pipelines"},"ListPresets":{"input_token":"PageToken","output_token":"NextPageToken","result_key":"Presets"}}}; +const getHttpAuthExtensionConfiguration = (runtimeConfig) => { + const _httpAuthSchemes = runtimeConfig.httpAuthSchemes; + let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider; + let _credentials = runtimeConfig.credentials; + return { + setHttpAuthScheme(httpAuthScheme) { + const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId); + if (index === -1) { + _httpAuthSchemes.push(httpAuthScheme); + } + else { + _httpAuthSchemes.splice(index, 1, httpAuthScheme); + } + }, + httpAuthSchemes() { + return _httpAuthSchemes; + }, + setHttpAuthSchemeProvider(httpAuthSchemeProvider) { + _httpAuthSchemeProvider = httpAuthSchemeProvider; + }, + httpAuthSchemeProvider() { + return _httpAuthSchemeProvider; + }, + setCredentials(credentials) { + _credentials = credentials; + }, + credentials() { + return _credentials; + }, + }; +}; +const resolveHttpAuthRuntimeConfig = (config) => { + return { + httpAuthSchemes: config.httpAuthSchemes(), + httpAuthSchemeProvider: config.httpAuthSchemeProvider(), + credentials: config.credentials(), + }; +}; -/***/ }), +const resolveRuntimeExtensions = (runtimeConfig, extensions) => { + const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig)); + extensions.forEach((extension) => extension.configure(extensionConfiguration)); + return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration)); +}; -/***/ 404: -/***/ (function(module, __unusedexports, __webpack_require__) { +class CloudFormationClient extends smithyClient.Client { + config; + constructor(...[configuration]) { + const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {}); + super(_config_0); + this.initConfig = _config_0; + const _config_1 = resolveClientEndpointParameters(_config_0); + const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1); + const _config_3 = middlewareRetry.resolveRetryConfig(_config_2); + const _config_4 = configResolver.resolveRegionConfig(_config_3); + const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4); + const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5); + const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6); + const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []); + this.config = _config_8; + this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config)); + this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config)); + this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config)); + this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config)); + this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config)); + this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config)); + this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config)); + this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, { + httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultCloudFormationHttpAuthSchemeParametersProvider, + identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({ + "aws.auth#sigv4": config.credentials, + }), + })); + this.middlewareStack.use(core.getHttpSigningPlugin(this.config)); + } + destroy() { + super.destroy(); + } +} -var escapeAttribute = __webpack_require__(8918).escapeAttribute; +let CloudFormationServiceException$1 = class CloudFormationServiceException extends smithyClient.ServiceException { + constructor(options) { + super(options); + Object.setPrototypeOf(this, CloudFormationServiceException.prototype); + } +}; -/** - * Represents an XML node. - * @api private - */ -function XmlNode(name, children) { - if (children === void 0) { children = []; } - this.name = name; - this.children = children; - this.attributes = {}; -} -XmlNode.prototype.addAttribute = function (name, value) { - this.attributes[name] = value; - return this; +let InvalidOperationException$1 = class InvalidOperationException extends CloudFormationServiceException$1 { + name = "InvalidOperationException"; + $fault = "client"; + Message; + constructor(opts) { + super({ + name: "InvalidOperationException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, InvalidOperationException.prototype); + this.Message = opts.Message; + } }; -XmlNode.prototype.addChildNode = function (child) { - this.children.push(child); - return this; +let OperationNotFoundException$1 = class OperationNotFoundException extends CloudFormationServiceException$1 { + name = "OperationNotFoundException"; + $fault = "client"; + Message; + constructor(opts) { + super({ + name: "OperationNotFoundException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, OperationNotFoundException.prototype); + this.Message = opts.Message; + } }; -XmlNode.prototype.removeAttribute = function (name) { - delete this.attributes[name]; - return this; +let CFNRegistryException$1 = class CFNRegistryException extends CloudFormationServiceException$1 { + name = "CFNRegistryException"; + $fault = "client"; + Message; + constructor(opts) { + super({ + name: "CFNRegistryException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, CFNRegistryException.prototype); + this.Message = opts.Message; + } }; -XmlNode.prototype.toString = function () { - var hasChildren = Boolean(this.children.length); - var xmlText = '<' + this.name; - // add attributes - var attributes = this.attributes; - for (var i = 0, attributeNames = Object.keys(attributes); i < attributeNames.length; i++) { - var attributeName = attributeNames[i]; - var attribute = attributes[attributeName]; - if (typeof attribute !== 'undefined' && attribute !== null) { - xmlText += ' ' + attributeName + '=\"' + escapeAttribute('' + attribute) + '\"'; - } +let TypeNotFoundException$1 = class TypeNotFoundException extends CloudFormationServiceException$1 { + name = "TypeNotFoundException"; + $fault = "client"; + Message; + constructor(opts) { + super({ + name: "TypeNotFoundException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, TypeNotFoundException.prototype); + this.Message = opts.Message; } - return xmlText += !hasChildren ? '/>' : '>' + this.children.map(function (c) { return c.toString(); }).join('') + ''; }; - -/** - * @api private - */ -module.exports = { - XmlNode: XmlNode +let AlreadyExistsException$1 = class AlreadyExistsException extends CloudFormationServiceException$1 { + name = "AlreadyExistsException"; + $fault = "client"; + Message; + constructor(opts) { + super({ + name: "AlreadyExistsException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, AlreadyExistsException.prototype); + this.Message = opts.Message; + } }; - - -/***/ }), - -/***/ 408: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['rdsdataservice'] = {}; -AWS.RDSDataService = Service.defineService('rdsdataservice', ['2018-08-01']); -__webpack_require__(2450); -Object.defineProperty(apiLoader.services['rdsdataservice'], '2018-08-01', { - get: function get() { - var model = __webpack_require__(8192); - model.paginators = __webpack_require__(8828).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.RDSDataService; - - -/***/ }), - -/***/ 417: -/***/ (function(module, __unusedexports, __webpack_require__) { - -"use strict"; - - -var common = __webpack_require__(2740); -var Type = __webpack_require__(4945); - -var YAML_FLOAT_PATTERN = new RegExp( - // 2.5e4, 2.5 and integers - '^(?:[-+]?(?:0|[1-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?' + - // .2e4, .2 - // special case, seems not from spec - '|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?' + - // 20:59 - '|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*' + - // .inf - '|[-+]?\\.(?:inf|Inf|INF)' + - // .nan - '|\\.(?:nan|NaN|NAN))$'); - -function resolveYamlFloat(data) { - if (data === null) return false; - - if (!YAML_FLOAT_PATTERN.test(data) || - // Quick hack to not allow integers end with `_` - // Probably should update regexp & check speed - data[data.length - 1] === '_') { - return false; - } - - return true; -} - -function constructYamlFloat(data) { - var value, sign, base, digits; - - value = data.replace(/_/g, '').toLowerCase(); - sign = value[0] === '-' ? -1 : 1; - digits = []; - - if ('+-'.indexOf(value[0]) >= 0) { - value = value.slice(1); - } - - if (value === '.inf') { - return (sign === 1) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY; - - } else if (value === '.nan') { - return NaN; - - } else if (value.indexOf(':') >= 0) { - value.split(':').forEach(function (v) { - digits.unshift(parseFloat(v, 10)); - }); - - value = 0.0; - base = 1; - - digits.forEach(function (d) { - value += d * base; - base *= 60; - }); - - return sign * value; - - } - return sign * parseFloat(value, 10); -} - - -var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/; - -function representYamlFloat(object, style) { - var res; - - if (isNaN(object)) { - switch (style) { - case 'lowercase': return '.nan'; - case 'uppercase': return '.NAN'; - case 'camelcase': return '.NaN'; +let TypeConfigurationNotFoundException$1 = class TypeConfigurationNotFoundException extends CloudFormationServiceException$1 { + name = "TypeConfigurationNotFoundException"; + $fault = "client"; + Message; + constructor(opts) { + super({ + name: "TypeConfigurationNotFoundException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, TypeConfigurationNotFoundException.prototype); + this.Message = opts.Message; } - } else if (Number.POSITIVE_INFINITY === object) { - switch (style) { - case 'lowercase': return '.inf'; - case 'uppercase': return '.INF'; - case 'camelcase': return '.Inf'; +}; +let TokenAlreadyExistsException$1 = class TokenAlreadyExistsException extends CloudFormationServiceException$1 { + name = "TokenAlreadyExistsException"; + $fault = "client"; + Message; + constructor(opts) { + super({ + name: "TokenAlreadyExistsException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, TokenAlreadyExistsException.prototype); + this.Message = opts.Message; } - } else if (Number.NEGATIVE_INFINITY === object) { - switch (style) { - case 'lowercase': return '-.inf'; - case 'uppercase': return '-.INF'; - case 'camelcase': return '-.Inf'; +}; +let ChangeSetNotFoundException$1 = class ChangeSetNotFoundException extends CloudFormationServiceException$1 { + name = "ChangeSetNotFoundException"; + $fault = "client"; + Message; + constructor(opts) { + super({ + name: "ChangeSetNotFoundException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, ChangeSetNotFoundException.prototype); + this.Message = opts.Message; } - } else if (common.isNegativeZero(object)) { - return '-0.0'; - } - - res = object.toString(10); - - // JS stringifier can build scientific format without dots: 5e-100, - // while YAML requres dot: 5.e-100. Fix it with simple hack - - return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace('e', '.e') : res; -} - -function isFloat(object) { - return (Object.prototype.toString.call(object) === '[object Number]') && - (object % 1 !== 0 || common.isNegativeZero(object)); -} - -module.exports = new Type('tag:yaml.org,2002:float', { - kind: 'scalar', - resolve: resolveYamlFloat, - construct: constructYamlFloat, - predicate: isFloat, - represent: representYamlFloat, - defaultStyle: 'lowercase' -}); - - -/***/ }), - -/***/ 422: -/***/ (function(module) { - -module.exports = {"pagination":{}}; - -/***/ }), - -/***/ 437: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2009-03-31","endpointPrefix":"elasticmapreduce","jsonVersion":"1.1","protocol":"json","serviceAbbreviation":"Amazon EMR","serviceFullName":"Amazon Elastic MapReduce","serviceId":"EMR","signatureVersion":"v4","targetPrefix":"ElasticMapReduce","uid":"elasticmapreduce-2009-03-31"},"operations":{"AddInstanceFleet":{"input":{"type":"structure","required":["ClusterId","InstanceFleet"],"members":{"ClusterId":{},"InstanceFleet":{"shape":"S3"}}},"output":{"type":"structure","members":{"ClusterId":{},"InstanceFleetId":{},"ClusterArn":{}}}},"AddInstanceGroups":{"input":{"type":"structure","required":["InstanceGroups","JobFlowId"],"members":{"InstanceGroups":{"shape":"Su"},"JobFlowId":{}}},"output":{"type":"structure","members":{"JobFlowId":{},"InstanceGroupIds":{"type":"list","member":{}},"ClusterArn":{}}}},"AddJobFlowSteps":{"input":{"type":"structure","required":["JobFlowId","Steps"],"members":{"JobFlowId":{},"Steps":{"shape":"S1f"}}},"output":{"type":"structure","members":{"StepIds":{"shape":"S1o"}}}},"AddTags":{"input":{"type":"structure","required":["ResourceId","Tags"],"members":{"ResourceId":{},"Tags":{"shape":"S1r"}}},"output":{"type":"structure","members":{}}},"CancelSteps":{"input":{"type":"structure","required":["ClusterId","StepIds"],"members":{"ClusterId":{},"StepIds":{"shape":"S1o"},"StepCancellationOption":{}}},"output":{"type":"structure","members":{"CancelStepsInfoList":{"type":"list","member":{"type":"structure","members":{"StepId":{},"Status":{},"Reason":{}}}}}}},"CreateSecurityConfiguration":{"input":{"type":"structure","required":["Name","SecurityConfiguration"],"members":{"Name":{},"SecurityConfiguration":{}}},"output":{"type":"structure","required":["Name","CreationDateTime"],"members":{"Name":{},"CreationDateTime":{"type":"timestamp"}}}},"DeleteSecurityConfiguration":{"input":{"type":"structure","required":["Name"],"members":{"Name":{}}},"output":{"type":"structure","members":{}}},"DescribeCluster":{"input":{"type":"structure","required":["ClusterId"],"members":{"ClusterId":{}}},"output":{"type":"structure","members":{"Cluster":{"type":"structure","members":{"Id":{},"Name":{},"Status":{"shape":"S2a"},"Ec2InstanceAttributes":{"type":"structure","members":{"Ec2KeyName":{},"Ec2SubnetId":{},"RequestedEc2SubnetIds":{"shape":"S2g"},"Ec2AvailabilityZone":{},"RequestedEc2AvailabilityZones":{"shape":"S2g"},"IamInstanceProfile":{},"EmrManagedMasterSecurityGroup":{},"EmrManagedSlaveSecurityGroup":{},"ServiceAccessSecurityGroup":{},"AdditionalMasterSecurityGroups":{"shape":"S2h"},"AdditionalSlaveSecurityGroups":{"shape":"S2h"}}},"InstanceCollectionType":{},"LogUri":{},"LogEncryptionKmsKeyId":{},"RequestedAmiVersion":{},"RunningAmiVersion":{},"ReleaseLabel":{},"AutoTerminate":{"type":"boolean"},"TerminationProtected":{"type":"boolean"},"VisibleToAllUsers":{"type":"boolean"},"Applications":{"shape":"S2k"},"Tags":{"shape":"S1r"},"ServiceRole":{},"NormalizedInstanceHours":{"type":"integer"},"MasterPublicDnsName":{},"Configurations":{"shape":"Sh"},"SecurityConfiguration":{},"AutoScalingRole":{},"ScaleDownBehavior":{},"CustomAmiId":{},"EbsRootVolumeSize":{"type":"integer"},"RepoUpgradeOnBoot":{},"KerberosAttributes":{"shape":"S2o"},"ClusterArn":{},"OutpostArn":{},"StepConcurrencyLevel":{"type":"integer"}}}}}},"DescribeJobFlows":{"input":{"type":"structure","members":{"CreatedAfter":{"type":"timestamp"},"CreatedBefore":{"type":"timestamp"},"JobFlowIds":{"shape":"S1m"},"JobFlowStates":{"type":"list","member":{}}}},"output":{"type":"structure","members":{"JobFlows":{"type":"list","member":{"type":"structure","required":["JobFlowId","Name","ExecutionStatusDetail","Instances"],"members":{"JobFlowId":{},"Name":{},"LogUri":{},"LogEncryptionKmsKeyId":{},"AmiVersion":{},"ExecutionStatusDetail":{"type":"structure","required":["State","CreationDateTime"],"members":{"State":{},"CreationDateTime":{"type":"timestamp"},"StartDateTime":{"type":"timestamp"},"ReadyDateTime":{"type":"timestamp"},"EndDateTime":{"type":"timestamp"},"LastStateChangeReason":{}}},"Instances":{"type":"structure","required":["MasterInstanceType","SlaveInstanceType","InstanceCount"],"members":{"MasterInstanceType":{},"MasterPublicDnsName":{},"MasterInstanceId":{},"SlaveInstanceType":{},"InstanceCount":{"type":"integer"},"InstanceGroups":{"type":"list","member":{"type":"structure","required":["Market","InstanceRole","InstanceType","InstanceRequestCount","InstanceRunningCount","State","CreationDateTime"],"members":{"InstanceGroupId":{},"Name":{},"Market":{},"InstanceRole":{},"BidPrice":{},"InstanceType":{},"InstanceRequestCount":{"type":"integer"},"InstanceRunningCount":{"type":"integer"},"State":{},"LastStateChangeReason":{},"CreationDateTime":{"type":"timestamp"},"StartDateTime":{"type":"timestamp"},"ReadyDateTime":{"type":"timestamp"},"EndDateTime":{"type":"timestamp"}}}},"NormalizedInstanceHours":{"type":"integer"},"Ec2KeyName":{},"Ec2SubnetId":{},"Placement":{"shape":"S31"},"KeepJobFlowAliveWhenNoSteps":{"type":"boolean"},"TerminationProtected":{"type":"boolean"},"HadoopVersion":{}}},"Steps":{"type":"list","member":{"type":"structure","required":["StepConfig","ExecutionStatusDetail"],"members":{"StepConfig":{"shape":"S1g"},"ExecutionStatusDetail":{"type":"structure","required":["State","CreationDateTime"],"members":{"State":{},"CreationDateTime":{"type":"timestamp"},"StartDateTime":{"type":"timestamp"},"EndDateTime":{"type":"timestamp"},"LastStateChangeReason":{}}}}}},"BootstrapActions":{"type":"list","member":{"type":"structure","members":{"BootstrapActionConfig":{"shape":"S38"}}}},"SupportedProducts":{"shape":"S3a"},"VisibleToAllUsers":{"type":"boolean"},"JobFlowRole":{},"ServiceRole":{},"AutoScalingRole":{},"ScaleDownBehavior":{}}}}}},"deprecated":true},"DescribeSecurityConfiguration":{"input":{"type":"structure","required":["Name"],"members":{"Name":{}}},"output":{"type":"structure","members":{"Name":{},"SecurityConfiguration":{},"CreationDateTime":{"type":"timestamp"}}}},"DescribeStep":{"input":{"type":"structure","required":["ClusterId","StepId"],"members":{"ClusterId":{},"StepId":{}}},"output":{"type":"structure","members":{"Step":{"type":"structure","members":{"Id":{},"Name":{},"Config":{"shape":"S3g"},"ActionOnFailure":{},"Status":{"shape":"S3h"}}}}}},"GetBlockPublicAccessConfiguration":{"input":{"type":"structure","members":{}},"output":{"type":"structure","required":["BlockPublicAccessConfiguration","BlockPublicAccessConfigurationMetadata"],"members":{"BlockPublicAccessConfiguration":{"shape":"S3p"},"BlockPublicAccessConfigurationMetadata":{"type":"structure","required":["CreationDateTime","CreatedByArn"],"members":{"CreationDateTime":{"type":"timestamp"},"CreatedByArn":{}}}}}},"GetManagedScalingPolicy":{"input":{"type":"structure","required":["ClusterId"],"members":{"ClusterId":{}}},"output":{"type":"structure","members":{"ManagedScalingPolicy":{"shape":"S3w"}}}},"ListBootstrapActions":{"input":{"type":"structure","required":["ClusterId"],"members":{"ClusterId":{},"Marker":{}}},"output":{"type":"structure","members":{"BootstrapActions":{"type":"list","member":{"type":"structure","members":{"Name":{},"ScriptPath":{},"Args":{"shape":"S2h"}}}},"Marker":{}}}},"ListClusters":{"input":{"type":"structure","members":{"CreatedAfter":{"type":"timestamp"},"CreatedBefore":{"type":"timestamp"},"ClusterStates":{"type":"list","member":{}},"Marker":{}}},"output":{"type":"structure","members":{"Clusters":{"type":"list","member":{"type":"structure","members":{"Id":{},"Name":{},"Status":{"shape":"S2a"},"NormalizedInstanceHours":{"type":"integer"},"ClusterArn":{},"OutpostArn":{}}}},"Marker":{}}}},"ListInstanceFleets":{"input":{"type":"structure","required":["ClusterId"],"members":{"ClusterId":{},"Marker":{}}},"output":{"type":"structure","members":{"InstanceFleets":{"type":"list","member":{"type":"structure","members":{"Id":{},"Name":{},"Status":{"type":"structure","members":{"State":{},"StateChangeReason":{"type":"structure","members":{"Code":{},"Message":{}}},"Timeline":{"type":"structure","members":{"CreationDateTime":{"type":"timestamp"},"ReadyDateTime":{"type":"timestamp"},"EndDateTime":{"type":"timestamp"}}}}},"InstanceFleetType":{},"TargetOnDemandCapacity":{"type":"integer"},"TargetSpotCapacity":{"type":"integer"},"ProvisionedOnDemandCapacity":{"type":"integer"},"ProvisionedSpotCapacity":{"type":"integer"},"InstanceTypeSpecifications":{"type":"list","member":{"type":"structure","members":{"InstanceType":{},"WeightedCapacity":{"type":"integer"},"BidPrice":{},"BidPriceAsPercentageOfOnDemandPrice":{"type":"double"},"Configurations":{"shape":"Sh"},"EbsBlockDevices":{"shape":"S4k"},"EbsOptimized":{"type":"boolean"}}}},"LaunchSpecifications":{"shape":"Sk"}}}},"Marker":{}}}},"ListInstanceGroups":{"input":{"type":"structure","required":["ClusterId"],"members":{"ClusterId":{},"Marker":{}}},"output":{"type":"structure","members":{"InstanceGroups":{"type":"list","member":{"type":"structure","members":{"Id":{},"Name":{},"Market":{},"InstanceGroupType":{},"BidPrice":{},"InstanceType":{},"RequestedInstanceCount":{"type":"integer"},"RunningInstanceCount":{"type":"integer"},"Status":{"type":"structure","members":{"State":{},"StateChangeReason":{"type":"structure","members":{"Code":{},"Message":{}}},"Timeline":{"type":"structure","members":{"CreationDateTime":{"type":"timestamp"},"ReadyDateTime":{"type":"timestamp"},"EndDateTime":{"type":"timestamp"}}}}},"Configurations":{"shape":"Sh"},"ConfigurationsVersion":{"type":"long"},"LastSuccessfullyAppliedConfigurations":{"shape":"Sh"},"LastSuccessfullyAppliedConfigurationsVersion":{"type":"long"},"EbsBlockDevices":{"shape":"S4k"},"EbsOptimized":{"type":"boolean"},"ShrinkPolicy":{"shape":"S4x"},"AutoScalingPolicy":{"shape":"S51"}}}},"Marker":{}}}},"ListInstances":{"input":{"type":"structure","required":["ClusterId"],"members":{"ClusterId":{},"InstanceGroupId":{},"InstanceGroupTypes":{"type":"list","member":{}},"InstanceFleetId":{},"InstanceFleetType":{},"InstanceStates":{"type":"list","member":{}},"Marker":{}}},"output":{"type":"structure","members":{"Instances":{"type":"list","member":{"type":"structure","members":{"Id":{},"Ec2InstanceId":{},"PublicDnsName":{},"PublicIpAddress":{},"PrivateDnsName":{},"PrivateIpAddress":{},"Status":{"type":"structure","members":{"State":{},"StateChangeReason":{"type":"structure","members":{"Code":{},"Message":{}}},"Timeline":{"type":"structure","members":{"CreationDateTime":{"type":"timestamp"},"ReadyDateTime":{"type":"timestamp"},"EndDateTime":{"type":"timestamp"}}}}},"InstanceGroupId":{},"InstanceFleetId":{},"Market":{},"InstanceType":{},"EbsVolumes":{"type":"list","member":{"type":"structure","members":{"Device":{},"VolumeId":{}}}}}}},"Marker":{}}}},"ListSecurityConfigurations":{"input":{"type":"structure","members":{"Marker":{}}},"output":{"type":"structure","members":{"SecurityConfigurations":{"type":"list","member":{"type":"structure","members":{"Name":{},"CreationDateTime":{"type":"timestamp"}}}},"Marker":{}}}},"ListSteps":{"input":{"type":"structure","required":["ClusterId"],"members":{"ClusterId":{},"StepStates":{"type":"list","member":{}},"StepIds":{"shape":"S1m"},"Marker":{}}},"output":{"type":"structure","members":{"Steps":{"type":"list","member":{"type":"structure","members":{"Id":{},"Name":{},"Config":{"shape":"S3g"},"ActionOnFailure":{},"Status":{"shape":"S3h"}}}},"Marker":{}}}},"ModifyCluster":{"input":{"type":"structure","required":["ClusterId"],"members":{"ClusterId":{},"StepConcurrencyLevel":{"type":"integer"}}},"output":{"type":"structure","members":{"StepConcurrencyLevel":{"type":"integer"}}}},"ModifyInstanceFleet":{"input":{"type":"structure","required":["ClusterId","InstanceFleet"],"members":{"ClusterId":{},"InstanceFleet":{"type":"structure","required":["InstanceFleetId"],"members":{"InstanceFleetId":{},"TargetOnDemandCapacity":{"type":"integer"},"TargetSpotCapacity":{"type":"integer"}}}}}},"ModifyInstanceGroups":{"input":{"type":"structure","members":{"ClusterId":{},"InstanceGroups":{"type":"list","member":{"type":"structure","required":["InstanceGroupId"],"members":{"InstanceGroupId":{},"InstanceCount":{"type":"integer"},"EC2InstanceIdsToTerminate":{"type":"list","member":{}},"ShrinkPolicy":{"shape":"S4x"},"Configurations":{"shape":"Sh"}}}}}}},"PutAutoScalingPolicy":{"input":{"type":"structure","required":["ClusterId","InstanceGroupId","AutoScalingPolicy"],"members":{"ClusterId":{},"InstanceGroupId":{},"AutoScalingPolicy":{"shape":"Sy"}}},"output":{"type":"structure","members":{"ClusterId":{},"InstanceGroupId":{},"AutoScalingPolicy":{"shape":"S51"},"ClusterArn":{}}}},"PutBlockPublicAccessConfiguration":{"input":{"type":"structure","required":["BlockPublicAccessConfiguration"],"members":{"BlockPublicAccessConfiguration":{"shape":"S3p"}}},"output":{"type":"structure","members":{}}},"PutManagedScalingPolicy":{"input":{"type":"structure","required":["ClusterId","ManagedScalingPolicy"],"members":{"ClusterId":{},"ManagedScalingPolicy":{"shape":"S3w"}}},"output":{"type":"structure","members":{}}},"RemoveAutoScalingPolicy":{"input":{"type":"structure","required":["ClusterId","InstanceGroupId"],"members":{"ClusterId":{},"InstanceGroupId":{}}},"output":{"type":"structure","members":{}}},"RemoveManagedScalingPolicy":{"input":{"type":"structure","required":["ClusterId"],"members":{"ClusterId":{}}},"output":{"type":"structure","members":{}}},"RemoveTags":{"input":{"type":"structure","required":["ResourceId","TagKeys"],"members":{"ResourceId":{},"TagKeys":{"shape":"S2h"}}},"output":{"type":"structure","members":{}}},"RunJobFlow":{"input":{"type":"structure","required":["Name","Instances"],"members":{"Name":{},"LogUri":{},"LogEncryptionKmsKeyId":{},"AdditionalInfo":{},"AmiVersion":{},"ReleaseLabel":{},"Instances":{"type":"structure","members":{"MasterInstanceType":{},"SlaveInstanceType":{},"InstanceCount":{"type":"integer"},"InstanceGroups":{"shape":"Su"},"InstanceFleets":{"type":"list","member":{"shape":"S3"}},"Ec2KeyName":{},"Placement":{"shape":"S31"},"KeepJobFlowAliveWhenNoSteps":{"type":"boolean"},"TerminationProtected":{"type":"boolean"},"HadoopVersion":{},"Ec2SubnetId":{},"Ec2SubnetIds":{"shape":"S2g"},"EmrManagedMasterSecurityGroup":{},"EmrManagedSlaveSecurityGroup":{},"ServiceAccessSecurityGroup":{},"AdditionalMasterSecurityGroups":{"shape":"S6f"},"AdditionalSlaveSecurityGroups":{"shape":"S6f"}}},"Steps":{"shape":"S1f"},"BootstrapActions":{"type":"list","member":{"shape":"S38"}},"SupportedProducts":{"shape":"S3a"},"NewSupportedProducts":{"type":"list","member":{"type":"structure","members":{"Name":{},"Args":{"shape":"S1m"}}}},"Applications":{"shape":"S2k"},"Configurations":{"shape":"Sh"},"VisibleToAllUsers":{"type":"boolean"},"JobFlowRole":{},"ServiceRole":{},"Tags":{"shape":"S1r"},"SecurityConfiguration":{},"AutoScalingRole":{},"ScaleDownBehavior":{},"CustomAmiId":{},"EbsRootVolumeSize":{"type":"integer"},"RepoUpgradeOnBoot":{},"KerberosAttributes":{"shape":"S2o"},"StepConcurrencyLevel":{"type":"integer"},"ManagedScalingPolicy":{"shape":"S3w"}}},"output":{"type":"structure","members":{"JobFlowId":{},"ClusterArn":{}}}},"SetTerminationProtection":{"input":{"type":"structure","required":["JobFlowIds","TerminationProtected"],"members":{"JobFlowIds":{"shape":"S1m"},"TerminationProtected":{"type":"boolean"}}}},"SetVisibleToAllUsers":{"input":{"type":"structure","required":["JobFlowIds","VisibleToAllUsers"],"members":{"JobFlowIds":{"shape":"S1m"},"VisibleToAllUsers":{"type":"boolean"}}}},"TerminateJobFlows":{"input":{"type":"structure","required":["JobFlowIds"],"members":{"JobFlowIds":{"shape":"S1m"}}}}},"shapes":{"S3":{"type":"structure","required":["InstanceFleetType"],"members":{"Name":{},"InstanceFleetType":{},"TargetOnDemandCapacity":{"type":"integer"},"TargetSpotCapacity":{"type":"integer"},"InstanceTypeConfigs":{"type":"list","member":{"type":"structure","required":["InstanceType"],"members":{"InstanceType":{},"WeightedCapacity":{"type":"integer"},"BidPrice":{},"BidPriceAsPercentageOfOnDemandPrice":{"type":"double"},"EbsConfiguration":{"shape":"Sa"},"Configurations":{"shape":"Sh"}}}},"LaunchSpecifications":{"shape":"Sk"}}},"Sa":{"type":"structure","members":{"EbsBlockDeviceConfigs":{"type":"list","member":{"type":"structure","required":["VolumeSpecification"],"members":{"VolumeSpecification":{"shape":"Sd"},"VolumesPerInstance":{"type":"integer"}}}},"EbsOptimized":{"type":"boolean"}}},"Sd":{"type":"structure","required":["VolumeType","SizeInGB"],"members":{"VolumeType":{},"Iops":{"type":"integer"},"SizeInGB":{"type":"integer"}}},"Sh":{"type":"list","member":{"type":"structure","members":{"Classification":{},"Configurations":{"shape":"Sh"},"Properties":{"shape":"Sj"}}}},"Sj":{"type":"map","key":{},"value":{}},"Sk":{"type":"structure","members":{"SpotSpecification":{"type":"structure","required":["TimeoutDurationMinutes","TimeoutAction"],"members":{"TimeoutDurationMinutes":{"type":"integer"},"TimeoutAction":{},"BlockDurationMinutes":{"type":"integer"},"AllocationStrategy":{}}},"OnDemandSpecification":{"type":"structure","required":["AllocationStrategy"],"members":{"AllocationStrategy":{}}}}},"Su":{"type":"list","member":{"type":"structure","required":["InstanceRole","InstanceType","InstanceCount"],"members":{"Name":{},"Market":{},"InstanceRole":{},"BidPrice":{},"InstanceType":{},"InstanceCount":{"type":"integer"},"Configurations":{"shape":"Sh"},"EbsConfiguration":{"shape":"Sa"},"AutoScalingPolicy":{"shape":"Sy"}}}},"Sy":{"type":"structure","required":["Constraints","Rules"],"members":{"Constraints":{"shape":"Sz"},"Rules":{"shape":"S10"}}},"Sz":{"type":"structure","required":["MinCapacity","MaxCapacity"],"members":{"MinCapacity":{"type":"integer"},"MaxCapacity":{"type":"integer"}}},"S10":{"type":"list","member":{"type":"structure","required":["Name","Action","Trigger"],"members":{"Name":{},"Description":{},"Action":{"type":"structure","required":["SimpleScalingPolicyConfiguration"],"members":{"Market":{},"SimpleScalingPolicyConfiguration":{"type":"structure","required":["ScalingAdjustment"],"members":{"AdjustmentType":{},"ScalingAdjustment":{"type":"integer"},"CoolDown":{"type":"integer"}}}}},"Trigger":{"type":"structure","required":["CloudWatchAlarmDefinition"],"members":{"CloudWatchAlarmDefinition":{"type":"structure","required":["ComparisonOperator","MetricName","Period","Threshold"],"members":{"ComparisonOperator":{},"EvaluationPeriods":{"type":"integer"},"MetricName":{},"Namespace":{},"Period":{"type":"integer"},"Statistic":{},"Threshold":{"type":"double"},"Unit":{},"Dimensions":{"type":"list","member":{"type":"structure","members":{"Key":{},"Value":{}}}}}}}}}}},"S1f":{"type":"list","member":{"shape":"S1g"}},"S1g":{"type":"structure","required":["Name","HadoopJarStep"],"members":{"Name":{},"ActionOnFailure":{},"HadoopJarStep":{"type":"structure","required":["Jar"],"members":{"Properties":{"type":"list","member":{"type":"structure","members":{"Key":{},"Value":{}}}},"Jar":{},"MainClass":{},"Args":{"shape":"S1m"}}}}},"S1m":{"type":"list","member":{}},"S1o":{"type":"list","member":{}},"S1r":{"type":"list","member":{"type":"structure","members":{"Key":{},"Value":{}}}},"S2a":{"type":"structure","members":{"State":{},"StateChangeReason":{"type":"structure","members":{"Code":{},"Message":{}}},"Timeline":{"type":"structure","members":{"CreationDateTime":{"type":"timestamp"},"ReadyDateTime":{"type":"timestamp"},"EndDateTime":{"type":"timestamp"}}}}},"S2g":{"type":"list","member":{}},"S2h":{"type":"list","member":{}},"S2k":{"type":"list","member":{"type":"structure","members":{"Name":{},"Version":{},"Args":{"shape":"S2h"},"AdditionalInfo":{"shape":"Sj"}}}},"S2o":{"type":"structure","required":["Realm","KdcAdminPassword"],"members":{"Realm":{},"KdcAdminPassword":{},"CrossRealmTrustPrincipalPassword":{},"ADDomainJoinUser":{},"ADDomainJoinPassword":{}}},"S31":{"type":"structure","members":{"AvailabilityZone":{},"AvailabilityZones":{"shape":"S2g"}}},"S38":{"type":"structure","required":["Name","ScriptBootstrapAction"],"members":{"Name":{},"ScriptBootstrapAction":{"type":"structure","required":["Path"],"members":{"Path":{},"Args":{"shape":"S1m"}}}}},"S3a":{"type":"list","member":{}},"S3g":{"type":"structure","members":{"Jar":{},"Properties":{"shape":"Sj"},"MainClass":{},"Args":{"shape":"S2h"}}},"S3h":{"type":"structure","members":{"State":{},"StateChangeReason":{"type":"structure","members":{"Code":{},"Message":{}}},"FailureDetails":{"type":"structure","members":{"Reason":{},"Message":{},"LogFile":{}}},"Timeline":{"type":"structure","members":{"CreationDateTime":{"type":"timestamp"},"StartDateTime":{"type":"timestamp"},"EndDateTime":{"type":"timestamp"}}}}},"S3p":{"type":"structure","required":["BlockPublicSecurityGroupRules"],"members":{"BlockPublicSecurityGroupRules":{"type":"boolean"},"PermittedPublicSecurityGroupRuleRanges":{"type":"list","member":{"type":"structure","required":["MinRange"],"members":{"MinRange":{"type":"integer"},"MaxRange":{"type":"integer"}}}}}},"S3w":{"type":"structure","members":{"ComputeLimits":{"type":"structure","required":["UnitType","MinimumCapacityUnits","MaximumCapacityUnits"],"members":{"UnitType":{},"MinimumCapacityUnits":{"type":"integer"},"MaximumCapacityUnits":{"type":"integer"},"MaximumOnDemandCapacityUnits":{"type":"integer"},"MaximumCoreCapacityUnits":{"type":"integer"}}}}},"S4k":{"type":"list","member":{"type":"structure","members":{"VolumeSpecification":{"shape":"Sd"},"Device":{}}}},"S4x":{"type":"structure","members":{"DecommissionTimeout":{"type":"integer"},"InstanceResizePolicy":{"type":"structure","members":{"InstancesToTerminate":{"shape":"S4z"},"InstancesToProtect":{"shape":"S4z"},"InstanceTerminationTimeout":{"type":"integer"}}}}},"S4z":{"type":"list","member":{}},"S51":{"type":"structure","members":{"Status":{"type":"structure","members":{"State":{},"StateChangeReason":{"type":"structure","members":{"Code":{},"Message":{}}}}},"Constraints":{"shape":"Sz"},"Rules":{"shape":"S10"}}},"S6f":{"type":"list","member":{}}}}; - -/***/ }), - -/***/ 439: -/***/ (function(module, __unusedexports, __webpack_require__) { - -var util = __webpack_require__(153); - -function QueryParamSerializer() { -} - -QueryParamSerializer.prototype.serialize = function(params, shape, fn) { - serializeStructure('', params, shape, fn); }; - -function ucfirst(shape) { - if (shape.isQueryName || shape.api.protocol !== 'ec2') { - return shape.name; - } else { - return shape.name[0].toUpperCase() + shape.name.substr(1); - } -} - -function serializeStructure(prefix, struct, rules, fn) { - util.each(rules.members, function(name, member) { - var value = struct[name]; - if (value === null || value === undefined) return; - - var memberName = ucfirst(member); - memberName = prefix ? prefix + '.' + memberName : memberName; - serializeMember(memberName, value, member, fn); - }); -} - -function serializeMap(name, map, rules, fn) { - var i = 1; - util.each(map, function (key, value) { - var prefix = rules.flattened ? '.' : '.entry.'; - var position = prefix + (i++) + '.'; - var keyName = position + (rules.key.name || 'key'); - var valueName = position + (rules.value.name || 'value'); - serializeMember(name + keyName, key, rules.key, fn); - serializeMember(name + valueName, value, rules.value, fn); - }); -} - -function serializeList(name, list, rules, fn) { - var memberRules = rules.member || {}; - - if (list.length === 0) { - fn.call(this, name, null); - return; - } - - util.arrayEach(list, function (v, n) { - var suffix = '.' + (n + 1); - if (rules.api.protocol === 'ec2') { - // Do nothing for EC2 - suffix = suffix + ''; // make linter happy - } else if (rules.flattened) { - if (memberRules.name) { - var parts = name.split('.'); - parts.pop(); - parts.push(ucfirst(memberRules)); - name = parts.join('.'); - } - } else { - suffix = '.' + (memberRules.name ? memberRules.name : 'member') + suffix; +let InsufficientCapabilitiesException$1 = class InsufficientCapabilitiesException extends CloudFormationServiceException$1 { + name = "InsufficientCapabilitiesException"; + $fault = "client"; + Message; + constructor(opts) { + super({ + name: "InsufficientCapabilitiesException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, InsufficientCapabilitiesException.prototype); + this.Message = opts.Message; } - serializeMember(name + suffix, v, memberRules, fn); - }); -} - -function serializeMember(name, value, rules, fn) { - if (value === null || value === undefined) return; - if (rules.type === 'structure') { - serializeStructure(name, value, rules, fn); - } else if (rules.type === 'list') { - serializeList(name, value, rules, fn); - } else if (rules.type === 'map') { - serializeMap(name, value, rules, fn); - } else { - fn(name, rules.toWireFormat(value).toString()); - } -} - -/** - * @api private - */ -module.exports = QueryParamSerializer; - - -/***/ }), - -/***/ 445: -/***/ (function(module, __unusedexports, __webpack_require__) { - -/** - * What is necessary to create an event stream in node? - * - http response stream - * - parser - * - event stream model - */ - -var EventMessageChunkerStream = __webpack_require__(3862).EventMessageChunkerStream; -var EventUnmarshallerStream = __webpack_require__(8723).EventUnmarshallerStream; - -function createEventStream(stream, parser, model) { - var eventStream = new EventUnmarshallerStream({ - parser: parser, - eventStreamModel: model - }); - - var eventMessageChunker = new EventMessageChunkerStream(); - - stream.pipe( - eventMessageChunker - ).pipe(eventStream); - - stream.on('error', function(err) { - eventMessageChunker.emit('error', err); - }); - - eventMessageChunker.on('error', function(err) { - eventStream.emit('error', err); - }); - - return eventStream; -} - -/** - * @api private - */ -module.exports = { - createEventStream: createEventStream }; - - -/***/ }), - -/***/ 466: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['mediatailor'] = {}; -AWS.MediaTailor = Service.defineService('mediatailor', ['2018-04-23']); -Object.defineProperty(apiLoader.services['mediatailor'], '2018-04-23', { - get: function get() { - var model = __webpack_require__(8892); - model.paginators = __webpack_require__(5369).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.MediaTailor; - - -/***/ }), - -/***/ 469: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['clouddirectory'] = {}; -AWS.CloudDirectory = Service.defineService('clouddirectory', ['2016-05-10', '2016-05-10*', '2017-01-11']); -Object.defineProperty(apiLoader.services['clouddirectory'], '2016-05-10', { - get: function get() { - var model = __webpack_require__(6869); - model.paginators = __webpack_require__(1287).pagination; - return model; - }, - enumerable: true, - configurable: true -}); -Object.defineProperty(apiLoader.services['clouddirectory'], '2017-01-11', { - get: function get() { - var model = __webpack_require__(2638); - model.paginators = __webpack_require__(8910).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.CloudDirectory; - - -/***/ }), - -/***/ 484: -/***/ (function(module) { - -module.exports = {"pagination":{"DescribeCodeCoverages":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken","result_key":"codeCoverages"},"DescribeTestCases":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken","result_key":"testCases"},"ListBuildBatches":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken","result_key":"ids"},"ListBuildBatchesForProject":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken","result_key":"ids"},"ListBuilds":{"input_token":"nextToken","output_token":"nextToken","result_key":"ids"},"ListBuildsForProject":{"input_token":"nextToken","output_token":"nextToken","result_key":"ids"},"ListProjects":{"input_token":"nextToken","output_token":"nextToken","result_key":"projects"},"ListReportGroups":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken","result_key":"reportGroups"},"ListReports":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken","result_key":"reports"},"ListReportsForReportGroup":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken","result_key":"reports"},"ListSharedProjects":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken","result_key":"projects"},"ListSharedReportGroups":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken","result_key":"reportGroups"}}}; - -/***/ }), - -/***/ 505: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2017-07-01","endpointPrefix":"mobile","jsonVersion":"1.1","protocol":"rest-json","serviceFullName":"AWS Mobile","serviceId":"Mobile","signatureVersion":"v4","signingName":"AWSMobileHubService","uid":"mobile-2017-07-01"},"operations":{"CreateProject":{"http":{"requestUri":"/projects"},"input":{"type":"structure","members":{"name":{"location":"querystring","locationName":"name"},"region":{"location":"querystring","locationName":"region"},"contents":{"type":"blob"},"snapshotId":{"location":"querystring","locationName":"snapshotId"}},"payload":"contents"},"output":{"type":"structure","members":{"details":{"shape":"S7"}}}},"DeleteProject":{"http":{"method":"DELETE","requestUri":"/projects/{projectId}"},"input":{"type":"structure","required":["projectId"],"members":{"projectId":{"location":"uri","locationName":"projectId"}}},"output":{"type":"structure","members":{"deletedResources":{"shape":"Sc"},"orphanedResources":{"shape":"Sc"}}}},"DescribeBundle":{"http":{"method":"GET","requestUri":"/bundles/{bundleId}"},"input":{"type":"structure","required":["bundleId"],"members":{"bundleId":{"location":"uri","locationName":"bundleId"}}},"output":{"type":"structure","members":{"details":{"shape":"Sq"}}}},"DescribeProject":{"http":{"method":"GET","requestUri":"/project"},"input":{"type":"structure","required":["projectId"],"members":{"projectId":{"location":"querystring","locationName":"projectId"},"syncFromResources":{"location":"querystring","locationName":"syncFromResources","type":"boolean"}}},"output":{"type":"structure","members":{"details":{"shape":"S7"}}}},"ExportBundle":{"http":{"requestUri":"/bundles/{bundleId}"},"input":{"type":"structure","required":["bundleId"],"members":{"bundleId":{"location":"uri","locationName":"bundleId"},"projectId":{"location":"querystring","locationName":"projectId"},"platform":{"location":"querystring","locationName":"platform"}}},"output":{"type":"structure","members":{"downloadUrl":{}}}},"ExportProject":{"http":{"requestUri":"/exports/{projectId}"},"input":{"type":"structure","required":["projectId"],"members":{"projectId":{"location":"uri","locationName":"projectId"}}},"output":{"type":"structure","members":{"downloadUrl":{},"shareUrl":{},"snapshotId":{}}}},"ListBundles":{"http":{"method":"GET","requestUri":"/bundles"},"input":{"type":"structure","members":{"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"nextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"bundleList":{"type":"list","member":{"shape":"Sq"}},"nextToken":{}}}},"ListProjects":{"http":{"method":"GET","requestUri":"/projects"},"input":{"type":"structure","members":{"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"nextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"projects":{"type":"list","member":{"type":"structure","members":{"name":{},"projectId":{}}}},"nextToken":{}}}},"UpdateProject":{"http":{"requestUri":"/update"},"input":{"type":"structure","required":["projectId"],"members":{"contents":{"type":"blob"},"projectId":{"location":"querystring","locationName":"projectId"}},"payload":"contents"},"output":{"type":"structure","members":{"details":{"shape":"S7"}}}}},"shapes":{"S7":{"type":"structure","members":{"name":{},"projectId":{},"region":{},"state":{},"createdDate":{"type":"timestamp"},"lastUpdatedDate":{"type":"timestamp"},"consoleUrl":{},"resources":{"shape":"Sc"}}},"Sc":{"type":"list","member":{"type":"structure","members":{"type":{},"name":{},"arn":{},"feature":{},"attributes":{"type":"map","key":{},"value":{}}}}},"Sq":{"type":"structure","members":{"bundleId":{},"title":{},"version":{},"description":{},"iconUrl":{},"availablePlatforms":{"type":"list","member":{}}}}}}; - -/***/ }), - -/***/ 520: -/***/ (function(module) { - -module.exports = {"pagination":{}}; - -/***/ }), - -/***/ 522: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2016-08-10","endpointPrefix":"batch","jsonVersion":"1.1","protocol":"rest-json","serviceAbbreviation":"AWS Batch","serviceFullName":"AWS Batch","serviceId":"Batch","signatureVersion":"v4","uid":"batch-2016-08-10"},"operations":{"CancelJob":{"http":{"requestUri":"/v1/canceljob"},"input":{"type":"structure","required":["jobId","reason"],"members":{"jobId":{},"reason":{}}},"output":{"type":"structure","members":{}}},"CreateComputeEnvironment":{"http":{"requestUri":"/v1/createcomputeenvironment"},"input":{"type":"structure","required":["computeEnvironmentName","type","serviceRole"],"members":{"computeEnvironmentName":{},"type":{},"state":{},"computeResources":{"shape":"S7"},"serviceRole":{}}},"output":{"type":"structure","members":{"computeEnvironmentName":{},"computeEnvironmentArn":{}}}},"CreateJobQueue":{"http":{"requestUri":"/v1/createjobqueue"},"input":{"type":"structure","required":["jobQueueName","priority","computeEnvironmentOrder"],"members":{"jobQueueName":{},"state":{},"priority":{"type":"integer"},"computeEnvironmentOrder":{"shape":"Sh"}}},"output":{"type":"structure","required":["jobQueueName","jobQueueArn"],"members":{"jobQueueName":{},"jobQueueArn":{}}}},"DeleteComputeEnvironment":{"http":{"requestUri":"/v1/deletecomputeenvironment"},"input":{"type":"structure","required":["computeEnvironment"],"members":{"computeEnvironment":{}}},"output":{"type":"structure","members":{}}},"DeleteJobQueue":{"http":{"requestUri":"/v1/deletejobqueue"},"input":{"type":"structure","required":["jobQueue"],"members":{"jobQueue":{}}},"output":{"type":"structure","members":{}}},"DeregisterJobDefinition":{"http":{"requestUri":"/v1/deregisterjobdefinition"},"input":{"type":"structure","required":["jobDefinition"],"members":{"jobDefinition":{}}},"output":{"type":"structure","members":{}}},"DescribeComputeEnvironments":{"http":{"requestUri":"/v1/describecomputeenvironments"},"input":{"type":"structure","members":{"computeEnvironments":{"shape":"Sb"},"maxResults":{"type":"integer"},"nextToken":{}}},"output":{"type":"structure","members":{"computeEnvironments":{"type":"list","member":{"type":"structure","required":["computeEnvironmentName","computeEnvironmentArn","ecsClusterArn"],"members":{"computeEnvironmentName":{},"computeEnvironmentArn":{},"ecsClusterArn":{},"type":{},"state":{},"status":{},"statusReason":{},"computeResources":{"shape":"S7"},"serviceRole":{}}}},"nextToken":{}}}},"DescribeJobDefinitions":{"http":{"requestUri":"/v1/describejobdefinitions"},"input":{"type":"structure","members":{"jobDefinitions":{"shape":"Sb"},"maxResults":{"type":"integer"},"jobDefinitionName":{},"status":{},"nextToken":{}}},"output":{"type":"structure","members":{"jobDefinitions":{"type":"list","member":{"type":"structure","required":["jobDefinitionName","jobDefinitionArn","revision","type"],"members":{"jobDefinitionName":{},"jobDefinitionArn":{},"revision":{"type":"integer"},"status":{},"type":{},"parameters":{"shape":"Sz"},"retryStrategy":{"shape":"S10"},"containerProperties":{"shape":"S11"},"timeout":{"shape":"S1k"},"nodeProperties":{"shape":"S1l"}}}},"nextToken":{}}}},"DescribeJobQueues":{"http":{"requestUri":"/v1/describejobqueues"},"input":{"type":"structure","members":{"jobQueues":{"shape":"Sb"},"maxResults":{"type":"integer"},"nextToken":{}}},"output":{"type":"structure","members":{"jobQueues":{"type":"list","member":{"type":"structure","required":["jobQueueName","jobQueueArn","state","priority","computeEnvironmentOrder"],"members":{"jobQueueName":{},"jobQueueArn":{},"state":{},"status":{},"statusReason":{},"priority":{"type":"integer"},"computeEnvironmentOrder":{"shape":"Sh"}}}},"nextToken":{}}}},"DescribeJobs":{"http":{"requestUri":"/v1/describejobs"},"input":{"type":"structure","required":["jobs"],"members":{"jobs":{"shape":"Sb"}}},"output":{"type":"structure","members":{"jobs":{"type":"list","member":{"type":"structure","required":["jobName","jobId","jobQueue","status","startedAt","jobDefinition"],"members":{"jobName":{},"jobId":{},"jobQueue":{},"status":{},"attempts":{"type":"list","member":{"type":"structure","members":{"container":{"type":"structure","members":{"containerInstanceArn":{},"taskArn":{},"exitCode":{"type":"integer"},"reason":{},"logStreamName":{},"networkInterfaces":{"shape":"S21"}}},"startedAt":{"type":"long"},"stoppedAt":{"type":"long"},"statusReason":{}}}},"statusReason":{},"createdAt":{"type":"long"},"retryStrategy":{"shape":"S10"},"startedAt":{"type":"long"},"stoppedAt":{"type":"long"},"dependsOn":{"shape":"S24"},"jobDefinition":{},"parameters":{"shape":"Sz"},"container":{"type":"structure","members":{"image":{},"vcpus":{"type":"integer"},"memory":{"type":"integer"},"command":{"shape":"Sb"},"jobRoleArn":{},"volumes":{"shape":"S12"},"environment":{"shape":"S15"},"mountPoints":{"shape":"S17"},"readonlyRootFilesystem":{"type":"boolean"},"ulimits":{"shape":"S1a"},"privileged":{"type":"boolean"},"user":{},"exitCode":{"type":"integer"},"reason":{},"containerInstanceArn":{},"taskArn":{},"logStreamName":{},"instanceType":{},"networkInterfaces":{"shape":"S21"},"resourceRequirements":{"shape":"S1c"},"linuxParameters":{"shape":"S1f"}}},"nodeDetails":{"type":"structure","members":{"nodeIndex":{"type":"integer"},"isMainNode":{"type":"boolean"}}},"nodeProperties":{"shape":"S1l"},"arrayProperties":{"type":"structure","members":{"statusSummary":{"type":"map","key":{},"value":{"type":"integer"}},"size":{"type":"integer"},"index":{"type":"integer"}}},"timeout":{"shape":"S1k"}}}}}}},"ListJobs":{"http":{"requestUri":"/v1/listjobs"},"input":{"type":"structure","members":{"jobQueue":{},"arrayJobId":{},"multiNodeJobId":{},"jobStatus":{},"maxResults":{"type":"integer"},"nextToken":{}}},"output":{"type":"structure","required":["jobSummaryList"],"members":{"jobSummaryList":{"type":"list","member":{"type":"structure","required":["jobId","jobName"],"members":{"jobId":{},"jobName":{},"createdAt":{"type":"long"},"status":{},"statusReason":{},"startedAt":{"type":"long"},"stoppedAt":{"type":"long"},"container":{"type":"structure","members":{"exitCode":{"type":"integer"},"reason":{}}},"arrayProperties":{"type":"structure","members":{"size":{"type":"integer"},"index":{"type":"integer"}}},"nodeProperties":{"type":"structure","members":{"isMainNode":{"type":"boolean"},"numNodes":{"type":"integer"},"nodeIndex":{"type":"integer"}}}}}},"nextToken":{}}}},"RegisterJobDefinition":{"http":{"requestUri":"/v1/registerjobdefinition"},"input":{"type":"structure","required":["jobDefinitionName","type"],"members":{"jobDefinitionName":{},"type":{},"parameters":{"shape":"Sz"},"containerProperties":{"shape":"S11"},"nodeProperties":{"shape":"S1l"},"retryStrategy":{"shape":"S10"},"timeout":{"shape":"S1k"}}},"output":{"type":"structure","required":["jobDefinitionName","jobDefinitionArn","revision"],"members":{"jobDefinitionName":{},"jobDefinitionArn":{},"revision":{"type":"integer"}}}},"SubmitJob":{"http":{"requestUri":"/v1/submitjob"},"input":{"type":"structure","required":["jobName","jobQueue","jobDefinition"],"members":{"jobName":{},"jobQueue":{},"arrayProperties":{"type":"structure","members":{"size":{"type":"integer"}}},"dependsOn":{"shape":"S24"},"jobDefinition":{},"parameters":{"shape":"Sz"},"containerOverrides":{"shape":"S2n"},"nodeOverrides":{"type":"structure","members":{"numNodes":{"type":"integer"},"nodePropertyOverrides":{"type":"list","member":{"type":"structure","required":["targetNodes"],"members":{"targetNodes":{},"containerOverrides":{"shape":"S2n"}}}}}},"retryStrategy":{"shape":"S10"},"timeout":{"shape":"S1k"}}},"output":{"type":"structure","required":["jobName","jobId"],"members":{"jobName":{},"jobId":{}}}},"TerminateJob":{"http":{"requestUri":"/v1/terminatejob"},"input":{"type":"structure","required":["jobId","reason"],"members":{"jobId":{},"reason":{}}},"output":{"type":"structure","members":{}}},"UpdateComputeEnvironment":{"http":{"requestUri":"/v1/updatecomputeenvironment"},"input":{"type":"structure","required":["computeEnvironment"],"members":{"computeEnvironment":{},"state":{},"computeResources":{"type":"structure","members":{"minvCpus":{"type":"integer"},"maxvCpus":{"type":"integer"},"desiredvCpus":{"type":"integer"}}},"serviceRole":{}}},"output":{"type":"structure","members":{"computeEnvironmentName":{},"computeEnvironmentArn":{}}}},"UpdateJobQueue":{"http":{"requestUri":"/v1/updatejobqueue"},"input":{"type":"structure","required":["jobQueue"],"members":{"jobQueue":{},"state":{},"priority":{"type":"integer"},"computeEnvironmentOrder":{"shape":"Sh"}}},"output":{"type":"structure","members":{"jobQueueName":{},"jobQueueArn":{}}}}},"shapes":{"S7":{"type":"structure","required":["type","minvCpus","maxvCpus","instanceTypes","subnets","instanceRole"],"members":{"type":{},"allocationStrategy":{},"minvCpus":{"type":"integer"},"maxvCpus":{"type":"integer"},"desiredvCpus":{"type":"integer"},"instanceTypes":{"shape":"Sb"},"imageId":{},"subnets":{"shape":"Sb"},"securityGroupIds":{"shape":"Sb"},"ec2KeyPair":{},"instanceRole":{},"tags":{"type":"map","key":{},"value":{}},"placementGroup":{},"bidPercentage":{"type":"integer"},"spotIamFleetRole":{},"launchTemplate":{"type":"structure","members":{"launchTemplateId":{},"launchTemplateName":{},"version":{}}}}},"Sb":{"type":"list","member":{}},"Sh":{"type":"list","member":{"type":"structure","required":["order","computeEnvironment"],"members":{"order":{"type":"integer"},"computeEnvironment":{}}}},"Sz":{"type":"map","key":{},"value":{}},"S10":{"type":"structure","members":{"attempts":{"type":"integer"}}},"S11":{"type":"structure","members":{"image":{},"vcpus":{"type":"integer"},"memory":{"type":"integer"},"command":{"shape":"Sb"},"jobRoleArn":{},"volumes":{"shape":"S12"},"environment":{"shape":"S15"},"mountPoints":{"shape":"S17"},"readonlyRootFilesystem":{"type":"boolean"},"privileged":{"type":"boolean"},"ulimits":{"shape":"S1a"},"user":{},"instanceType":{},"resourceRequirements":{"shape":"S1c"},"linuxParameters":{"shape":"S1f"}}},"S12":{"type":"list","member":{"type":"structure","members":{"host":{"type":"structure","members":{"sourcePath":{}}},"name":{}}}},"S15":{"type":"list","member":{"type":"structure","members":{"name":{},"value":{}}}},"S17":{"type":"list","member":{"type":"structure","members":{"containerPath":{},"readOnly":{"type":"boolean"},"sourceVolume":{}}}},"S1a":{"type":"list","member":{"type":"structure","required":["hardLimit","name","softLimit"],"members":{"hardLimit":{"type":"integer"},"name":{},"softLimit":{"type":"integer"}}}},"S1c":{"type":"list","member":{"type":"structure","required":["value","type"],"members":{"value":{},"type":{}}}},"S1f":{"type":"structure","members":{"devices":{"type":"list","member":{"type":"structure","required":["hostPath"],"members":{"hostPath":{},"containerPath":{},"permissions":{"type":"list","member":{}}}}}}},"S1k":{"type":"structure","members":{"attemptDurationSeconds":{"type":"integer"}}},"S1l":{"type":"structure","required":["numNodes","mainNode","nodeRangeProperties"],"members":{"numNodes":{"type":"integer"},"mainNode":{"type":"integer"},"nodeRangeProperties":{"type":"list","member":{"type":"structure","required":["targetNodes"],"members":{"targetNodes":{},"container":{"shape":"S11"}}}}}},"S21":{"type":"list","member":{"type":"structure","members":{"attachmentId":{},"ipv6Address":{},"privateIpv4Address":{}}}},"S24":{"type":"list","member":{"type":"structure","members":{"jobId":{},"type":{}}}},"S2n":{"type":"structure","members":{"vcpus":{"type":"integer"},"memory":{"type":"integer"},"command":{"shape":"Sb"},"instanceType":{},"environment":{"shape":"S15"},"resourceRequirements":{"shape":"S1c"}}}}}; - -/***/ }), - -/***/ 543: -/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) { - -var AWS = __webpack_require__(395); - -AWS.util.update(AWS.Glacier.prototype, { - /** - * @api private - */ - setupRequestListeners: function setupRequestListeners(request) { - if (Array.isArray(request._events.validate)) { - request._events.validate.unshift(this.validateAccountId); - } else { - request.on('validate', this.validateAccountId); +let LimitExceededException$1 = class LimitExceededException extends CloudFormationServiceException$1 { + name = "LimitExceededException"; + $fault = "client"; + Message; + constructor(opts) { + super({ + name: "LimitExceededException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, LimitExceededException.prototype); + this.Message = opts.Message; } - request.removeListener('afterBuild', - AWS.EventListeners.Core.COMPUTE_SHA256); - request.on('build', this.addGlacierApiVersion); - request.on('build', this.addTreeHashHeaders); - }, - - /** - * @api private - */ - validateAccountId: function validateAccountId(request) { - if (request.params.accountId !== undefined) return; - request.params = AWS.util.copy(request.params); - request.params.accountId = '-'; - }, - - /** - * @api private - */ - addGlacierApiVersion: function addGlacierApiVersion(request) { - var version = request.service.api.apiVersion; - request.httpRequest.headers['x-amz-glacier-version'] = version; - }, - - /** - * @api private - */ - addTreeHashHeaders: function addTreeHashHeaders(request) { - if (request.params.body === undefined) return; - - var hashes = request.service.computeChecksums(request.params.body); - request.httpRequest.headers['X-Amz-Content-Sha256'] = hashes.linearHash; - - if (!request.httpRequest.headers['x-amz-sha256-tree-hash']) { - request.httpRequest.headers['x-amz-sha256-tree-hash'] = hashes.treeHash; +}; +let ConcurrentResourcesLimitExceededException$1 = class ConcurrentResourcesLimitExceededException extends CloudFormationServiceException$1 { + name = "ConcurrentResourcesLimitExceededException"; + $fault = "client"; + Message; + constructor(opts) { + super({ + name: "ConcurrentResourcesLimitExceededException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, ConcurrentResourcesLimitExceededException.prototype); + this.Message = opts.Message; } - }, - - /** - * @!group Computing Checksums - */ - - /** - * Computes the SHA-256 linear and tree hash checksums for a given - * block of Buffer data. Pass the tree hash of the computed checksums - * as the checksum input to the {completeMultipartUpload} when performing - * a multi-part upload. - * - * @example Calculate checksum of 5.5MB data chunk - * var glacier = new AWS.Glacier(); - * var data = Buffer.alloc(5.5 * 1024 * 1024); - * data.fill('0'); // fill with zeros - * var results = glacier.computeChecksums(data); - * // Result: { linearHash: '68aff0c5a9...', treeHash: '154e26c78f...' } - * @param data [Buffer, String] data to calculate the checksum for - * @return [map] a map containing - * the linearHash and treeHash properties representing hex based digests - * of the respective checksums. - * @see completeMultipartUpload - */ - computeChecksums: function computeChecksums(data) { - if (!AWS.util.Buffer.isBuffer(data)) data = AWS.util.buffer.toBuffer(data); - - var mb = 1024 * 1024; - var hashes = []; - var hash = AWS.util.crypto.createHash('sha256'); - - // build leaf nodes in 1mb chunks - for (var i = 0; i < data.length; i += mb) { - var chunk = data.slice(i, Math.min(i + mb, data.length)); - hash.update(chunk); - hashes.push(AWS.util.crypto.sha256(chunk)); +}; +let OperationIdAlreadyExistsException$1 = class OperationIdAlreadyExistsException extends CloudFormationServiceException$1 { + name = "OperationIdAlreadyExistsException"; + $fault = "client"; + Message; + constructor(opts) { + super({ + name: "OperationIdAlreadyExistsException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, OperationIdAlreadyExistsException.prototype); + this.Message = opts.Message; } - - return { - linearHash: hash.digest('hex'), - treeHash: this.buildHashTree(hashes) - }; - }, - - /** - * @api private - */ - buildHashTree: function buildHashTree(hashes) { - // merge leaf nodes - while (hashes.length > 1) { - var tmpHashes = []; - for (var i = 0; i < hashes.length; i += 2) { - if (hashes[i + 1]) { - var tmpHash = AWS.util.buffer.alloc(64); - tmpHash.write(hashes[i], 0, 32, 'binary'); - tmpHash.write(hashes[i + 1], 32, 32, 'binary'); - tmpHashes.push(AWS.util.crypto.sha256(tmpHash)); - } else { - tmpHashes.push(hashes[i]); - } - } - hashes = tmpHashes; +}; +let OperationInProgressException$1 = class OperationInProgressException extends CloudFormationServiceException$1 { + name = "OperationInProgressException"; + $fault = "client"; + Message; + constructor(opts) { + super({ + name: "OperationInProgressException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, OperationInProgressException.prototype); + this.Message = opts.Message; } - - return AWS.util.crypto.toHex(hashes[0]); - } -}); - - -/***/ }), - -/***/ 556: -/***/ (function(module) { - -"use strict"; -// YAML error class. http://stackoverflow.com/questions/8458984 -// - - -function YAMLException(reason, mark) { - // Super constructor - Error.call(this); - - this.name = 'YAMLException'; - this.reason = reason; - this.mark = mark; - this.message = (this.reason || '(unknown reason)') + (this.mark ? ' ' + this.mark.toString() : ''); - - // Include stack trace in error object - if (Error.captureStackTrace) { - // Chrome and NodeJS - Error.captureStackTrace(this, this.constructor); - } else { - // FF, IE 10+ and Safari 6+. Fallback for others - this.stack = (new Error()).stack || ''; - } -} - - -// Inherit from Error -YAMLException.prototype = Object.create(Error.prototype); -YAMLException.prototype.constructor = YAMLException; - - -YAMLException.prototype.toString = function toString(compact) { - var result = this.name + ': '; - - result += this.reason || '(unknown reason)'; - - if (!compact && this.mark) { - result += ' ' + this.mark.toString(); - } - - return result; }; - - -module.exports = YAMLException; - - -/***/ }), - -/***/ 559: -/***/ (function(module) { - -module.exports = {"pagination":{"DescribeAccountLimits":{"input_token":"NextToken","output_token":"NextToken","result_key":"AccountLimits"},"DescribeStackEvents":{"input_token":"NextToken","output_token":"NextToken","result_key":"StackEvents"},"DescribeStackResourceDrifts":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"DescribeStackResources":{"result_key":"StackResources"},"DescribeStacks":{"input_token":"NextToken","output_token":"NextToken","result_key":"Stacks"},"ListChangeSets":{"input_token":"NextToken","output_token":"NextToken","result_key":"Summaries"},"ListExports":{"input_token":"NextToken","output_token":"NextToken","result_key":"Exports"},"ListImports":{"input_token":"NextToken","output_token":"NextToken","result_key":"Imports"},"ListStackInstances":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Summaries"},"ListStackResources":{"input_token":"NextToken","output_token":"NextToken","result_key":"StackResourceSummaries"},"ListStackSetOperationResults":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Summaries"},"ListStackSetOperations":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Summaries"},"ListStackSets":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Summaries"},"ListStacks":{"input_token":"NextToken","output_token":"NextToken","result_key":"StackSummaries"},"ListTypeRegistrations":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"ListTypeVersions":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"ListTypes":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"}}}; - -/***/ }), - -/***/ 576: -/***/ (function(module, __unusedexports, __webpack_require__) { - -var AWS = __webpack_require__(395); -var util = __webpack_require__(153); -var QueryParamSerializer = __webpack_require__(439); -var Shape = __webpack_require__(3682); -var populateHostPrefix = __webpack_require__(904).populateHostPrefix; - -function buildRequest(req) { - var operation = req.service.api.operations[req.operation]; - var httpRequest = req.httpRequest; - httpRequest.headers['Content-Type'] = - 'application/x-www-form-urlencoded; charset=utf-8'; - httpRequest.params = { - Version: req.service.api.apiVersion, - Action: operation.name - }; - - // convert the request parameters into a list of query params, - // e.g. Deeply.NestedParam.0.Name=value - var builder = new QueryParamSerializer(); - builder.serialize(req.params, operation.input, function(name, value) { - httpRequest.params[name] = value; - }); - httpRequest.body = util.queryParamsToString(httpRequest.params); - - populateHostPrefix(req); -} - -function extractError(resp) { - var data, body = resp.httpResponse.body.toString(); - if (body.match(' 9223372036854775807 || number < -9223372036854775808) { - throw new Error( - number + ' is too large (or, if negative, too small) to represent as an Int64' - ); +}; +let NameAlreadyExistsException$1 = class NameAlreadyExistsException extends CloudFormationServiceException$1 { + name = "NameAlreadyExistsException"; + $fault = "client"; + Message; + constructor(opts) { + super({ + name: "NameAlreadyExistsException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, NameAlreadyExistsException.prototype); + this.Message = opts.Message; } - - var bytes = new Uint8Array(8); - for ( - var i = 7, remaining = Math.abs(Math.round(number)); - i > -1 && remaining > 0; - i--, remaining /= 256 - ) { - bytes[i] = remaining; +}; +let InvalidChangeSetStatusException$1 = class InvalidChangeSetStatusException extends CloudFormationServiceException$1 { + name = "InvalidChangeSetStatusException"; + $fault = "client"; + Message; + constructor(opts) { + super({ + name: "InvalidChangeSetStatusException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, InvalidChangeSetStatusException.prototype); + this.Message = opts.Message; } - - if (number < 0) { - negate(bytes); +}; +let GeneratedTemplateNotFoundException$1 = class GeneratedTemplateNotFoundException extends CloudFormationServiceException$1 { + name = "GeneratedTemplateNotFoundException"; + $fault = "client"; + Message; + constructor(opts) { + super({ + name: "GeneratedTemplateNotFoundException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, GeneratedTemplateNotFoundException.prototype); + this.Message = opts.Message; } - - return new Int64(bytes); }; - -/** - * @returns {number} - * - * @api private - */ -Int64.prototype.valueOf = function() { - var bytes = this.bytes.slice(0); - var negative = bytes[0] & 128; - if (negative) { - negate(bytes); +let StackSetNotEmptyException$1 = class StackSetNotEmptyException extends CloudFormationServiceException$1 { + name = "StackSetNotEmptyException"; + $fault = "client"; + Message; + constructor(opts) { + super({ + name: "StackSetNotEmptyException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, StackSetNotEmptyException.prototype); + this.Message = opts.Message; } - - return parseInt(bytes.toString('hex'), 16) * (negative ? -1 : 1); }; - -Int64.prototype.toString = function() { - return String(this.valueOf()); +let ResourceScanNotFoundException$1 = class ResourceScanNotFoundException extends CloudFormationServiceException$1 { + name = "ResourceScanNotFoundException"; + $fault = "client"; + Message; + constructor(opts) { + super({ + name: "ResourceScanNotFoundException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, ResourceScanNotFoundException.prototype); + this.Message = opts.Message; + } }; - -/** - * @param {Buffer} bytes - * - * @api private - */ -function negate(bytes) { - for (var i = 0; i < 8; i++) { - bytes[i] ^= 0xFF; +let StackInstanceNotFoundException$1 = class StackInstanceNotFoundException extends CloudFormationServiceException$1 { + name = "StackInstanceNotFoundException"; + $fault = "client"; + Message; + constructor(opts) { + super({ + name: "StackInstanceNotFoundException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, StackInstanceNotFoundException.prototype); + this.Message = opts.Message; } - for (var i = 7; i > -1; i--) { - bytes[i]++; - if (bytes[i] !== 0) { - break; - } +}; +let StackRefactorNotFoundException$1 = class StackRefactorNotFoundException extends CloudFormationServiceException$1 { + name = "StackRefactorNotFoundException"; + $fault = "client"; + Message; + constructor(opts) { + super({ + name: "StackRefactorNotFoundException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, StackRefactorNotFoundException.prototype); + this.Message = opts.Message; } -} - -/** - * @api private - */ -module.exports = { - Int64: Int64 }; - - -/***/ }), - -/***/ 612: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2016-02-16","endpointPrefix":"inspector","jsonVersion":"1.1","protocol":"json","serviceFullName":"Amazon Inspector","serviceId":"Inspector","signatureVersion":"v4","targetPrefix":"InspectorService","uid":"inspector-2016-02-16"},"operations":{"AddAttributesToFindings":{"input":{"type":"structure","required":["findingArns","attributes"],"members":{"findingArns":{"shape":"S2"},"attributes":{"shape":"S4"}}},"output":{"type":"structure","required":["failedItems"],"members":{"failedItems":{"shape":"S9"}}}},"CreateAssessmentTarget":{"input":{"type":"structure","required":["assessmentTargetName"],"members":{"assessmentTargetName":{},"resourceGroupArn":{}}},"output":{"type":"structure","required":["assessmentTargetArn"],"members":{"assessmentTargetArn":{}}}},"CreateAssessmentTemplate":{"input":{"type":"structure","required":["assessmentTargetArn","assessmentTemplateName","durationInSeconds","rulesPackageArns"],"members":{"assessmentTargetArn":{},"assessmentTemplateName":{},"durationInSeconds":{"type":"integer"},"rulesPackageArns":{"shape":"Sj"},"userAttributesForFindings":{"shape":"S4"}}},"output":{"type":"structure","required":["assessmentTemplateArn"],"members":{"assessmentTemplateArn":{}}}},"CreateExclusionsPreview":{"input":{"type":"structure","required":["assessmentTemplateArn"],"members":{"assessmentTemplateArn":{}}},"output":{"type":"structure","required":["previewToken"],"members":{"previewToken":{}}}},"CreateResourceGroup":{"input":{"type":"structure","required":["resourceGroupTags"],"members":{"resourceGroupTags":{"shape":"Sp"}}},"output":{"type":"structure","required":["resourceGroupArn"],"members":{"resourceGroupArn":{}}}},"DeleteAssessmentRun":{"input":{"type":"structure","required":["assessmentRunArn"],"members":{"assessmentRunArn":{}}}},"DeleteAssessmentTarget":{"input":{"type":"structure","required":["assessmentTargetArn"],"members":{"assessmentTargetArn":{}}}},"DeleteAssessmentTemplate":{"input":{"type":"structure","required":["assessmentTemplateArn"],"members":{"assessmentTemplateArn":{}}}},"DescribeAssessmentRuns":{"input":{"type":"structure","required":["assessmentRunArns"],"members":{"assessmentRunArns":{"shape":"Sy"}}},"output":{"type":"structure","required":["assessmentRuns","failedItems"],"members":{"assessmentRuns":{"type":"list","member":{"type":"structure","required":["arn","name","assessmentTemplateArn","state","durationInSeconds","rulesPackageArns","userAttributesForFindings","createdAt","stateChangedAt","dataCollected","stateChanges","notifications","findingCounts"],"members":{"arn":{},"name":{},"assessmentTemplateArn":{},"state":{},"durationInSeconds":{"type":"integer"},"rulesPackageArns":{"type":"list","member":{}},"userAttributesForFindings":{"shape":"S4"},"createdAt":{"type":"timestamp"},"startedAt":{"type":"timestamp"},"completedAt":{"type":"timestamp"},"stateChangedAt":{"type":"timestamp"},"dataCollected":{"type":"boolean"},"stateChanges":{"type":"list","member":{"type":"structure","required":["stateChangedAt","state"],"members":{"stateChangedAt":{"type":"timestamp"},"state":{}}}},"notifications":{"type":"list","member":{"type":"structure","required":["date","event","error"],"members":{"date":{"type":"timestamp"},"event":{},"message":{},"error":{"type":"boolean"},"snsTopicArn":{},"snsPublishStatusCode":{}}}},"findingCounts":{"type":"map","key":{},"value":{"type":"integer"}}}}},"failedItems":{"shape":"S9"}}}},"DescribeAssessmentTargets":{"input":{"type":"structure","required":["assessmentTargetArns"],"members":{"assessmentTargetArns":{"shape":"Sy"}}},"output":{"type":"structure","required":["assessmentTargets","failedItems"],"members":{"assessmentTargets":{"type":"list","member":{"type":"structure","required":["arn","name","createdAt","updatedAt"],"members":{"arn":{},"name":{},"resourceGroupArn":{},"createdAt":{"type":"timestamp"},"updatedAt":{"type":"timestamp"}}}},"failedItems":{"shape":"S9"}}}},"DescribeAssessmentTemplates":{"input":{"type":"structure","required":["assessmentTemplateArns"],"members":{"assessmentTemplateArns":{"shape":"Sy"}}},"output":{"type":"structure","required":["assessmentTemplates","failedItems"],"members":{"assessmentTemplates":{"type":"list","member":{"type":"structure","required":["arn","name","assessmentTargetArn","durationInSeconds","rulesPackageArns","userAttributesForFindings","assessmentRunCount","createdAt"],"members":{"arn":{},"name":{},"assessmentTargetArn":{},"durationInSeconds":{"type":"integer"},"rulesPackageArns":{"shape":"Sj"},"userAttributesForFindings":{"shape":"S4"},"lastAssessmentRunArn":{},"assessmentRunCount":{"type":"integer"},"createdAt":{"type":"timestamp"}}}},"failedItems":{"shape":"S9"}}}},"DescribeCrossAccountAccessRole":{"output":{"type":"structure","required":["roleArn","valid","registeredAt"],"members":{"roleArn":{},"valid":{"type":"boolean"},"registeredAt":{"type":"timestamp"}}}},"DescribeExclusions":{"input":{"type":"structure","required":["exclusionArns"],"members":{"exclusionArns":{"type":"list","member":{}},"locale":{}}},"output":{"type":"structure","required":["exclusions","failedItems"],"members":{"exclusions":{"type":"map","key":{},"value":{"type":"structure","required":["arn","title","description","recommendation","scopes"],"members":{"arn":{},"title":{},"description":{},"recommendation":{},"scopes":{"shape":"S1x"},"attributes":{"shape":"S21"}}}},"failedItems":{"shape":"S9"}}}},"DescribeFindings":{"input":{"type":"structure","required":["findingArns"],"members":{"findingArns":{"shape":"Sy"},"locale":{}}},"output":{"type":"structure","required":["findings","failedItems"],"members":{"findings":{"type":"list","member":{"type":"structure","required":["arn","attributes","userAttributes","createdAt","updatedAt"],"members":{"arn":{},"schemaVersion":{"type":"integer"},"service":{},"serviceAttributes":{"type":"structure","required":["schemaVersion"],"members":{"schemaVersion":{"type":"integer"},"assessmentRunArn":{},"rulesPackageArn":{}}},"assetType":{},"assetAttributes":{"type":"structure","required":["schemaVersion"],"members":{"schemaVersion":{"type":"integer"},"agentId":{},"autoScalingGroup":{},"amiId":{},"hostname":{},"ipv4Addresses":{"type":"list","member":{}},"tags":{"type":"list","member":{"shape":"S2i"}},"networkInterfaces":{"type":"list","member":{"type":"structure","members":{"networkInterfaceId":{},"subnetId":{},"vpcId":{},"privateDnsName":{},"privateIpAddress":{},"privateIpAddresses":{"type":"list","member":{"type":"structure","members":{"privateDnsName":{},"privateIpAddress":{}}}},"publicDnsName":{},"publicIp":{},"ipv6Addresses":{"type":"list","member":{}},"securityGroups":{"type":"list","member":{"type":"structure","members":{"groupName":{},"groupId":{}}}}}}}}},"id":{},"title":{},"description":{},"recommendation":{},"severity":{},"numericSeverity":{"type":"double"},"confidence":{"type":"integer"},"indicatorOfCompromise":{"type":"boolean"},"attributes":{"shape":"S21"},"userAttributes":{"shape":"S4"},"createdAt":{"type":"timestamp"},"updatedAt":{"type":"timestamp"}}}},"failedItems":{"shape":"S9"}}}},"DescribeResourceGroups":{"input":{"type":"structure","required":["resourceGroupArns"],"members":{"resourceGroupArns":{"shape":"Sy"}}},"output":{"type":"structure","required":["resourceGroups","failedItems"],"members":{"resourceGroups":{"type":"list","member":{"type":"structure","required":["arn","tags","createdAt"],"members":{"arn":{},"tags":{"shape":"Sp"},"createdAt":{"type":"timestamp"}}}},"failedItems":{"shape":"S9"}}}},"DescribeRulesPackages":{"input":{"type":"structure","required":["rulesPackageArns"],"members":{"rulesPackageArns":{"shape":"Sy"},"locale":{}}},"output":{"type":"structure","required":["rulesPackages","failedItems"],"members":{"rulesPackages":{"type":"list","member":{"type":"structure","required":["arn","name","version","provider"],"members":{"arn":{},"name":{},"version":{},"provider":{},"description":{}}}},"failedItems":{"shape":"S9"}}}},"GetAssessmentReport":{"input":{"type":"structure","required":["assessmentRunArn","reportFileFormat","reportType"],"members":{"assessmentRunArn":{},"reportFileFormat":{},"reportType":{}}},"output":{"type":"structure","required":["status"],"members":{"status":{},"url":{}}}},"GetExclusionsPreview":{"input":{"type":"structure","required":["assessmentTemplateArn","previewToken"],"members":{"assessmentTemplateArn":{},"previewToken":{},"nextToken":{},"maxResults":{"type":"integer"},"locale":{}}},"output":{"type":"structure","required":["previewStatus"],"members":{"previewStatus":{},"exclusionPreviews":{"type":"list","member":{"type":"structure","required":["title","description","recommendation","scopes"],"members":{"title":{},"description":{},"recommendation":{},"scopes":{"shape":"S1x"},"attributes":{"shape":"S21"}}}},"nextToken":{}}}},"GetTelemetryMetadata":{"input":{"type":"structure","required":["assessmentRunArn"],"members":{"assessmentRunArn":{}}},"output":{"type":"structure","required":["telemetryMetadata"],"members":{"telemetryMetadata":{"shape":"S3j"}}}},"ListAssessmentRunAgents":{"input":{"type":"structure","required":["assessmentRunArn"],"members":{"assessmentRunArn":{},"filter":{"type":"structure","required":["agentHealths","agentHealthCodes"],"members":{"agentHealths":{"type":"list","member":{}},"agentHealthCodes":{"type":"list","member":{}}}},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","required":["assessmentRunAgents"],"members":{"assessmentRunAgents":{"type":"list","member":{"type":"structure","required":["agentId","assessmentRunArn","agentHealth","agentHealthCode","telemetryMetadata"],"members":{"agentId":{},"assessmentRunArn":{},"agentHealth":{},"agentHealthCode":{},"agentHealthDetails":{},"autoScalingGroup":{},"telemetryMetadata":{"shape":"S3j"}}}},"nextToken":{}}}},"ListAssessmentRuns":{"input":{"type":"structure","members":{"assessmentTemplateArns":{"shape":"S3x"},"filter":{"type":"structure","members":{"namePattern":{},"states":{"type":"list","member":{}},"durationRange":{"shape":"S41"},"rulesPackageArns":{"shape":"S42"},"startTimeRange":{"shape":"S43"},"completionTimeRange":{"shape":"S43"},"stateChangeTimeRange":{"shape":"S43"}}},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","required":["assessmentRunArns"],"members":{"assessmentRunArns":{"shape":"S45"},"nextToken":{}}}},"ListAssessmentTargets":{"input":{"type":"structure","members":{"filter":{"type":"structure","members":{"assessmentTargetNamePattern":{}}},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","required":["assessmentTargetArns"],"members":{"assessmentTargetArns":{"shape":"S45"},"nextToken":{}}}},"ListAssessmentTemplates":{"input":{"type":"structure","members":{"assessmentTargetArns":{"shape":"S3x"},"filter":{"type":"structure","members":{"namePattern":{},"durationRange":{"shape":"S41"},"rulesPackageArns":{"shape":"S42"}}},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","required":["assessmentTemplateArns"],"members":{"assessmentTemplateArns":{"shape":"S45"},"nextToken":{}}}},"ListEventSubscriptions":{"input":{"type":"structure","members":{"resourceArn":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","required":["subscriptions"],"members":{"subscriptions":{"type":"list","member":{"type":"structure","required":["resourceArn","topicArn","eventSubscriptions"],"members":{"resourceArn":{},"topicArn":{},"eventSubscriptions":{"type":"list","member":{"type":"structure","required":["event","subscribedAt"],"members":{"event":{},"subscribedAt":{"type":"timestamp"}}}}}}},"nextToken":{}}}},"ListExclusions":{"input":{"type":"structure","required":["assessmentRunArn"],"members":{"assessmentRunArn":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","required":["exclusionArns"],"members":{"exclusionArns":{"shape":"S45"},"nextToken":{}}}},"ListFindings":{"input":{"type":"structure","members":{"assessmentRunArns":{"shape":"S3x"},"filter":{"type":"structure","members":{"agentIds":{"type":"list","member":{}},"autoScalingGroups":{"type":"list","member":{}},"ruleNames":{"type":"list","member":{}},"severities":{"type":"list","member":{}},"rulesPackageArns":{"shape":"S42"},"attributes":{"shape":"S21"},"userAttributes":{"shape":"S21"},"creationTimeRange":{"shape":"S43"}}},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","required":["findingArns"],"members":{"findingArns":{"shape":"S45"},"nextToken":{}}}},"ListRulesPackages":{"input":{"type":"structure","members":{"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","required":["rulesPackageArns"],"members":{"rulesPackageArns":{"shape":"S45"},"nextToken":{}}}},"ListTagsForResource":{"input":{"type":"structure","required":["resourceArn"],"members":{"resourceArn":{}}},"output":{"type":"structure","required":["tags"],"members":{"tags":{"shape":"S4x"}}}},"PreviewAgents":{"input":{"type":"structure","required":["previewAgentsArn"],"members":{"previewAgentsArn":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","required":["agentPreviews"],"members":{"agentPreviews":{"type":"list","member":{"type":"structure","required":["agentId"],"members":{"hostname":{},"agentId":{},"autoScalingGroup":{},"agentHealth":{},"agentVersion":{},"operatingSystem":{},"kernelVersion":{},"ipv4Address":{}}}},"nextToken":{}}}},"RegisterCrossAccountAccessRole":{"input":{"type":"structure","required":["roleArn"],"members":{"roleArn":{}}}},"RemoveAttributesFromFindings":{"input":{"type":"structure","required":["findingArns","attributeKeys"],"members":{"findingArns":{"shape":"S2"},"attributeKeys":{"type":"list","member":{}}}},"output":{"type":"structure","required":["failedItems"],"members":{"failedItems":{"shape":"S9"}}}},"SetTagsForResource":{"input":{"type":"structure","required":["resourceArn"],"members":{"resourceArn":{},"tags":{"shape":"S4x"}}}},"StartAssessmentRun":{"input":{"type":"structure","required":["assessmentTemplateArn"],"members":{"assessmentTemplateArn":{},"assessmentRunName":{}}},"output":{"type":"structure","required":["assessmentRunArn"],"members":{"assessmentRunArn":{}}}},"StopAssessmentRun":{"input":{"type":"structure","required":["assessmentRunArn"],"members":{"assessmentRunArn":{},"stopAction":{}}}},"SubscribeToEvent":{"input":{"type":"structure","required":["resourceArn","event","topicArn"],"members":{"resourceArn":{},"event":{},"topicArn":{}}}},"UnsubscribeFromEvent":{"input":{"type":"structure","required":["resourceArn","event","topicArn"],"members":{"resourceArn":{},"event":{},"topicArn":{}}}},"UpdateAssessmentTarget":{"input":{"type":"structure","required":["assessmentTargetArn","assessmentTargetName"],"members":{"assessmentTargetArn":{},"assessmentTargetName":{},"resourceGroupArn":{}}}}},"shapes":{"S2":{"type":"list","member":{}},"S4":{"type":"list","member":{"shape":"S5"}},"S5":{"type":"structure","required":["key"],"members":{"key":{},"value":{}}},"S9":{"type":"map","key":{},"value":{"type":"structure","required":["failureCode","retryable"],"members":{"failureCode":{},"retryable":{"type":"boolean"}}}},"Sj":{"type":"list","member":{}},"Sp":{"type":"list","member":{"type":"structure","required":["key"],"members":{"key":{},"value":{}}}},"Sy":{"type":"list","member":{}},"S1x":{"type":"list","member":{"type":"structure","members":{"key":{},"value":{}}}},"S21":{"type":"list","member":{"shape":"S5"}},"S2i":{"type":"structure","required":["key"],"members":{"key":{},"value":{}}},"S3j":{"type":"list","member":{"type":"structure","required":["messageType","count"],"members":{"messageType":{},"count":{"type":"long"},"dataSize":{"type":"long"}}}},"S3x":{"type":"list","member":{}},"S41":{"type":"structure","members":{"minSeconds":{"type":"integer"},"maxSeconds":{"type":"integer"}}},"S42":{"type":"list","member":{}},"S43":{"type":"structure","members":{"beginDate":{"type":"timestamp"},"endDate":{"type":"timestamp"}}},"S45":{"type":"list","member":{}},"S4x":{"type":"list","member":{"shape":"S2i"}}}}; - -/***/ }), - -/***/ 623: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['codeguruprofiler'] = {}; -AWS.CodeGuruProfiler = Service.defineService('codeguruprofiler', ['2019-07-18']); -Object.defineProperty(apiLoader.services['codeguruprofiler'], '2019-07-18', { - get: function get() { - var model = __webpack_require__(5408); - model.paginators = __webpack_require__(4571).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.CodeGuruProfiler; - - -/***/ }), - -/***/ 625: -/***/ (function(module) { - -/** - * Takes in a buffer of event messages and splits them into individual messages. - * @param {Buffer} buffer - * @api private - */ -function eventMessageChunker(buffer) { - /** @type Buffer[] */ - var messages = []; - var offset = 0; - - while (offset < buffer.length) { - var totalLength = buffer.readInt32BE(offset); - - // create new buffer for individual message (shares memory with original) - var message = buffer.slice(offset, totalLength + offset); - // increment offset to it starts at the next message - offset += totalLength; - - messages.push(message); +let HookResultNotFoundException$1 = class HookResultNotFoundException extends CloudFormationServiceException$1 { + name = "HookResultNotFoundException"; + $fault = "client"; + Message; + constructor(opts) { + super({ + name: "HookResultNotFoundException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, HookResultNotFoundException.prototype); + this.Message = opts.Message; } - - return messages; -} - -/** - * @api private - */ -module.exports = { - eventMessageChunker: eventMessageChunker }; - - -/***/ }), - -/***/ 634: -/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) { - -var AWS = __webpack_require__(395); - -/** - * Represents credentials from a JSON file on disk. - * If the credentials expire, the SDK can {refresh} the credentials - * from the file. - * - * The format of the file should be similar to the options passed to - * {AWS.Config}: - * - * ```javascript - * {accessKeyId: 'akid', secretAccessKey: 'secret', sessionToken: 'optional'} - * ``` - * - * @example Loading credentials from disk - * var creds = new AWS.FileSystemCredentials('./configuration.json'); - * creds.accessKeyId == 'AKID' - * - * @!attribute filename - * @readonly - * @return [String] the path to the JSON file on disk containing the - * credentials. - * @!macro nobrowser - */ -AWS.FileSystemCredentials = AWS.util.inherit(AWS.Credentials, { - - /** - * @overload AWS.FileSystemCredentials(filename) - * Creates a new FileSystemCredentials object from a filename - * - * @param filename [String] the path on disk to the JSON file to load. - */ - constructor: function FileSystemCredentials(filename) { - AWS.Credentials.call(this); - this.filename = filename; - this.get(function() {}); - }, - - /** - * Loads the credentials from the {filename} on disk. - * - * @callback callback function(err) - * Called after the JSON file on disk is read and parsed. When this callback - * is called with no error, it means that the credentials information - * has been loaded into the object (as the `accessKeyId`, `secretAccessKey`, - * and `sessionToken` properties). - * @param err [Error] if an error occurred, this value will be filled - * @see get - */ - refresh: function refresh(callback) { - if (!callback) callback = AWS.util.fn.callback; - try { - var creds = JSON.parse(AWS.util.readFileSync(this.filename)); - AWS.Credentials.call(this, creds); - if (!this.accessKeyId || !this.secretAccessKey) { - throw AWS.util.error( - new Error('Credentials not set in ' + this.filename), - { code: 'FileSystemCredentialsProviderFailure' } - ); - } - this.expired = false; - callback(); - } catch (err) { - callback(err); +let StackNotFoundException$1 = class StackNotFoundException extends CloudFormationServiceException$1 { + name = "StackNotFoundException"; + $fault = "client"; + Message; + constructor(opts) { + super({ + name: "StackNotFoundException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, StackNotFoundException.prototype); + this.Message = opts.Message; } - } - -}); - - -/***/ }), - -/***/ 636: -/***/ (function(module) { - -module.exports = {"version":2,"waiters":{"ImageScanComplete":{"description":"Wait until an image scan is complete and findings can be accessed","operation":"DescribeImageScanFindings","delay":5,"maxAttempts":60,"acceptors":[{"state":"success","matcher":"path","argument":"imageScanStatus.status","expected":"COMPLETE"},{"state":"failure","matcher":"path","argument":"imageScanStatus.status","expected":"FAILED"}]},"LifecyclePolicyPreviewComplete":{"description":"Wait until a lifecycle policy preview request is complete and results can be accessed","operation":"GetLifecyclePolicyPreview","delay":5,"maxAttempts":20,"acceptors":[{"state":"success","matcher":"path","argument":"status","expected":"COMPLETE"},{"state":"failure","matcher":"path","argument":"status","expected":"FAILED"}]}}}; - -/***/ }), - -/***/ 644: -/***/ (function(module) { - -module.exports = {"pagination":{"DescribeAccessPoints":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"DescribeFileSystems":{"input_token":"Marker","output_token":"NextMarker","limit_key":"MaxItems"},"DescribeTags":{"input_token":"Marker","output_token":"NextMarker","limit_key":"MaxItems"},"ListTagsForResource":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"}}}; - -/***/ }), - -/***/ 665: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['codebuild'] = {}; -AWS.CodeBuild = Service.defineService('codebuild', ['2016-10-06']); -Object.defineProperty(apiLoader.services['codebuild'], '2016-10-06', { - get: function get() { - var model = __webpack_require__(5915); - model.paginators = __webpack_require__(484).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.CodeBuild; - - -/***/ }), - -/***/ 677: -/***/ (function(module) { - -module.exports = {"pagination":{"ListComponentBuildVersions":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"ListComponents":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"ListDistributionConfigurations":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"ListImageBuildVersions":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"ListImagePipelineImages":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"ListImagePipelines":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"ListImageRecipes":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"ListImages":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"ListInfrastructureConfigurations":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"}}}; - -/***/ }), - -/***/ 682: -/***/ (function(module) { - -module.exports = {"pagination":{"ListAccountRoles":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults","result_key":"roleList"},"ListAccounts":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults","result_key":"accountList"}}}; - -/***/ }), - -/***/ 686: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['savingsplans'] = {}; -AWS.SavingsPlans = Service.defineService('savingsplans', ['2019-06-28']); -Object.defineProperty(apiLoader.services['savingsplans'], '2019-06-28', { - get: function get() { - var model = __webpack_require__(7752); - model.paginators = __webpack_require__(4252).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.SavingsPlans; - - -/***/ }), - -/***/ 693: -/***/ (function(module) { - -module.exports = {"pagination":{"DescribeCacheClusters":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"CacheClusters"},"DescribeCacheEngineVersions":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"CacheEngineVersions"},"DescribeCacheParameterGroups":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"CacheParameterGroups"},"DescribeCacheParameters":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"Parameters"},"DescribeCacheSecurityGroups":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"CacheSecurityGroups"},"DescribeCacheSubnetGroups":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"CacheSubnetGroups"},"DescribeEngineDefaultParameters":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"EngineDefaults.Marker","result_key":"EngineDefaults.Parameters"},"DescribeEvents":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"Events"},"DescribeGlobalReplicationGroups":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"GlobalReplicationGroups"},"DescribeReplicationGroups":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"ReplicationGroups"},"DescribeReservedCacheNodes":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"ReservedCacheNodes"},"DescribeReservedCacheNodesOfferings":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"ReservedCacheNodesOfferings"},"DescribeServiceUpdates":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"ServiceUpdates"},"DescribeSnapshots":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"Snapshots"},"DescribeUpdateActions":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"UpdateActions"}}}; - -/***/ }), - -/***/ 697: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['connect'] = {}; -AWS.Connect = Service.defineService('connect', ['2017-08-08']); -Object.defineProperty(apiLoader.services['connect'], '2017-08-08', { - get: function get() { - var model = __webpack_require__(2662); - model.paginators = __webpack_require__(1479).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.Connect; - - -/***/ }), - -/***/ 707: -/***/ (function(module) { - -module.exports = {"pagination":{"ListBuckets":{"result_key":"Buckets"},"ListMultipartUploads":{"input_token":["KeyMarker","UploadIdMarker"],"limit_key":"MaxUploads","more_results":"IsTruncated","output_token":["NextKeyMarker","NextUploadIdMarker"],"result_key":["Uploads","CommonPrefixes"]},"ListObjectVersions":{"input_token":["KeyMarker","VersionIdMarker"],"limit_key":"MaxKeys","more_results":"IsTruncated","output_token":["NextKeyMarker","NextVersionIdMarker"],"result_key":["Versions","DeleteMarkers","CommonPrefixes"]},"ListObjects":{"input_token":"Marker","limit_key":"MaxKeys","more_results":"IsTruncated","output_token":"NextMarker || Contents[-1].Key","result_key":["Contents","CommonPrefixes"]},"ListObjectsV2":{"input_token":"ContinuationToken","limit_key":"MaxKeys","output_token":"NextContinuationToken","result_key":["Contents","CommonPrefixes"]},"ListParts":{"input_token":"PartNumberMarker","limit_key":"MaxParts","more_results":"IsTruncated","output_token":"NextPartNumberMarker","result_key":"Parts"}}}; - -/***/ }), - -/***/ 721: -/***/ (function(module) { - -module.exports = {"pagination":{"GetWorkflowExecutionHistory":{"input_token":"nextPageToken","limit_key":"maximumPageSize","output_token":"nextPageToken","result_key":"events"},"ListActivityTypes":{"input_token":"nextPageToken","limit_key":"maximumPageSize","output_token":"nextPageToken","result_key":"typeInfos"},"ListClosedWorkflowExecutions":{"input_token":"nextPageToken","limit_key":"maximumPageSize","output_token":"nextPageToken","result_key":"executionInfos"},"ListDomains":{"input_token":"nextPageToken","limit_key":"maximumPageSize","output_token":"nextPageToken","result_key":"domainInfos"},"ListOpenWorkflowExecutions":{"input_token":"nextPageToken","limit_key":"maximumPageSize","output_token":"nextPageToken","result_key":"executionInfos"},"ListWorkflowTypes":{"input_token":"nextPageToken","limit_key":"maximumPageSize","output_token":"nextPageToken","result_key":"typeInfos"},"PollForDecisionTask":{"input_token":"nextPageToken","limit_key":"maximumPageSize","output_token":"nextPageToken","result_key":"events"}}}; - -/***/ }), - -/***/ 747: -/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) { - -var AWS = __webpack_require__(395); -var STS = __webpack_require__(1733); - -/** - * Represents credentials retrieved from STS Web Identity Federation support. - * - * By default this provider gets credentials using the - * {AWS.STS.assumeRoleWithWebIdentity} service operation. This operation - * requires a `RoleArn` containing the ARN of the IAM trust policy for the - * application for which credentials will be given. In addition, the - * `WebIdentityToken` must be set to the token provided by the identity - * provider. See {constructor} for an example on creating a credentials - * object with proper `RoleArn` and `WebIdentityToken` values. - * - * ## Refreshing Credentials from Identity Service - * - * In addition to AWS credentials expiring after a given amount of time, the - * login token from the identity provider will also expire. Once this token - * expires, it will not be usable to refresh AWS credentials, and another - * token will be needed. The SDK does not manage refreshing of the token value, - * but this can be done through a "refresh token" supported by most identity - * providers. Consult the documentation for the identity provider for refreshing - * tokens. Once the refreshed token is acquired, you should make sure to update - * this new token in the credentials object's {params} property. The following - * code will update the WebIdentityToken, assuming you have retrieved an updated - * token from the identity provider: - * - * ```javascript - * AWS.config.credentials.params.WebIdentityToken = updatedToken; - * ``` - * - * Future calls to `credentials.refresh()` will now use the new token. - * - * @!attribute params - * @return [map] the map of params passed to - * {AWS.STS.assumeRoleWithWebIdentity}. To update the token, set the - * `params.WebIdentityToken` property. - * @!attribute data - * @return [map] the raw data response from the call to - * {AWS.STS.assumeRoleWithWebIdentity}. Use this if you want to get - * access to other properties from the response. - */ -AWS.WebIdentityCredentials = AWS.util.inherit(AWS.Credentials, { - /** - * Creates a new credentials object. - * @param (see AWS.STS.assumeRoleWithWebIdentity) - * @example Creating a new credentials object - * AWS.config.credentials = new AWS.WebIdentityCredentials({ - * RoleArn: 'arn:aws:iam::1234567890:role/WebIdentity', - * WebIdentityToken: 'ABCDEFGHIJKLMNOP', // token from identity service - * RoleSessionName: 'web' // optional name, defaults to web-identity - * }, { - * // optionally provide configuration to apply to the underlying AWS.STS service client - * // if configuration is not provided, then configuration will be pulled from AWS.config - * - * // specify timeout options - * httpOptions: { - * timeout: 100 - * } - * }); - * @see AWS.STS.assumeRoleWithWebIdentity - * @see AWS.Config - */ - constructor: function WebIdentityCredentials(params, clientConfig) { - AWS.Credentials.call(this); - this.expired = true; - this.params = params; - this.params.RoleSessionName = this.params.RoleSessionName || 'web-identity'; - this.data = null; - this._clientConfig = AWS.util.copy(clientConfig || {}); - }, - - /** - * Refreshes credentials using {AWS.STS.assumeRoleWithWebIdentity} - * - * @callback callback function(err) - * Called when the STS service responds (or fails). When - * this callback is called with no error, it means that the credentials - * information has been loaded into the object (as the `accessKeyId`, - * `secretAccessKey`, and `sessionToken` properties). - * @param err [Error] if an error occurred, this value will be filled - * @see get - */ - refresh: function refresh(callback) { - this.coalesceRefresh(callback || AWS.util.fn.callback); - }, - - /** - * @api private - */ - load: function load(callback) { - var self = this; - self.createClients(); - self.service.assumeRoleWithWebIdentity(function (err, data) { - self.data = null; - if (!err) { - self.data = data; - self.service.credentialsFrom(data, self); - } - callback(err); - }); - }, - - /** - * @api private - */ - createClients: function() { - if (!this.service) { - var stsConfig = AWS.util.merge({}, this._clientConfig); - stsConfig.params = this.params; - this.service = new STS(stsConfig); +}; +let ResourceScanInProgressException$1 = class ResourceScanInProgressException extends CloudFormationServiceException$1 { + name = "ResourceScanInProgressException"; + $fault = "client"; + Message; + constructor(opts) { + super({ + name: "ResourceScanInProgressException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, ResourceScanInProgressException.prototype); + this.Message = opts.Message; } - } - -}); - - -/***/ }), - -/***/ 758: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['mobile'] = {}; -AWS.Mobile = Service.defineService('mobile', ['2017-07-01']); -Object.defineProperty(apiLoader.services['mobile'], '2017-07-01', { - get: function get() { - var model = __webpack_require__(505); - model.paginators = __webpack_require__(3410).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.Mobile; - - -/***/ }), - -/***/ 761: -/***/ (function(module) { - -module.exports = {"version":2,"waiters":{"DBInstanceAvailable":{"delay":30,"operation":"DescribeDBInstances","maxAttempts":60,"acceptors":[{"expected":"available","matcher":"pathAll","state":"success","argument":"DBInstances[].DBInstanceStatus"},{"expected":"deleted","matcher":"pathAny","state":"failure","argument":"DBInstances[].DBInstanceStatus"},{"expected":"deleting","matcher":"pathAny","state":"failure","argument":"DBInstances[].DBInstanceStatus"},{"expected":"failed","matcher":"pathAny","state":"failure","argument":"DBInstances[].DBInstanceStatus"},{"expected":"incompatible-restore","matcher":"pathAny","state":"failure","argument":"DBInstances[].DBInstanceStatus"},{"expected":"incompatible-parameters","matcher":"pathAny","state":"failure","argument":"DBInstances[].DBInstanceStatus"}]},"DBInstanceDeleted":{"delay":30,"operation":"DescribeDBInstances","maxAttempts":60,"acceptors":[{"expected":"deleted","matcher":"pathAll","state":"success","argument":"DBInstances[].DBInstanceStatus"},{"expected":"DBInstanceNotFound","matcher":"error","state":"success"},{"expected":"creating","matcher":"pathAny","state":"failure","argument":"DBInstances[].DBInstanceStatus"},{"expected":"modifying","matcher":"pathAny","state":"failure","argument":"DBInstances[].DBInstanceStatus"},{"expected":"rebooting","matcher":"pathAny","state":"failure","argument":"DBInstances[].DBInstanceStatus"},{"expected":"resetting-master-credentials","matcher":"pathAny","state":"failure","argument":"DBInstances[].DBInstanceStatus"}]}}}; - -/***/ }), - -/***/ 768: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['cloudtrail'] = {}; -AWS.CloudTrail = Service.defineService('cloudtrail', ['2013-11-01']); -Object.defineProperty(apiLoader.services['cloudtrail'], '2013-11-01', { - get: function get() { - var model = __webpack_require__(1459); - model.paginators = __webpack_require__(7744).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.CloudTrail; - - -/***/ }), - -/***/ 807: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2018-01-04","endpointPrefix":"ram","jsonVersion":"1.1","protocol":"rest-json","serviceAbbreviation":"RAM","serviceFullName":"AWS Resource Access Manager","serviceId":"RAM","signatureVersion":"v4","uid":"ram-2018-01-04"},"operations":{"AcceptResourceShareInvitation":{"http":{"requestUri":"/acceptresourceshareinvitation"},"input":{"type":"structure","required":["resourceShareInvitationArn"],"members":{"resourceShareInvitationArn":{},"clientToken":{}}},"output":{"type":"structure","members":{"resourceShareInvitation":{"shape":"S4"},"clientToken":{}}}},"AssociateResourceShare":{"http":{"requestUri":"/associateresourceshare"},"input":{"type":"structure","required":["resourceShareArn"],"members":{"resourceShareArn":{},"resourceArns":{"shape":"Sd"},"principals":{"shape":"Se"},"clientToken":{}}},"output":{"type":"structure","members":{"resourceShareAssociations":{"shape":"S7"},"clientToken":{}}}},"AssociateResourceSharePermission":{"http":{"requestUri":"/associateresourcesharepermission"},"input":{"type":"structure","required":["resourceShareArn","permissionArn"],"members":{"resourceShareArn":{},"permissionArn":{},"replace":{"type":"boolean"},"clientToken":{}}},"output":{"type":"structure","members":{"returnValue":{"type":"boolean"},"clientToken":{}}}},"CreateResourceShare":{"http":{"requestUri":"/createresourceshare"},"input":{"type":"structure","required":["name"],"members":{"name":{},"resourceArns":{"shape":"Sd"},"principals":{"shape":"Se"},"tags":{"shape":"Sj"},"allowExternalPrincipals":{"type":"boolean"},"clientToken":{},"permissionArns":{"type":"list","member":{}}}},"output":{"type":"structure","members":{"resourceShare":{"shape":"Sp"},"clientToken":{}}}},"DeleteResourceShare":{"http":{"method":"DELETE","requestUri":"/deleteresourceshare"},"input":{"type":"structure","required":["resourceShareArn"],"members":{"resourceShareArn":{"location":"querystring","locationName":"resourceShareArn"},"clientToken":{"location":"querystring","locationName":"clientToken"}}},"output":{"type":"structure","members":{"returnValue":{"type":"boolean"},"clientToken":{}}}},"DisassociateResourceShare":{"http":{"requestUri":"/disassociateresourceshare"},"input":{"type":"structure","required":["resourceShareArn"],"members":{"resourceShareArn":{},"resourceArns":{"shape":"Sd"},"principals":{"shape":"Se"},"clientToken":{}}},"output":{"type":"structure","members":{"resourceShareAssociations":{"shape":"S7"},"clientToken":{}}}},"DisassociateResourceSharePermission":{"http":{"requestUri":"/disassociateresourcesharepermission"},"input":{"type":"structure","required":["resourceShareArn","permissionArn"],"members":{"resourceShareArn":{},"permissionArn":{},"clientToken":{}}},"output":{"type":"structure","members":{"returnValue":{"type":"boolean"},"clientToken":{}}}},"EnableSharingWithAwsOrganization":{"http":{"requestUri":"/enablesharingwithawsorganization"},"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"returnValue":{"type":"boolean"}}}},"GetPermission":{"http":{"requestUri":"/getpermission"},"input":{"type":"structure","required":["permissionArn"],"members":{"permissionArn":{},"permissionVersion":{"type":"integer"}}},"output":{"type":"structure","members":{"permission":{"type":"structure","members":{"arn":{},"version":{},"defaultVersion":{"type":"boolean"},"name":{},"resourceType":{},"permission":{},"creationTime":{"type":"timestamp"},"lastUpdatedTime":{"type":"timestamp"}}}}}},"GetResourcePolicies":{"http":{"requestUri":"/getresourcepolicies"},"input":{"type":"structure","required":["resourceArns"],"members":{"resourceArns":{"shape":"Sd"},"principal":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"policies":{"type":"list","member":{}},"nextToken":{}}}},"GetResourceShareAssociations":{"http":{"requestUri":"/getresourceshareassociations"},"input":{"type":"structure","required":["associationType"],"members":{"associationType":{},"resourceShareArns":{"shape":"S1a"},"resourceArn":{},"principal":{},"associationStatus":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"resourceShareAssociations":{"shape":"S7"},"nextToken":{}}}},"GetResourceShareInvitations":{"http":{"requestUri":"/getresourceshareinvitations"},"input":{"type":"structure","members":{"resourceShareInvitationArns":{"type":"list","member":{}},"resourceShareArns":{"shape":"S1a"},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"resourceShareInvitations":{"type":"list","member":{"shape":"S4"}},"nextToken":{}}}},"GetResourceShares":{"http":{"requestUri":"/getresourceshares"},"input":{"type":"structure","required":["resourceOwner"],"members":{"resourceShareArns":{"shape":"S1a"},"resourceShareStatus":{},"resourceOwner":{},"name":{},"tagFilters":{"type":"list","member":{"type":"structure","members":{"tagKey":{},"tagValues":{"type":"list","member":{}}}}},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"resourceShares":{"type":"list","member":{"shape":"Sp"}},"nextToken":{}}}},"ListPendingInvitationResources":{"http":{"requestUri":"/listpendinginvitationresources"},"input":{"type":"structure","required":["resourceShareInvitationArn"],"members":{"resourceShareInvitationArn":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"resources":{"shape":"S1p"},"nextToken":{}}}},"ListPermissions":{"http":{"requestUri":"/listpermissions"},"input":{"type":"structure","members":{"resourceType":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"permissions":{"shape":"S1u"},"nextToken":{}}}},"ListPrincipals":{"http":{"requestUri":"/listprincipals"},"input":{"type":"structure","required":["resourceOwner"],"members":{"resourceOwner":{},"resourceArn":{},"principals":{"shape":"Se"},"resourceType":{},"resourceShareArns":{"shape":"S1a"},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"principals":{"type":"list","member":{"type":"structure","members":{"id":{},"resourceShareArn":{},"creationTime":{"type":"timestamp"},"lastUpdatedTime":{"type":"timestamp"},"external":{"type":"boolean"}}}},"nextToken":{}}}},"ListResourceSharePermissions":{"http":{"requestUri":"/listresourcesharepermissions"},"input":{"type":"structure","required":["resourceShareArn"],"members":{"resourceShareArn":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"permissions":{"shape":"S1u"},"nextToken":{}}}},"ListResourceTypes":{"http":{"requestUri":"/listresourcetypes"},"input":{"type":"structure","members":{"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"resourceTypes":{"type":"list","member":{"type":"structure","members":{"resourceType":{},"serviceName":{}}}},"nextToken":{}}}},"ListResources":{"http":{"requestUri":"/listresources"},"input":{"type":"structure","required":["resourceOwner"],"members":{"resourceOwner":{},"principal":{},"resourceType":{},"resourceArns":{"shape":"Sd"},"resourceShareArns":{"shape":"S1a"},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"resources":{"shape":"S1p"},"nextToken":{}}}},"PromoteResourceShareCreatedFromPolicy":{"http":{"requestUri":"/promoteresourcesharecreatedfrompolicy"},"input":{"type":"structure","required":["resourceShareArn"],"members":{"resourceShareArn":{"location":"querystring","locationName":"resourceShareArn"}}},"output":{"type":"structure","members":{"returnValue":{"type":"boolean"}}}},"RejectResourceShareInvitation":{"http":{"requestUri":"/rejectresourceshareinvitation"},"input":{"type":"structure","required":["resourceShareInvitationArn"],"members":{"resourceShareInvitationArn":{},"clientToken":{}}},"output":{"type":"structure","members":{"resourceShareInvitation":{"shape":"S4"},"clientToken":{}}}},"TagResource":{"http":{"requestUri":"/tagresource"},"input":{"type":"structure","required":["resourceShareArn","tags"],"members":{"resourceShareArn":{},"tags":{"shape":"Sj"}}},"output":{"type":"structure","members":{}}},"UntagResource":{"http":{"requestUri":"/untagresource"},"input":{"type":"structure","required":["resourceShareArn","tagKeys"],"members":{"resourceShareArn":{},"tagKeys":{"type":"list","member":{}}}},"output":{"type":"structure","members":{}}},"UpdateResourceShare":{"http":{"requestUri":"/updateresourceshare"},"input":{"type":"structure","required":["resourceShareArn"],"members":{"resourceShareArn":{},"name":{},"allowExternalPrincipals":{"type":"boolean"},"clientToken":{}}},"output":{"type":"structure","members":{"resourceShare":{"shape":"Sp"},"clientToken":{}}}}},"shapes":{"S4":{"type":"structure","members":{"resourceShareInvitationArn":{},"resourceShareName":{},"resourceShareArn":{},"senderAccountId":{},"receiverAccountId":{},"invitationTimestamp":{"type":"timestamp"},"status":{},"resourceShareAssociations":{"shape":"S7","deprecated":true,"deprecatedMessage":"This member has been deprecated. Use ListPendingInvitationResources."}}},"S7":{"type":"list","member":{"type":"structure","members":{"resourceShareArn":{},"resourceShareName":{},"associatedEntity":{},"associationType":{},"status":{},"statusMessage":{},"creationTime":{"type":"timestamp"},"lastUpdatedTime":{"type":"timestamp"},"external":{"type":"boolean"}}}},"Sd":{"type":"list","member":{}},"Se":{"type":"list","member":{}},"Sj":{"type":"list","member":{"type":"structure","members":{"key":{},"value":{}}}},"Sp":{"type":"structure","members":{"resourceShareArn":{},"name":{},"owningAccountId":{},"allowExternalPrincipals":{"type":"boolean"},"status":{},"statusMessage":{},"tags":{"shape":"Sj"},"creationTime":{"type":"timestamp"},"lastUpdatedTime":{"type":"timestamp"},"featureSet":{}}},"S1a":{"type":"list","member":{}},"S1p":{"type":"list","member":{"type":"structure","members":{"arn":{},"type":{},"resourceShareArn":{},"resourceGroupArn":{},"status":{},"statusMessage":{},"creationTime":{"type":"timestamp"},"lastUpdatedTime":{"type":"timestamp"}}}},"S1u":{"type":"list","member":{"type":"structure","members":{"arn":{},"version":{},"defaultVersion":{"type":"boolean"},"name":{},"resourceType":{},"status":{},"creationTime":{"type":"timestamp"},"lastUpdatedTime":{"type":"timestamp"}}}}}}; - -/***/ }), - -/***/ 833: -/***/ (function(module) { - -module.exports = {"pagination":{"DescribeDomains":{"result_key":"DomainStatusList"},"DescribeIndexFields":{"result_key":"IndexFields"},"DescribeRankExpressions":{"result_key":"RankExpressions"}}}; - -/***/ }), - -/***/ 837: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['sesv2'] = {}; -AWS.SESV2 = Service.defineService('sesv2', ['2019-09-27']); -Object.defineProperty(apiLoader.services['sesv2'], '2019-09-27', { - get: function get() { - var model = __webpack_require__(5338); - model.paginators = __webpack_require__(2189).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.SESV2; - - -/***/ }), - -/***/ 842: -/***/ (function(module, __unusedexports, __webpack_require__) { - -"use strict"; - - -var Type = __webpack_require__(4945); - -var _hasOwnProperty = Object.prototype.hasOwnProperty; -var _toString = Object.prototype.toString; - -function resolveYamlOmap(data) { - if (data === null) return true; - - var objectKeys = [], index, length, pair, pairKey, pairHasKey, - object = data; - - for (index = 0, length = object.length; index < length; index += 1) { - pair = object[index]; - pairHasKey = false; - - if (_toString.call(pair) !== '[object Object]') return false; - - for (pairKey in pair) { - if (_hasOwnProperty.call(pair, pairKey)) { - if (!pairHasKey) pairHasKey = true; - else return false; - } +}; +let InvalidStateTransitionException$1 = class InvalidStateTransitionException extends CloudFormationServiceException$1 { + name = "InvalidStateTransitionException"; + $fault = "client"; + Message; + constructor(opts) { + super({ + name: "InvalidStateTransitionException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, InvalidStateTransitionException.prototype); + this.Message = opts.Message; } +}; +let OperationStatusCheckFailedException$1 = class OperationStatusCheckFailedException extends CloudFormationServiceException$1 { + name = "OperationStatusCheckFailedException"; + $fault = "client"; + Message; + constructor(opts) { + super({ + name: "OperationStatusCheckFailedException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, OperationStatusCheckFailedException.prototype); + this.Message = opts.Message; + } +}; +let ResourceScanLimitExceededException$1 = class ResourceScanLimitExceededException extends CloudFormationServiceException$1 { + name = "ResourceScanLimitExceededException"; + $fault = "client"; + Message; + constructor(opts) { + super({ + name: "ResourceScanLimitExceededException", + $fault: "client", + ...opts, + }); + Object.setPrototypeOf(this, ResourceScanLimitExceededException.prototype); + this.Message = opts.Message; + } +}; - if (!pairHasKey) return false; +const _A = "Arn"; +const _AC = "AfterContext"; +const _ACT = "AttributeChangeType"; +const _AD = "AutoDeployment"; +const _AEE = "AlreadyExistsException"; +const _AFT = "AccountFilterType"; +const _AGR = "AccountGateResult"; +const _AL = "AccountLimit"; +const _ALL = "AccountLimitList"; +const _ALc = "AccountLimits"; +const _ALn = "AnnotationList"; +const _AN = "AnnotationName"; +const _AOA = "ActivateOrganizationsAccess"; +const _AOAI = "ActivateOrganizationsAccessInput"; +const _AOAO = "ActivateOrganizationsAccessOutput"; +const _AP = "ActualProperties"; +const _AR = "AddResources"; +const _ARARN = "AdministrationRoleARN"; +const _AT = "ActivateType"; +const _ATAC = "AcceptTermsAndConditions"; +const _ATI = "ActivateTypeInput"; +const _ATO = "ActivateTypeOutput"; +const _AU = "AutoUpdate"; +const _AUc = "AccountsUrl"; +const _AV = "ActualValue"; +const _AVF = "AfterValueFrom"; +const _AVf = "AfterValue"; +const _AVl = "AllowedValues"; +const _Ac = "Accounts"; +const _Acc = "Account"; +const _Act = "Action"; +const _Acti = "Active"; +const _Al = "Alias"; +const _An = "Annotation"; +const _Ann = "Annotations"; +const _At = "Attribute"; +const _BC = "BeforeContext"; +const _BDTC = "BatchDescribeTypeConfigurations"; +const _BDTCE = "BatchDescribeTypeConfigurationsError"; +const _BDTCEa = "BatchDescribeTypeConfigurationsErrors"; +const _BDTCI = "BatchDescribeTypeConfigurationsInput"; +const _BDTCO = "BatchDescribeTypeConfigurationsOutput"; +const _BT = "BearerToken"; +const _BV = "BeforeValue"; +const _BVF = "BeforeValueFrom"; +const _C = "Change"; +const _CA = "CallAs"; +const _CAo = "ConnectionArn"; +const _CAon = "ConfigurationAlias"; +const _CAonf = "ConfigurationArn"; +const _CBME = "CreatedButModifiedException"; +const _CCS = "CreateChangeSet"; +const _CCSI = "CreateChangeSetInput"; +const _CCSO = "CreateChangeSetOutput"; +const _CE = "CausingEntity"; +const _CFNRE = "CFNRegistryException"; +const _CGT = "CreateGeneratedTemplate"; +const _CGTI = "CreateGeneratedTemplateInput"; +const _CGTO = "CreateGeneratedTemplateOutput"; +const _CM = "ConcurrencyMode"; +const _COS = "CurrentOperationStatus"; +const _CR = "CapabilitiesReason"; +const _CRLEE = "ConcurrentResourcesLimitExceededException"; +const _CRT = "ClientRequestToken"; +const _CS = "ConfigurationSchema"; +const _CSH = "ChangeSetHook"; +const _CSHRTD = "ChangeSetHookResourceTargetDetails"; +const _CSHTD = "ChangeSetHookTargetDetails"; +const _CSHh = "ChangeSetHooks"; +const _CSI = "ChangeSetId"; +const _CSII = "CreateStackInstancesInput"; +const _CSIO = "CreateStackInstancesOutput"; +const _CSIr = "CreateStackInput"; +const _CSIre = "CreateStackInstances"; +const _CSN = "ChangeSetName"; +const _CSNFE = "ChangeSetNotFoundException"; +const _CSO = "CreateStackOutput"; +const _CSR = "CreateStackRefactor"; +const _CSRI = "CreateStackRefactorInput"; +const _CSRO = "CreateStackRefactorOutput"; +const _CSS = "ChangeSetSummary"; +const _CSSI = "CreateStackSetInput"; +const _CSSO = "CreateStackSetOutput"; +const _CSSh = "ChangeSetSummaries"; +const _CSSr = "CreateStackSet"; +const _CST = "ChangeSetType"; +const _CSh = "ChangeSource"; +const _CSr = "CreateStack"; +const _CT = "CreationTime"; +const _CTl = "ClientToken"; +const _CTr = "CreationTimestamp"; +const _CUR = "ContinueUpdateRollback"; +const _CURI = "ContinueUpdateRollbackInput"; +const _CURO = "ContinueUpdateRollbackOutput"; +const _CUS = "CancelUpdateStack"; +const _CUSI = "CancelUpdateStackInput"; +const _Ca = "Capabilities"; +const _Cat = "Category"; +const _Ch = "Changes"; +const _Co = "Configuration"; +const _D = "Description"; +const _DAL = "DescribeAccountLimits"; +const _DALI = "DescribeAccountLimitsInput"; +const _DALO = "DescribeAccountLimitsOutput"; +const _DCS = "DeleteChangeSet"; +const _DCSH = "DescribeChangeSetHooks"; +const _DCSHI = "DescribeChangeSetHooksInput"; +const _DCSHO = "DescribeChangeSetHooksOutput"; +const _DCSI = "DeleteChangeSetInput"; +const _DCSIe = "DescribeChangeSetInput"; +const _DCSO = "DeleteChangeSetOutput"; +const _DCSOe = "DescribeChangeSetOutput"; +const _DCSe = "DescribeChangeSet"; +const _DDS = "DriftDetectionStatus"; +const _DDT = "DriftDetectionTimestamp"; +const _DE = "DescribeEvents"; +const _DEI = "DescribeEventsInput"; +const _DEO = "DescribeEventsOutput"; +const _DGT = "DeleteGeneratedTemplate"; +const _DGTI = "DeleteGeneratedTemplateInput"; +const _DGTIe = "DescribeGeneratedTemplateInput"; +const _DGTO = "DescribeGeneratedTemplateOutput"; +const _DGTe = "DescribeGeneratedTemplate"; +const _DI = "DriftInformation"; +const _DM = "DeploymentMode"; +const _DMe = "DeletionMode"; +const _DOA = "DeactivateOrganizationsAccess"; +const _DOAI = "DeactivateOrganizationsAccessInput"; +const _DOAIe = "DescribeOrganizationsAccessInput"; +const _DOAO = "DeactivateOrganizationsAccessOutput"; +const _DOAOe = "DescribeOrganizationsAccessOutput"; +const _DOAe = "DescribeOrganizationsAccess"; +const _DP = "DeletionPolicy"; +const _DPI = "DescribePublisherInput"; +const _DPO = "DescribePublisherOutput"; +const _DPe = "DescribePublisher"; +const _DR = "DisableRollback"; +const _DRS = "DescribeResourceScan"; +const _DRSI = "DescribeResourceScanInput"; +const _DRSO = "DescribeResourceScanOutput"; +const _DRe = "DetectionReason"; +const _DS = "DetectionStatus"; +const _DSD = "DetectStackDrift"; +const _DSDDS = "DescribeStackDriftDetectionStatus"; +const _DSDDSI = "DescribeStackDriftDetectionStatusInput"; +const _DSDDSO = "DescribeStackDriftDetectionStatusOutput"; +const _DSDI = "DetectStackDriftInput"; +const _DSDO = "DetectStackDriftOutput"; +const _DSE = "DescribeStackEvents"; +const _DSEI = "DescribeStackEventsInput"; +const _DSEO = "DescribeStackEventsOutput"; +const _DSI = "DeleteStackInput"; +const _DSIC = "DriftedStackInstancesCount"; +const _DSII = "DeleteStackInstancesInput"; +const _DSIIe = "DescribeStackInstanceInput"; +const _DSIO = "DeleteStackInstancesOutput"; +const _DSIOe = "DescribeStackInstanceOutput"; +const _DSIe = "DescribeStacksInput"; +const _DSIel = "DeleteStackInstances"; +const _DSIes = "DescribeStackInstance"; +const _DSO = "DescribeStacksOutput"; +const _DSR = "DetectionStatusReason"; +const _DSRC = "DriftedStackResourceCount"; +const _DSRD = "DescribeStackResourceDrifts"; +const _DSRDI = "DescribeStackResourceDriftsInput"; +const _DSRDIe = "DetectStackResourceDriftInput"; +const _DSRDO = "DescribeStackResourceDriftsOutput"; +const _DSRDOe = "DetectStackResourceDriftOutput"; +const _DSRDe = "DetectStackResourceDrift"; +const _DSRI = "DescribeStackRefactorInput"; +const _DSRIe = "DescribeStackResourceInput"; +const _DSRIes = "DescribeStackResourcesInput"; +const _DSRO = "DescribeStackRefactorOutput"; +const _DSROe = "DescribeStackResourceOutput"; +const _DSROes = "DescribeStackResourcesOutput"; +const _DSRe = "DescribeStackRefactor"; +const _DSRes = "DescribeStackResource"; +const _DSResc = "DescribeStackResources"; +const _DSRr = "DriftStatusReason"; +const _DSS = "DeleteStackSet"; +const _DSSD = "DetectStackSetDrift"; +const _DSSDI = "DetectStackSetDriftInput"; +const _DSSDO = "DetectStackSetDriftOutput"; +const _DSSI = "DeleteStackSetInput"; +const _DSSIe = "DescribeStackSetInput"; +const _DSSO = "DeleteStackSetOutput"; +const _DSSOI = "DescribeStackSetOperationInput"; +const _DSSOO = "DescribeStackSetOperationOutput"; +const _DSSOe = "DescribeStackSetOutput"; +const _DSSOes = "DescribeStackSetOperation"; +const _DSSe = "DescribeStackSet"; +const _DSe = "DeprecatedStatus"; +const _DSel = "DeleteStack"; +const _DSes = "DescribeStacks"; +const _DSet = "DetailedStatus"; +const _DSr = "DriftStatus"; +const _DT = "DeploymentTargets"; +const _DTI = "DeactivateTypeInput"; +const _DTIe = "DeregisterTypeInput"; +const _DTIes = "DescribeTypeInput"; +const _DTO = "DeactivateTypeOutput"; +const _DTOe = "DeregisterTypeOutput"; +const _DTOes = "DescribeTypeOutput"; +const _DTR = "DescribeTypeRegistration"; +const _DTRI = "DescribeTypeRegistrationInput"; +const _DTRO = "DescribeTypeRegistrationOutput"; +const _DTe = "DeclaredTransforms"; +const _DTea = "DeactivateType"; +const _DTel = "DeletionTime"; +const _DTer = "DeregisterType"; +const _DTes = "DescribeType"; +const _DTi = "DifferenceType"; +const _DU = "DocumentationUrl"; +const _DV = "DefaultValue"; +const _DVI = "DefaultVersionId"; +const _De = "Details"; +const _Des = "Destination"; +const _Det = "Detection"; +const _Dr = "Drift"; +const _E = "Enabled"; +const _EC = "ErrorCode"; +const _ECS = "ExecuteChangeSet"; +const _ECSI = "ExecuteChangeSetInput"; +const _ECSO = "ExecuteChangeSetOutput"; +const _EF = "EventFilter"; +const _EI = "EventId"; +const _EM = "ErrorMessage"; +const _EN = "ExportName"; +const _EP = "ExpectedProperties"; +const _ERA = "ExecutionRoleArn"; +const _ERN = "ExecutionRoleName"; +const _ES = "ExecutionStatus"; +const _ESC = "EnableStackCreation"; +const _ESF = "ExecutionStatusFilter"; +const _ESI = "ExportingStackId"; +const _ESR = "ExecutionStatusReason"; +const _ESRI = "ExecuteStackRefactorInput"; +const _ESRx = "ExecuteStackRefactor"; +const _ET = "EndTime"; +const _ETC = "EstimateTemplateCost"; +const _ETCI = "EstimateTemplateCostInput"; +const _ETCO = "EstimateTemplateCostOutput"; +const _ETP = "EnableTerminationProtection"; +const _ETn = "EndTimestamp"; +const _ETv = "EventType"; +const _EV = "ExpectedValue"; +const _En = "Entity"; +const _Er = "Errors"; +const _Ev = "Evaluation"; +const _Ex = "Export"; +const _Exp = "Exports"; +const _F = "Filters"; +const _FE = "FailedEvents"; +const _FM = "FailureMode"; +const _FSIC = "FailedStackInstancesCount"; +const _FTC = "FailureToleranceCount"; +const _FTP = "FailureTolerancePercentage"; +const _Fo = "Format"; +const _GGT = "GetGeneratedTemplate"; +const _GGTI = "GetGeneratedTemplateInput"; +const _GGTO = "GetGeneratedTemplateOutput"; +const _GHR = "GetHookResult"; +const _GHRI = "GetHookResultInput"; +const _GHRO = "GetHookResultOutput"; +const _GSP = "GetStackPolicy"; +const _GSPI = "GetStackPolicyInput"; +const _GSPO = "GetStackPolicyOutput"; +const _GT = "GetTemplate"; +const _GTI = "GeneratedTemplateId"; +const _GTIe = "GetTemplateInput"; +const _GTN = "GeneratedTemplateName"; +const _GTNFE = "GeneratedTemplateNotFoundException"; +const _GTO = "GetTemplateOutput"; +const _GTS = "GetTemplateSummary"; +const _GTSI = "GetTemplateSummaryInput"; +const _GTSO = "GetTemplateSummaryOutput"; +const _H = "Hooks"; +const _HET = "HookExecutionTarget"; +const _HFM = "HookFailureMode"; +const _HIC = "HookInvocationCount"; +const _HII = "HookInvocationId"; +const _HIP = "HookInvocationPoint"; +const _HR = "HookResults"; +const _HRI = "HookResultId"; +const _HRNFE = "HookResultNotFoundException"; +const _HRS = "HookResultSummary"; +const _HRSo = "HookResultSummaries"; +const _HS = "HookStatus"; +const _HSR = "HookStatusReason"; +const _HT = "HookTarget"; +const _HTo = "HookType"; +const _I = "Id"; +const _IA = "IsActivated"; +const _IAn = "InvokedAt"; +const _ICE = "InsufficientCapabilitiesException"; +const _ICSSE = "InvalidChangeSetStatusException"; +const _IDC = "IsDefaultConfiguration"; +const _IDV = "IsDefaultVersion"; +const _IER = "ImportExistingResources"; +const _INS = "IncludeNestedStacks"; +const _IOE = "InvalidOperationException"; +const _IP = "InvocationPoint"; +const _IPSIC = "InProgressStackInstancesCount"; +const _IPV = "IncludePropertyValues"; +const _IPd = "IdentityProvider"; +const _ISSIC = "InSyncStackInstancesCount"; +const _ISTE = "InvalidStateTransitionException"; +const _ISTSS = "ImportStacksToStackSet"; +const _ISTSSI = "ImportStacksToStackSetInput"; +const _ISTSSO = "ImportStacksToStackSetOutput"; +const _Im = "Imports"; +const _K = "Key"; +const _LC = "LoggingConfig"; +const _LCS = "ListChangeSets"; +const _LCSI = "ListChangeSetsInput"; +const _LCSO = "ListChangeSetsOutput"; +const _LCT = "LastCheckTimestamp"; +const _LDB = "LogDeliveryBucket"; +const _LDCT = "LastDriftCheckTimestamp"; +const _LE = "ListExports"; +const _LEE = "LimitExceededException"; +const _LEI = "ListExportsInput"; +const _LEO = "ListExportsOutput"; +const _LGN = "LogGroupName"; +const _LGT = "ListGeneratedTemplates"; +const _LGTI = "ListGeneratedTemplatesInput"; +const _LGTO = "ListGeneratedTemplatesOutput"; +const _LHR = "ListHookResults"; +const _LHRI = "ListHookResultsInput"; +const _LHRO = "ListHookResultsOutput"; +const _LI = "ListImports"; +const _LIH = "LogicalIdHierarchy"; +const _LII = "ListImportsInput"; +const _LIO = "ListImportsOutput"; +const _LO = "LastOperations"; +const _LOI = "LastOperationId"; +const _LPV = "LatestPublicVersion"; +const _LRA = "LogRoleArn"; +const _LRD = "LiveResourceDrift"; +const _LRI = "LogicalResourceId"; +const _LRIo = "LogicalResourceIds"; +const _LRS = "ListResourceScans"; +const _LRSI = "ListResourceScansInput"; +const _LRSO = "ListResourceScansOutput"; +const _LRSR = "ListResourceScanResources"; +const _LRSRI = "ListResourceScanResourcesInput"; +const _LRSRO = "ListResourceScanResourcesOutput"; +const _LRSRR = "ListResourceScanRelatedResources"; +const _LRSRRI = "ListResourceScanRelatedResourcesInput"; +const _LRSRRO = "ListResourceScanRelatedResourcesOutput"; +const _LS = "ListStacks"; +const _LSI = "ListStacksInput"; +const _LSII = "ListStackInstancesInput"; +const _LSIO = "ListStackInstancesOutput"; +const _LSIRD = "ListStackInstanceResourceDrifts"; +const _LSIRDI = "ListStackInstanceResourceDriftsInput"; +const _LSIRDO = "ListStackInstanceResourceDriftsOutput"; +const _LSIi = "ListStackInstances"; +const _LSO = "ListStacksOutput"; +const _LSR = "ListStackRefactors"; +const _LSRA = "ListStackRefactorActions"; +const _LSRAI = "ListStackRefactorActionsInput"; +const _LSRAO = "ListStackRefactorActionsOutput"; +const _LSRI = "ListStackRefactorsInput"; +const _LSRIi = "ListStackResourcesInput"; +const _LSRO = "ListStackRefactorsOutput"; +const _LSROi = "ListStackResourcesOutput"; +const _LSRi = "ListStackResources"; +const _LSS = "ListStackSets"; +const _LSSADT = "ListStackSetAutoDeploymentTargets"; +const _LSSADTI = "ListStackSetAutoDeploymentTargetsInput"; +const _LSSADTO = "ListStackSetAutoDeploymentTargetsOutput"; +const _LSSI = "ListStackSetsInput"; +const _LSSO = "ListStackSetsOutput"; +const _LSSOI = "ListStackSetOperationsInput"; +const _LSSOO = "ListStackSetOperationsOutput"; +const _LSSOR = "ListStackSetOperationResults"; +const _LSSORI = "ListStackSetOperationResultsInput"; +const _LSSORO = "ListStackSetOperationResultsOutput"; +const _LSSOi = "ListStackSetOperations"; +const _LT = "ListTypes"; +const _LTI = "ListTypesInput"; +const _LTO = "ListTypesOutput"; +const _LTR = "ListTypeRegistrations"; +const _LTRI = "ListTypeRegistrationsInput"; +const _LTRO = "ListTypeRegistrationsOutput"; +const _LTV = "ListTypeVersions"; +const _LTVI = "ListTypeVersionsInput"; +const _LTVO = "ListTypeVersionsOutput"; +const _LU = "LastUpdated"; +const _LUT = "LastUpdatedTime"; +const _LUTa = "LastUpdatedTimestamp"; +const _M = "Message"; +const _MBS = "ManagedByStack"; +const _MCC = "MaxConcurrentCount"; +const _MCP = "MaxConcurrentPercentage"; +const _ME = "ManagedExecution"; +const _MI = "ModuleInfo"; +const _MR = "MaxResults"; +const _MTIM = "MonitoringTimeInMinutes"; +const _MV = "MajorVersion"; +const _Me = "Metadata"; +const _N = "Name"; +const _NAEE = "NameAlreadyExistsException"; +const _NARN = "NotificationARNs"; +const _NE = "NoEcho"; +const _NGTN = "NewGeneratedTemplateName"; +const _NOR = "NumberOfResources"; +const _NT = "NextToken"; +const _O = "Output"; +const _OE = "OperationEvents"; +const _OEp = "OperationEntry"; +const _OEpe = "OperationEvent"; +const _OF = "OnFailure"; +const _OI = "OperationId"; +const _OIAEE = "OperationIdAlreadyExistsException"; +const _OIPE = "OperationInProgressException"; +const _OK = "OutputKey"; +const _ONFE = "OperationNotFoundException"; +const _OP = "OperationPreferences"; +const _ORF = "OperationResultFilter"; +const _ORFp = "OperationResultFilters"; +const _OS = "OperationStatus"; +const _OSCFE = "OperationStatusCheckFailedException"; +const _OSF = "OnStackFailure"; +const _OT = "OperationType"; +const _OTA = "OriginalTypeArn"; +const _OTN = "OriginalTypeName"; +const _OUI = "OrganizationalUnitIds"; +const _OUIr = "OrganizationalUnitId"; +const _OV = "OutputValue"; +const _Ou = "Outputs"; +const _P = "Parameters"; +const _PA = "PolicyAction"; +const _PC = "PercentageCompleted"; +const _PCSI = "ParentChangeSetId"; +const _PCa = "ParameterConstraints"; +const _PD = "ParameterDeclaration"; +const _PDC = "PreviousDeploymentContext"; +const _PDa = "ParameterDeclarations"; +const _PDr = "PropertyDifference"; +const _PDro = "PropertyDifferences"; +const _PI = "PublisherId"; +const _PIa = "ParentId"; +const _PIu = "PublisherIdentity"; +const _PK = "ParameterKey"; +const _PM = "PermissionModel"; +const _PN = "PublisherName"; +const _PO = "ParameterOverrides"; +const _PP = "PublisherProfile"; +const _PPr = "PropertyPath"; +const _PRI = "PhysicalResourceId"; +const _PRIC = "PhysicalResourceIdContext"; +const _PRICKVP = "PhysicalResourceIdContextKeyValuePair"; +const _PS = "PublisherStatus"; +const _PSr = "ProgressStatus"; +const _PT = "ProvisioningType"; +const _PTA = "PublicTypeArn"; +const _PTI = "PublishTypeInput"; +const _PTO = "PublishTypeOutput"; +const _PTa = "ParameterType"; +const _PTu = "PublishType"; +const _PV = "PreviousValue"; +const _PVN = "PublicVersionNumber"; +const _PVa = "ParameterValue"; +const _Pa = "Parameter"; +const _Pat = "Path"; +const _Pr = "Progress"; +const _Pro = "Properties"; +const _R = "Resources"; +const _RA = "ResourceAction"; +const _RAR = "RefreshAllResources"; +const _RARN = "RoleARN"; +const _RAT = "RequiredActivatedTypes"; +const _RATe = "RequiredActivatedType"; +const _RC = "ResourceChange"; +const _RCD = "ResourceChangeDetail"; +const _RCDe = "ResourceChangeDetails"; +const _RCSI = "RootChangeSetId"; +const _RCT = "RegionConcurrencyType"; +const _RCo = "RollbackConfiguration"; +const _RD = "ResourceDefinition"; +const _RDIA = "ResourceDriftIgnoredAttributes"; +const _RDIAe = "ResourceDriftIgnoredAttribute"; +const _RDS = "ResourceDriftStatus"; +const _RDe = "ResourceDetail"; +const _RDes = "ResourceDefinitions"; +const _RDeso = "ResourceDetails"; +const _REOC = "RetainExceptOnCreate"; +const _RF = "ResourcesFailed"; +const _RHP = "RecordHandlerProgress"; +const _RHPI = "RecordHandlerProgressInput"; +const _RHPO = "RecordHandlerProgressOutput"; +const _RI = "ResourceIdentifier"; +const _RIS = "ResourceIdentifierSummaries"; +const _RISe = "ResourceIdentifierSummary"; +const _RIe = "ResourceIdentifiers"; +const _RIo = "RootId"; +const _RL = "RemediationLink"; +const _RLe = "ResourceLocation"; +const _RM = "RemediationMessage"; +const _RMe = "ResourceMappings"; +const _RMes = "ResourceModel"; +const _RMeso = "ResourceMapping"; +const _RO = "RegionOrder"; +const _RP = "ResourceProperties"; +const _RPI = "RegisterPublisherInput"; +const _RPO = "RegisterPublisherOutput"; +const _RPe = "ResourcesProcessing"; +const _RPeg = "RegisterPublisher"; +const _RPes = "ResourcesPending"; +const _RR = "RetainResources"; +const _RRe = "ResourcesRead"; +const _RRel = "RelatedResources"; +const _RRem = "RemoveResources"; +const _RReq = "RequiresRecreation"; +const _RS = "RetainStacks"; +const _RSF = "RegistrationStatusFilter"; +const _RSI = "ResourceScanId"; +const _RSIPE = "ResourceScanInProgressException"; +const _RSIo = "RollbackStackInput"; +const _RSLEE = "ResourceScanLimitExceededException"; +const _RSNFE = "ResourceScanNotFoundException"; +const _RSO = "RollbackStackOutput"; +const _RSOAR = "RetainStacksOnAccountRemoval"; +const _RSR = "ResourceStatusReason"; +const _RSS = "ResourceScanSummaries"; +const _RSSe = "ResourceScanSummary"; +const _RSe = "ResourcesScanned"; +const _RSes = "ResourceStatus"; +const _RSeso = "ResourcesSucceeded"; +const _RSo = "RollbackStack"; +const _RT = "ResourceType"; +const _RTD = "ResourceTargetDetails"; +const _RTDe = "ResourceTargetDefinition"; +const _RTI = "ResourcesToImport"; +const _RTIe = "RegisterTypeInput"; +const _RTIes = "ResourceToImport"; +const _RTL = "RegistrationTokenList"; +const _RTO = "RegisterTypeOutput"; +const _RTP = "ResourceTypePrefix"; +const _RTS = "ResourcesToSkip"; +const _RTe = "ResourceTypes"; +const _RTeg = "RegistrationToken"; +const _RTegi = "RegisterType"; +const _RTo = "RollbackTriggers"; +const _RTol = "RollbackTrigger"; +const _RV = "ResolvedValue"; +const _Re = "Regions"; +const _Rea = "Reason"; +const _Reg = "Region"; +const _Rep = "Replacement"; +const _Req = "Required"; +const _S = "Status"; +const _SA = "StagesAvailable"; +const _SD = "StackDefinitions"; +const _SDDI = "StackDriftDetectionId"; +const _SDI = "StackDriftInformation"; +const _SDIS = "StackDriftInformationSummary"; +const _SDS = "StackDriftStatus"; +const _SDt = "StackDefinition"; +const _SDta = "StatusDetails"; +const _SE = "StackEvents"; +const _SEt = "StackEvent"; +const _SF = "ScanFilters"; +const _SFc = "ScanFilter"; +const _SHP = "SchemaHandlerPackage"; +const _SI = "StackId"; +const _SIA = "StackInstanceAccount"; +const _SICS = "StackInstanceComprehensiveStatus"; +const _SIF = "StackInstanceFilter"; +const _SIFt = "StackInstanceFilters"; +const _SINFE = "StackInstanceNotFoundException"; +const _SIR = "StackInstanceRegion"; +const _SIRDS = "StackInstanceResourceDriftStatuses"; +const _SIRDSt = "StackInstanceResourceDriftsSummary"; +const _SIRDSta = "StackInstanceResourceDriftsSummaries"; +const _SIS = "StackInstanceStatus"; +const _SISt = "StackInstanceSummary"; +const _SISta = "StackInstanceSummaries"; +const _SIU = "StackIdsUrl"; +const _SIt = "StackInstance"; +const _SIta = "StackIds"; +const _SL = "SeverityLevel"; +const _SM = "StatusMessage"; +const _SMV = "SupportedMajorVersions"; +const _SN = "StackName"; +const _SNFE = "StackNotFoundException"; +const _SPB = "StackPolicyBody"; +const _SPDUB = "StackPolicyDuringUpdateBody"; +const _SPDUURL = "StackPolicyDuringUpdateURL"; +const _SPURL = "StackPolicyURL"; +const _SR = "StatusReason"; +const _SRA = "StackRefactorActions"; +const _SRAt = "StackRefactorAction"; +const _SRD = "StackResourceDrifts"; +const _SRDI = "StackResourceDriftInformation"; +const _SRDIS = "StackResourceDriftInformationSummary"; +const _SRDS = "StackResourceDriftStatus"; +const _SRDSF = "StackResourceDriftStatusFilters"; +const _SRDt = "StackResourceDetail"; +const _SRDta = "StackResourceDrift"; +const _SRE = "StaleRequestException"; +const _SRI = "StackRefactorId"; +const _SRIc = "ScannedResourceIdentifier"; +const _SRIca = "ScannedResourceIdentifiers"; +const _SRIi = "SignalResourceInput"; +const _SRNFE = "StackRefactorNotFoundException"; +const _SRS = "StackRefactorSummaries"; +const _SRSI = "StartResourceScanInput"; +const _SRSO = "StartResourceScanOutput"; +const _SRSt = "StackResourceSummaries"; +const _SRSta = "StackRefactorSummary"; +const _SRStac = "StackResourceSummary"; +const _SRStar = "StartResourceScan"; +const _SRTR = "StackRefactorTagResources"; +const _SRc = "ScannedResource"; +const _SRca = "ScannedResources"; +const _SRi = "SignalResource"; +const _SRt = "StackResources"; +const _SRta = "StackResource"; +const _SS = "StackSet"; +const _SSADTS = "StackSetAutoDeploymentTargetSummary"; +const _SSADTSt = "StackSetAutoDeploymentTargetSummaries"; +const _SSARN = "StackSetARN"; +const _SSDDD = "StackSetDriftDetectionDetails"; +const _SSF = "StackStatusFilter"; +const _SSI = "StackSetId"; +const _SSN = "StackSetName"; +const _SSNEE = "StackSetNotEmptyException"; +const _SSNFE = "StackSetNotFoundException"; +const _SSO = "StackSetOperation"; +const _SSOP = "StackSetOperationPreferences"; +const _SSORS = "StackSetOperationResultSummary"; +const _SSORSt = "StackSetOperationResultSummaries"; +const _SSOS = "StackSetOperationSummary"; +const _SSOSD = "StackSetOperationStatusDetails"; +const _SSOSt = "StackSetOperationSummaries"; +const _SSP = "SetStackPolicy"; +const _SSPI = "SetStackPolicyInput"; +const _SSR = "StackStatusReason"; +const _SSS = "StackSetSummary"; +const _SSSO = "StopStackSetOperation"; +const _SSSOI = "StopStackSetOperationInput"; +const _SSSOO = "StopStackSetOperationOutput"; +const _SSSt = "StackSetSummaries"; +const _SSt = "StackSummaries"; +const _SSta = "StackStatus"; +const _SStac = "StackSummary"; +const _ST = "StartTime"; +const _STC = "SetTypeConfiguration"; +const _STCI = "SetTypeConfigurationInput"; +const _STCO = "SetTypeConfigurationOutput"; +const _STDV = "SetTypeDefaultVersion"; +const _STDVI = "SetTypeDefaultVersionInput"; +const _STDVO = "SetTypeDefaultVersionOutput"; +const _STF = "ScanTypeFilter"; +const _STc = "ScanType"; +const _SU = "SourceUrl"; +const _Sc = "Schema"; +const _Sco = "Scope"; +const _So = "Source"; +const _St = "Stacks"; +const _Sta = "Stack"; +const _Su = "Summaries"; +const _T = "Type"; +const _TA = "TypeArn"; +const _TAEE = "TokenAlreadyExistsException"; +const _TB = "TemplateBody"; +const _TC = "TypeConfigurations"; +const _TCA = "TypeConfigurationAlias"; +const _TCAy = "TypeConfigurationArn"; +const _TCD = "TypeConfigurationDetails"; +const _TCDL = "TypeConfigurationDetailsList"; +const _TCI = "TypeConfigurationIdentifier"; +const _TCIy = "TypeConfigurationIdentifiers"; +const _TCNFE = "TypeConfigurationNotFoundException"; +const _TCVI = "TypeConfigurationVersionId"; +const _TCe = "TemplateConfiguration"; +const _TCi = "TimeCreated"; +const _TD = "TargetDetails"; +const _TDe = "TemplateDescription"; +const _TF = "TypeFilters"; +const _TH = "TypeHierarchy"; +const _TI = "TargetId"; +const _TIM = "TimeoutInMinutes"; +const _TK = "TagKey"; +const _TN = "TypeName"; +const _TNA = "TypeNameAlias"; +const _TNFE = "TypeNotFoundException"; +const _TNP = "TypeNamePrefix"; +const _TP = "TemplateParameter"; +const _TPe = "TemplateProgress"; +const _TPem = "TemplateParameters"; +const _TR = "TagResources"; +const _TS = "TemplateStage"; +const _TSC = "TemplateSummaryConfig"; +const _TSIC = "TotalStackInstancesCount"; +const _TSe = "TemplateSummary"; +const _TSem = "TemplateSummaries"; +const _TSy = "TypeSummaries"; +const _TSyp = "TypeSummary"; +const _TT = "TargetType"; +const _TTI = "TestTypeInput"; +const _TTN = "TargetTypeName"; +const _TTO = "TestTypeOutput"; +const _TTS = "TypeTestsStatus"; +const _TTSD = "TypeTestsStatusDescription"; +const _TTe = "TestType"; +const _TURL = "TemplateURL"; +const _TURTAW = "TreatUnrecognizedResourceTypesAsWarnings"; +const _TV = "TagValue"; +const _TVA = "TypeVersionArn"; +const _TVI = "TypeVersionId"; +const _TVS = "TypeVersionSummaries"; +const _TVSy = "TypeVersionSummary"; +const _TW = "TotalWarnings"; +const _Ta = "Tags"; +const _Tag = "Tag"; +const _Tar = "Target"; +const _Ti = "Timestamp"; +const _Ty = "Types"; +const _U = "Url"; +const _UGT = "UpdateGeneratedTemplate"; +const _UGTI = "UpdateGeneratedTemplateInput"; +const _UGTO = "UpdateGeneratedTemplateOutput"; +const _UI = "UniqueId"; +const _UPT = "UsePreviousTemplate"; +const _UPV = "UsePreviousValue"; +const _UR = "UntagResources"; +const _URP = "UpdateReplacePolicy"; +const _URT = "UnrecognizedResourceTypes"; +const _US = "UpdateStack"; +const _USI = "UpdateStackInput"; +const _USII = "UpdateStackInstancesInput"; +const _USIO = "UpdateStackInstancesOutput"; +const _USIp = "UpdateStackInstances"; +const _USO = "UpdateStackOutput"; +const _USS = "UpdateStackSet"; +const _USSI = "UpdateStackSetInput"; +const _USSO = "UpdateStackSetOutput"; +const _UTC = "UnprocessedTypeConfigurations"; +const _UTP = "UpdateTerminationProtection"; +const _UTPI = "UpdateTerminationProtectionInput"; +const _UTPO = "UpdateTerminationProtectionOutput"; +const _V = "Value"; +const _VB = "VersionBump"; +const _VFM = "ValidationFailureMode"; +const _VI = "VersionId"; +const _VN = "ValidationName"; +const _VP = "ValidationPath"; +const _VS = "ValidationStatus"; +const _VSR = "ValidationStatusReason"; +const _VT = "ValidateTemplate"; +const _VTI = "ValidateTemplateInput"; +const _VTO = "ValidateTemplateOutput"; +const _Va = "Values"; +const _Ve = "Version"; +const _Vi = "Visibility"; +const _W = "Warnings"; +const _WD = "WarningDetail"; +const _WDa = "WarningDetails"; +const _WP = "WarningProperty"; +const _WPa = "WarningProperties"; +const _aQE = "awsQueryError"; +const _c = "client"; +const _e = "error"; +const _hE = "httpError"; +const _s = "smithy.ts.sdk.synthetic.com.amazonaws.cloudformation"; +const n0 = "com.amazonaws.cloudformation"; +var AccountGateResult = [3, n0, _AGR, 0, [_S, _SR], [0, 0]]; +var AccountLimit = [3, n0, _AL, 0, [_N, _V], [0, 1]]; +var ActivateOrganizationsAccessInput = [3, n0, _AOAI, 0, [], []]; +var ActivateOrganizationsAccessOutput = [3, n0, _AOAO, 0, [], []]; +var ActivateTypeInput = [ + 3, + n0, + _ATI, + 0, + [_T, _PTA, _PI, _TN, _TNA, _AU, _LC, _ERA, _VB, _MV], + [0, 0, 0, 0, 0, 2, () => LoggingConfig, 0, 0, 1], +]; +var ActivateTypeOutput = [3, n0, _ATO, 0, [_A], [0]]; +var AlreadyExistsException = [ + -3, + n0, + _AEE, + { + [_e]: _c, + [_hE]: 400, + [_aQE]: [`AlreadyExistsException`, 400], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(AlreadyExistsException, AlreadyExistsException$1); +var Annotation = [3, n0, _An, 0, [_AN, _S, _SM, _RM, _RL, _SL], [0, 0, 0, 0, 0, 0]]; +var AutoDeployment = [3, n0, _AD, 0, [_E, _RSOAR], [2, 2]]; +var BatchDescribeTypeConfigurationsError = [ + 3, + n0, + _BDTCE, + 0, + [_EC, _EM, _TCI], + [0, 0, () => TypeConfigurationIdentifier], +]; +var BatchDescribeTypeConfigurationsInput = [ + 3, + n0, + _BDTCI, + 0, + [_TCIy], + [() => TypeConfigurationIdentifiers], +]; +var BatchDescribeTypeConfigurationsOutput = [ + 3, + n0, + _BDTCO, + 0, + [_Er, _UTC, _TC], + [ + () => BatchDescribeTypeConfigurationsErrors, + () => UnprocessedTypeConfigurations, + () => TypeConfigurationDetailsList, + ], +]; +var CancelUpdateStackInput = [3, n0, _CUSI, 0, [_SN, _CRT], [0, 0]]; +var CFNRegistryException = [ + -3, + n0, + _CFNRE, + { + [_e]: _c, + [_hE]: 400, + [_aQE]: [`CFNRegistryException`, 400], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(CFNRegistryException, CFNRegistryException$1); +var Change = [3, n0, _C, 0, [_T, _HIC, _RC], [0, 1, () => ResourceChange]]; +var ChangeSetHook = [ + 3, + n0, + _CSH, + 0, + [_IP, _FM, _TN, _TVI, _TCVI, _TD], + [0, 0, 0, 0, 0, () => ChangeSetHookTargetDetails], +]; +var ChangeSetHookResourceTargetDetails = [3, n0, _CSHRTD, 0, [_LRI, _RT, _RA], [0, 0, 0]]; +var ChangeSetHookTargetDetails = [ + 3, + n0, + _CSHTD, + 0, + [_TT, _RTD], + [0, () => ChangeSetHookResourceTargetDetails], +]; +var ChangeSetNotFoundException = [ + -3, + n0, + _CSNFE, + { + [_e]: _c, + [_hE]: 404, + [_aQE]: [`ChangeSetNotFound`, 404], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(ChangeSetNotFoundException, ChangeSetNotFoundException$1); +var ChangeSetSummary = [ + 3, + n0, + _CSS, + 0, + [_SI, _SN, _CSI, _CSN, _ES, _S, _SR, _CT, _D, _INS, _PCSI, _RCSI, _IER], + [0, 0, 0, 0, 0, 0, 0, 4, 0, 2, 0, 0, 2], +]; +var ConcurrentResourcesLimitExceededException = [ + -3, + n0, + _CRLEE, + { + [_e]: _c, + [_hE]: 429, + [_aQE]: [`ConcurrentResourcesLimitExceeded`, 429], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(ConcurrentResourcesLimitExceededException, ConcurrentResourcesLimitExceededException$1); +var ContinueUpdateRollbackInput = [ + 3, + n0, + _CURI, + 0, + [_SN, _RARN, _RTS, _CRT], + [0, 0, 64 | 0, 0], +]; +var ContinueUpdateRollbackOutput = [3, n0, _CURO, 0, [], []]; +var CreateChangeSetInput = [ + 3, + n0, + _CCSI, + 0, + [_SN, _TB, _TURL, _UPT, _P, _Ca, _RTe, _RARN, _RCo, _NARN, _Ta, _CSN, _CTl, _D, _CST, _RTI, _INS, _OSF, _IER, _DM], + [ + 0, + 0, + 0, + 2, + () => _Parameters, + 64 | 0, + 64 | 0, + 0, + () => RollbackConfiguration, + 64 | 0, + () => Tags, + 0, + 0, + 0, + 0, + () => ResourcesToImport, + 2, + 0, + 2, + 0, + ], +]; +var CreateChangeSetOutput = [3, n0, _CCSO, 0, [_I, _SI], [0, 0]]; +var CreatedButModifiedException = [ + -3, + n0, + _CBME, + { + [_e]: _c, + [_hE]: 409, + [_aQE]: [`CreatedButModifiedException`, 409], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(CreatedButModifiedException, CreatedButModifiedException$1); +var CreateGeneratedTemplateInput = [ + 3, + n0, + _CGTI, + 0, + [_R, _GTN, _SN, _TCe], + [() => ResourceDefinitions, 0, 0, () => TemplateConfiguration], +]; +var CreateGeneratedTemplateOutput = [3, n0, _CGTO, 0, [_GTI], [0]]; +var CreateStackInput = [ + 3, + n0, + _CSIr, + 0, + [_SN, _TB, _TURL, _P, _DR, _RCo, _TIM, _NARN, _Ca, _RTe, _RARN, _OF, _SPB, _SPURL, _Ta, _CRT, _ETP, _REOC], + [ + 0, + 0, + 0, + () => _Parameters, + 2, + () => RollbackConfiguration, + 1, + 64 | 0, + 64 | 0, + 64 | 0, + 0, + 0, + 0, + 0, + () => Tags, + 0, + 2, + 2, + ], +]; +var CreateStackInstancesInput = [ + 3, + n0, + _CSII, + 0, + [_SSN, _Ac, _DT, _Re, _PO, _OP, _OI, _CA], + [0, 64 | 0, () => DeploymentTargets, 64 | 0, () => _Parameters, () => StackSetOperationPreferences, [0, 4], 0], +]; +var CreateStackInstancesOutput = [3, n0, _CSIO, 0, [_OI], [0]]; +var CreateStackOutput = [3, n0, _CSO, 0, [_SI, _OI], [0, 0]]; +var CreateStackRefactorInput = [ + 3, + n0, + _CSRI, + 0, + [_D, _ESC, _RMe, _SD], + [0, 2, () => ResourceMappings, () => StackDefinitions], +]; +var CreateStackRefactorOutput = [3, n0, _CSRO, 0, [_SRI], [0]]; +var CreateStackSetInput = [ + 3, + n0, + _CSSI, + 0, + [_SSN, _D, _TB, _TURL, _SI, _P, _Ca, _Ta, _ARARN, _ERN, _PM, _AD, _CA, _CRT, _ME], + [ + 0, + 0, + 0, + 0, + 0, + () => _Parameters, + 64 | 0, + () => Tags, + 0, + 0, + 0, + () => AutoDeployment, + 0, + [0, 4], + () => ManagedExecution, + ], +]; +var CreateStackSetOutput = [3, n0, _CSSO, 0, [_SSI], [0]]; +var DeactivateOrganizationsAccessInput = [3, n0, _DOAI, 0, [], []]; +var DeactivateOrganizationsAccessOutput = [3, n0, _DOAO, 0, [], []]; +var DeactivateTypeInput = [3, n0, _DTI, 0, [_TN, _T, _A], [0, 0, 0]]; +var DeactivateTypeOutput = [3, n0, _DTO, 0, [], []]; +var DeleteChangeSetInput = [3, n0, _DCSI, 0, [_CSN, _SN], [0, 0]]; +var DeleteChangeSetOutput = [3, n0, _DCSO, 0, [], []]; +var DeleteGeneratedTemplateInput = [3, n0, _DGTI, 0, [_GTN], [0]]; +var DeleteStackInput = [ + 3, + n0, + _DSI, + 0, + [_SN, _RR, _RARN, _CRT, _DMe], + [0, 64 | 0, 0, 0, 0], +]; +var DeleteStackInstancesInput = [ + 3, + n0, + _DSII, + 0, + [_SSN, _Ac, _DT, _Re, _OP, _RS, _OI, _CA], + [0, 64 | 0, () => DeploymentTargets, 64 | 0, () => StackSetOperationPreferences, 2, [0, 4], 0], +]; +var DeleteStackInstancesOutput = [3, n0, _DSIO, 0, [_OI], [0]]; +var DeleteStackSetInput = [3, n0, _DSSI, 0, [_SSN, _CA], [0, 0]]; +var DeleteStackSetOutput = [3, n0, _DSSO, 0, [], []]; +var DeploymentTargets = [3, n0, _DT, 0, [_Ac, _AUc, _OUI, _AFT], [64 | 0, 0, 64 | 0, 0]]; +var DeregisterTypeInput = [3, n0, _DTIe, 0, [_A, _T, _TN, _VI], [0, 0, 0, 0]]; +var DeregisterTypeOutput = [3, n0, _DTOe, 0, [], []]; +var DescribeAccountLimitsInput = [3, n0, _DALI, 0, [_NT], [0]]; +var DescribeAccountLimitsOutput = [ + 3, + n0, + _DALO, + 0, + [_ALc, _NT], + [() => AccountLimitList, 0], +]; +var DescribeChangeSetHooksInput = [ + 3, + n0, + _DCSHI, + 0, + [_CSN, _SN, _NT, _LRI], + [0, 0, 0, 0], +]; +var DescribeChangeSetHooksOutput = [ + 3, + n0, + _DCSHO, + 0, + [_CSI, _CSN, _H, _S, _NT, _SI, _SN], + [0, 0, () => ChangeSetHooks, 0, 0, 0, 0], +]; +var DescribeChangeSetInput = [3, n0, _DCSIe, 0, [_CSN, _SN, _NT, _IPV], [0, 0, 0, 2]]; +var DescribeChangeSetOutput = [ + 3, + n0, + _DCSOe, + 0, + [ + _CSN, + _CSI, + _SI, + _SN, + _D, + _P, + _CT, + _ES, + _S, + _SR, + _SDS, + _NARN, + _RCo, + _Ca, + _Ta, + _Ch, + _NT, + _INS, + _PCSI, + _RCSI, + _OSF, + _IER, + _DM, + ], + [ + 0, + 0, + 0, + 0, + 0, + () => _Parameters, + 4, + 0, + 0, + 0, + 0, + 64 | 0, + () => RollbackConfiguration, + 64 | 0, + () => Tags, + () => Changes, + 0, + 2, + 0, + 0, + 0, + 2, + 0, + ], +]; +var DescribeEventsInput = [ + 3, + n0, + _DEI, + 0, + [_SN, _CSN, _OI, _F, _NT], + [0, 0, 0, () => EventFilter, 0], +]; +var DescribeEventsOutput = [3, n0, _DEO, 0, [_OE, _NT], [() => OperationEvents, 0]]; +var DescribeGeneratedTemplateInput = [3, n0, _DGTIe, 0, [_GTN], [0]]; +var DescribeGeneratedTemplateOutput = [ + 3, + n0, + _DGTO, + 0, + [_GTI, _GTN, _R, _S, _SR, _CT, _LUT, _Pr, _SI, _TCe, _TW], + [0, 0, () => ResourceDetails, 0, 0, 4, 4, () => TemplateProgress, 0, () => TemplateConfiguration, 1], +]; +var DescribeOrganizationsAccessInput = [3, n0, _DOAIe, 0, [_CA], [0]]; +var DescribeOrganizationsAccessOutput = [3, n0, _DOAOe, 0, [_S], [0]]; +var DescribePublisherInput = [3, n0, _DPI, 0, [_PI], [0]]; +var DescribePublisherOutput = [3, n0, _DPO, 0, [_PI, _PS, _IPd, _PP], [0, 0, 0, 0]]; +var DescribeResourceScanInput = [3, n0, _DRSI, 0, [_RSI], [0]]; +var DescribeResourceScanOutput = [ + 3, + n0, + _DRSO, + 0, + [_RSI, _S, _SR, _ST, _ET, _PC, _RTe, _RSe, _RRe, _SF], + [0, 0, 0, 4, 4, 1, 64 | 0, 1, 1, () => ScanFilters], +]; +var DescribeStackDriftDetectionStatusInput = [3, n0, _DSDDSI, 0, [_SDDI], [0]]; +var DescribeStackDriftDetectionStatusOutput = [ + 3, + n0, + _DSDDSO, + 0, + [_SI, _SDDI, _SDS, _DS, _DSR, _DSRC, _Ti], + [0, 0, 0, 0, 0, 1, 4], +]; +var DescribeStackEventsInput = [3, n0, _DSEI, 0, [_SN, _NT], [0, 0]]; +var DescribeStackEventsOutput = [3, n0, _DSEO, 0, [_SE, _NT], [() => StackEvents, 0]]; +var DescribeStackInstanceInput = [ + 3, + n0, + _DSIIe, + 0, + [_SSN, _SIA, _SIR, _CA], + [0, 0, 0, 0], +]; +var DescribeStackInstanceOutput = [3, n0, _DSIOe, 0, [_SIt], [() => StackInstance]]; +var DescribeStackRefactorInput = [3, n0, _DSRI, 0, [_SRI], [0]]; +var DescribeStackRefactorOutput = [ + 3, + n0, + _DSRO, + 0, + [_D, _SRI, _SIta, _ES, _ESR, _S, _SR], + [0, 0, 64 | 0, 0, 0, 0, 0], +]; +var DescribeStackResourceDriftsInput = [ + 3, + n0, + _DSRDI, + 0, + [_SN, _SRDSF, _NT, _MR], + [0, 64 | 0, 0, 1], +]; +var DescribeStackResourceDriftsOutput = [ + 3, + n0, + _DSRDO, + 0, + [_SRD, _NT], + [() => StackResourceDrifts, 0], +]; +var DescribeStackResourceInput = [3, n0, _DSRIe, 0, [_SN, _LRI], [0, 0]]; +var DescribeStackResourceOutput = [ + 3, + n0, + _DSROe, + 0, + [_SRDt], + [() => StackResourceDetail], +]; +var DescribeStackResourcesInput = [3, n0, _DSRIes, 0, [_SN, _LRI, _PRI], [0, 0, 0]]; +var DescribeStackResourcesOutput = [3, n0, _DSROes, 0, [_SRt], [() => StackResources]]; +var DescribeStackSetInput = [3, n0, _DSSIe, 0, [_SSN, _CA], [0, 0]]; +var DescribeStackSetOperationInput = [3, n0, _DSSOI, 0, [_SSN, _OI, _CA], [0, 0, 0]]; +var DescribeStackSetOperationOutput = [ + 3, + n0, + _DSSOO, + 0, + [_SSO], + [() => StackSetOperation], +]; +var DescribeStackSetOutput = [3, n0, _DSSOe, 0, [_SS], [() => StackSet]]; +var DescribeStacksInput = [3, n0, _DSIe, 0, [_SN, _NT], [0, 0]]; +var DescribeStacksOutput = [3, n0, _DSO, 0, [_St, _NT], [() => Stacks, 0]]; +var DescribeTypeInput = [ + 3, + n0, + _DTIes, + 0, + [_T, _TN, _A, _VI, _PI, _PVN], + [0, 0, 0, 0, 0, 0], +]; +var DescribeTypeOutput = [ + 3, + n0, + _DTOes, + 0, + [ + _A, + _T, + _TN, + _DVI, + _IDV, + _TTS, + _TTSD, + _D, + _Sc, + _PT, + _DSe, + _LC, + _RAT, + _ERA, + _Vi, + _SU, + _DU, + _LU, + _TCi, + _CS, + _PI, + _OTN, + _OTA, + _PVN, + _LPV, + _IA, + _AU, + ], + [ + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + () => LoggingConfig, + () => RequiredActivatedTypes, + 0, + 0, + 0, + 0, + 4, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + ], +]; +var DescribeTypeRegistrationInput = [3, n0, _DTRI, 0, [_RTeg], [0]]; +var DescribeTypeRegistrationOutput = [ + 3, + n0, + _DTRO, + 0, + [_PSr, _D, _TA, _TVA], + [0, 0, 0, 0], +]; +var DetectStackDriftInput = [3, n0, _DSDI, 0, [_SN, _LRIo], [0, 64 | 0]]; +var DetectStackDriftOutput = [3, n0, _DSDO, 0, [_SDDI], [0]]; +var DetectStackResourceDriftInput = [3, n0, _DSRDIe, 0, [_SN, _LRI], [0, 0]]; +var DetectStackResourceDriftOutput = [ + 3, + n0, + _DSRDOe, + 0, + [_SRDta], + [() => StackResourceDrift], +]; +var DetectStackSetDriftInput = [ + 3, + n0, + _DSSDI, + 0, + [_SSN, _OP, _OI, _CA], + [0, () => StackSetOperationPreferences, [0, 4], 0], +]; +var DetectStackSetDriftOutput = [3, n0, _DSSDO, 0, [_OI], [0]]; +var EstimateTemplateCostInput = [ + 3, + n0, + _ETCI, + 0, + [_TB, _TURL, _P], + [0, 0, () => _Parameters], +]; +var EstimateTemplateCostOutput = [3, n0, _ETCO, 0, [_U], [0]]; +var EventFilter = [3, n0, _EF, 0, [_FE], [2]]; +var ExecuteChangeSetInput = [ + 3, + n0, + _ECSI, + 0, + [_CSN, _SN, _CRT, _DR, _REOC], + [0, 0, 0, 2, 2], +]; +var ExecuteChangeSetOutput = [3, n0, _ECSO, 0, [], []]; +var ExecuteStackRefactorInput = [3, n0, _ESRI, 0, [_SRI], [0]]; +var Export = [3, n0, _Ex, 0, [_ESI, _N, _V], [0, 0, 0]]; +var GeneratedTemplateNotFoundException = [ + -3, + n0, + _GTNFE, + { + [_e]: _c, + [_hE]: 404, + [_aQE]: [`GeneratedTemplateNotFound`, 404], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(GeneratedTemplateNotFoundException, GeneratedTemplateNotFoundException$1); +var GetGeneratedTemplateInput = [3, n0, _GGTI, 0, [_Fo, _GTN], [0, 0]]; +var GetGeneratedTemplateOutput = [3, n0, _GGTO, 0, [_S, _TB], [0, 0]]; +var GetHookResultInput = [3, n0, _GHRI, 0, [_HRI], [0]]; +var GetHookResultOutput = [ + 3, + n0, + _GHRO, + 0, + [_HRI, _IP, _FM, _TN, _OTN, _TVI, _TCVI, _TA, _S, _HSR, _IAn, _Tar, _Ann], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, () => HookTarget, () => AnnotationList], +]; +var GetStackPolicyInput = [3, n0, _GSPI, 0, [_SN], [0]]; +var GetStackPolicyOutput = [3, n0, _GSPO, 0, [_SPB], [0]]; +var GetTemplateInput = [3, n0, _GTIe, 0, [_SN, _CSN, _TS], [0, 0, 0]]; +var GetTemplateOutput = [3, n0, _GTO, 0, [_TB, _SA], [0, 64 | 0]]; +var GetTemplateSummaryInput = [ + 3, + n0, + _GTSI, + 0, + [_TB, _TURL, _SN, _SSN, _CA, _TSC], + [0, 0, 0, 0, 0, () => TemplateSummaryConfig], +]; +var GetTemplateSummaryOutput = [ + 3, + n0, + _GTSO, + 0, + [_P, _D, _Ca, _CR, _RTe, _Ve, _Me, _DTe, _RIS, _W], + [() => ParameterDeclarations, 0, 64 | 0, 0, 64 | 0, 0, 0, 64 | 0, () => ResourceIdentifierSummaries, () => Warnings], +]; +var HookResultNotFoundException = [ + -3, + n0, + _HRNFE, + { + [_e]: _c, + [_hE]: 404, + [_aQE]: [`HookResultNotFound`, 404], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(HookResultNotFoundException, HookResultNotFoundException$1); +var HookResultSummary = [ + 3, + n0, + _HRS, + 0, + [_HRI, _IP, _FM, _TN, _TVI, _TCVI, _S, _HSR, _IAn, _TT, _TI, _TA, _HET], + [0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0], +]; +var HookTarget = [3, n0, _HT, 0, [_TT, _TTN, _TI, _Act], [0, 0, 0, 0]]; +var ImportStacksToStackSetInput = [ + 3, + n0, + _ISTSSI, + 0, + [_SSN, _SIta, _SIU, _OUI, _OP, _OI, _CA], + [0, 64 | 0, 0, 64 | 0, () => StackSetOperationPreferences, [0, 4], 0], +]; +var ImportStacksToStackSetOutput = [3, n0, _ISTSSO, 0, [_OI], [0]]; +var InsufficientCapabilitiesException = [ + -3, + n0, + _ICE, + { + [_e]: _c, + [_hE]: 400, + [_aQE]: [`InsufficientCapabilitiesException`, 400], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(InsufficientCapabilitiesException, InsufficientCapabilitiesException$1); +var InvalidChangeSetStatusException = [ + -3, + n0, + _ICSSE, + { + [_e]: _c, + [_hE]: 400, + [_aQE]: [`InvalidChangeSetStatus`, 400], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(InvalidChangeSetStatusException, InvalidChangeSetStatusException$1); +var InvalidOperationException = [ + -3, + n0, + _IOE, + { + [_e]: _c, + [_hE]: 400, + [_aQE]: [`InvalidOperationException`, 400], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(InvalidOperationException, InvalidOperationException$1); +var InvalidStateTransitionException = [ + -3, + n0, + _ISTE, + { + [_e]: _c, + [_hE]: 400, + [_aQE]: [`InvalidStateTransition`, 400], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(InvalidStateTransitionException, InvalidStateTransitionException$1); +var LimitExceededException = [ + -3, + n0, + _LEE, + { + [_e]: _c, + [_hE]: 400, + [_aQE]: [`LimitExceededException`, 400], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(LimitExceededException, LimitExceededException$1); +var ListChangeSetsInput = [3, n0, _LCSI, 0, [_SN, _NT], [0, 0]]; +var ListChangeSetsOutput = [3, n0, _LCSO, 0, [_Su, _NT], [() => ChangeSetSummaries, 0]]; +var ListExportsInput = [3, n0, _LEI, 0, [_NT], [0]]; +var ListExportsOutput = [3, n0, _LEO, 0, [_Exp, _NT], [() => Exports, 0]]; +var ListGeneratedTemplatesInput = [3, n0, _LGTI, 0, [_NT, _MR], [0, 1]]; +var ListGeneratedTemplatesOutput = [ + 3, + n0, + _LGTO, + 0, + [_Su, _NT], + [() => TemplateSummaries, 0], +]; +var ListHookResultsInput = [3, n0, _LHRI, 0, [_TT, _TI, _TA, _S, _NT], [0, 0, 0, 0, 0]]; +var ListHookResultsOutput = [ + 3, + n0, + _LHRO, + 0, + [_TT, _TI, _HR, _NT], + [0, 0, () => HookResultSummaries, 0], +]; +var ListImportsInput = [3, n0, _LII, 0, [_EN, _NT], [0, 0]]; +var ListImportsOutput = [3, n0, _LIO, 0, [_Im, _NT], [64 | 0, 0]]; +var ListResourceScanRelatedResourcesInput = [ + 3, + n0, + _LRSRRI, + 0, + [_RSI, _R, _NT, _MR], + [0, () => ScannedResourceIdentifiers, 0, 1], +]; +var ListResourceScanRelatedResourcesOutput = [ + 3, + n0, + _LRSRRO, + 0, + [_RRel, _NT], + [() => RelatedResources, 0], +]; +var ListResourceScanResourcesInput = [ + 3, + n0, + _LRSRI, + 0, + [_RSI, _RI, _RTP, _TK, _TV, _NT, _MR], + [0, 0, 0, 0, 0, 0, 1], +]; +var ListResourceScanResourcesOutput = [ + 3, + n0, + _LRSRO, + 0, + [_R, _NT], + [() => ScannedResources, 0], +]; +var ListResourceScansInput = [3, n0, _LRSI, 0, [_NT, _MR, _STF], [0, 1, 0]]; +var ListResourceScansOutput = [ + 3, + n0, + _LRSO, + 0, + [_RSS, _NT], + [() => ResourceScanSummaries, 0], +]; +var ListStackInstanceResourceDriftsInput = [ + 3, + n0, + _LSIRDI, + 0, + [_SSN, _NT, _MR, _SIRDS, _SIA, _SIR, _OI, _CA], + [0, 0, 1, 64 | 0, 0, 0, 0, 0], +]; +var ListStackInstanceResourceDriftsOutput = [ + 3, + n0, + _LSIRDO, + 0, + [_Su, _NT], + [() => StackInstanceResourceDriftsSummaries, 0], +]; +var ListStackInstancesInput = [ + 3, + n0, + _LSII, + 0, + [_SSN, _NT, _MR, _F, _SIA, _SIR, _CA], + [0, 0, 1, () => StackInstanceFilters, 0, 0, 0], +]; +var ListStackInstancesOutput = [ + 3, + n0, + _LSIO, + 0, + [_Su, _NT], + [() => StackInstanceSummaries, 0], +]; +var ListStackRefactorActionsInput = [3, n0, _LSRAI, 0, [_SRI, _NT, _MR], [0, 0, 1]]; +var ListStackRefactorActionsOutput = [ + 3, + n0, + _LSRAO, + 0, + [_SRA, _NT], + [() => StackRefactorActions, 0], +]; +var ListStackRefactorsInput = [3, n0, _LSRI, 0, [_ESF, _NT, _MR], [64 | 0, 0, 1]]; +var ListStackRefactorsOutput = [ + 3, + n0, + _LSRO, + 0, + [_SRS, _NT], + [() => StackRefactorSummaries, 0], +]; +var ListStackResourcesInput = [3, n0, _LSRIi, 0, [_SN, _NT], [0, 0]]; +var ListStackResourcesOutput = [ + 3, + n0, + _LSROi, + 0, + [_SRSt, _NT], + [() => StackResourceSummaries, 0], +]; +var ListStackSetAutoDeploymentTargetsInput = [ + 3, + n0, + _LSSADTI, + 0, + [_SSN, _NT, _MR, _CA], + [0, 0, 1, 0], +]; +var ListStackSetAutoDeploymentTargetsOutput = [ + 3, + n0, + _LSSADTO, + 0, + [_Su, _NT], + [() => StackSetAutoDeploymentTargetSummaries, 0], +]; +var ListStackSetOperationResultsInput = [ + 3, + n0, + _LSSORI, + 0, + [_SSN, _OI, _NT, _MR, _CA, _F], + [0, 0, 0, 1, 0, () => OperationResultFilters], +]; +var ListStackSetOperationResultsOutput = [ + 3, + n0, + _LSSORO, + 0, + [_Su, _NT], + [() => StackSetOperationResultSummaries, 0], +]; +var ListStackSetOperationsInput = [3, n0, _LSSOI, 0, [_SSN, _NT, _MR, _CA], [0, 0, 1, 0]]; +var ListStackSetOperationsOutput = [ + 3, + n0, + _LSSOO, + 0, + [_Su, _NT], + [() => StackSetOperationSummaries, 0], +]; +var ListStackSetsInput = [3, n0, _LSSI, 0, [_NT, _MR, _S, _CA], [0, 1, 0, 0]]; +var ListStackSetsOutput = [3, n0, _LSSO, 0, [_Su, _NT], [() => StackSetSummaries, 0]]; +var ListStacksInput = [3, n0, _LSI, 0, [_NT, _SSF], [0, 64 | 0]]; +var ListStacksOutput = [3, n0, _LSO, 0, [_SSt, _NT], [() => StackSummaries, 0]]; +var ListTypeRegistrationsInput = [ + 3, + n0, + _LTRI, + 0, + [_T, _TN, _TA, _RSF, _MR, _NT], + [0, 0, 0, 0, 1, 0], +]; +var ListTypeRegistrationsOutput = [3, n0, _LTRO, 0, [_RTL, _NT], [64 | 0, 0]]; +var ListTypesInput = [ + 3, + n0, + _LTI, + 0, + [_Vi, _PT, _DSe, _T, _F, _MR, _NT], + [0, 0, 0, 0, () => TypeFilters, 1, 0], +]; +var ListTypesOutput = [3, n0, _LTO, 0, [_TSy, _NT], [() => TypeSummaries, 0]]; +var ListTypeVersionsInput = [ + 3, + n0, + _LTVI, + 0, + [_T, _TN, _A, _MR, _NT, _DSe, _PI], + [0, 0, 0, 1, 0, 0, 0], +]; +var ListTypeVersionsOutput = [ + 3, + n0, + _LTVO, + 0, + [_TVS, _NT], + [() => TypeVersionSummaries, 0], +]; +var LiveResourceDrift = [3, n0, _LRD, 0, [_PV, _AV, _DDT], [0, 0, 4]]; +var LoggingConfig = [3, n0, _LC, 0, [_LRA, _LGN], [0, 0]]; +var ManagedExecution = [3, n0, _ME, 0, [_Acti], [2]]; +var ModuleInfo = [3, n0, _MI, 0, [_TH, _LIH], [0, 0]]; +var NameAlreadyExistsException = [ + -3, + n0, + _NAEE, + { + [_e]: _c, + [_hE]: 409, + [_aQE]: [`NameAlreadyExistsException`, 409], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(NameAlreadyExistsException, NameAlreadyExistsException$1); +var OperationEntry = [3, n0, _OEp, 0, [_OT, _OI], [0, 0]]; +var OperationEvent = [ + 3, + n0, + _OEpe, + 0, + [ + _EI, + _SI, + _OI, + _OT, + _OS, + _ETv, + _LRI, + _PRI, + _RT, + _Ti, + _ST, + _ET, + _RSes, + _RSR, + _RP, + _CRT, + _HTo, + _HS, + _HSR, + _HIP, + _HFM, + _DSet, + _VFM, + _VN, + _VS, + _VSR, + _VP, + ], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], +]; +var OperationIdAlreadyExistsException = [ + -3, + n0, + _OIAEE, + { + [_e]: _c, + [_hE]: 409, + [_aQE]: [`OperationIdAlreadyExistsException`, 409], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(OperationIdAlreadyExistsException, OperationIdAlreadyExistsException$1); +var OperationInProgressException = [ + -3, + n0, + _OIPE, + { + [_e]: _c, + [_hE]: 409, + [_aQE]: [`OperationInProgressException`, 409], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(OperationInProgressException, OperationInProgressException$1); +var OperationNotFoundException = [ + -3, + n0, + _ONFE, + { + [_e]: _c, + [_hE]: 404, + [_aQE]: [`OperationNotFoundException`, 404], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(OperationNotFoundException, OperationNotFoundException$1); +var OperationResultFilter = [3, n0, _ORF, 0, [_N, _Va], [0, 0]]; +var OperationStatusCheckFailedException = [ + -3, + n0, + _OSCFE, + { + [_e]: _c, + [_hE]: 400, + [_aQE]: [`ConditionalCheckFailed`, 400], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(OperationStatusCheckFailedException, OperationStatusCheckFailedException$1); +var Output = [3, n0, _O, 0, [_OK, _OV, _D, _EN], [0, 0, 0, 0]]; +var Parameter = [3, n0, _Pa, 0, [_PK, _PVa, _UPV, _RV], [0, 0, 2, 0]]; +var ParameterConstraints = [3, n0, _PCa, 0, [_AVl], [64 | 0]]; +var ParameterDeclaration = [ + 3, + n0, + _PD, + 0, + [_PK, _DV, _PTa, _NE, _D, _PCa], + [0, 0, 0, 2, 0, () => ParameterConstraints], +]; +var PhysicalResourceIdContextKeyValuePair = [3, n0, _PRICKVP, 0, [_K, _V], [0, 0]]; +var PropertyDifference = [3, n0, _PDr, 0, [_PPr, _EV, _AV, _DTi], [0, 0, 0, 0]]; +var PublishTypeInput = [3, n0, _PTI, 0, [_T, _A, _TN, _PVN], [0, 0, 0, 0]]; +var PublishTypeOutput = [3, n0, _PTO, 0, [_PTA], [0]]; +var RecordHandlerProgressInput = [ + 3, + n0, + _RHPI, + 0, + [_BT, _OS, _COS, _SM, _EC, _RMes, _CRT], + [0, 0, 0, 0, 0, 0, 0], +]; +var RecordHandlerProgressOutput = [3, n0, _RHPO, 0, [], []]; +var RegisterPublisherInput = [3, n0, _RPI, 0, [_ATAC, _CAo], [2, 0]]; +var RegisterPublisherOutput = [3, n0, _RPO, 0, [_PI], [0]]; +var RegisterTypeInput = [ + 3, + n0, + _RTIe, + 0, + [_T, _TN, _SHP, _LC, _ERA, _CRT], + [0, 0, 0, () => LoggingConfig, 0, 0], +]; +var RegisterTypeOutput = [3, n0, _RTO, 0, [_RTeg], [0]]; +var RequiredActivatedType = [3, n0, _RATe, 0, [_TNA, _OTN, _PI, _SMV], [0, 0, 0, 64 | 1]]; +var ResourceChange = [ + 3, + n0, + _RC, + 0, + [_PA, _Act, _LRI, _PRI, _RT, _Rep, _Sco, _RDS, _RDIA, _De, _CSI, _MI, _BC, _AC, _PDC], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 64 | 0, + 0, + () => ResourceDriftIgnoredAttributes, + () => ResourceChangeDetails, + 0, + () => ModuleInfo, + 0, + 0, + 0, + ], +]; +var ResourceChangeDetail = [ + 3, + n0, + _RCD, + 0, + [_Tar, _Ev, _CSh, _CE], + [() => ResourceTargetDefinition, 0, 0, 0], +]; +var ResourceDefinition = [3, n0, _RD, 0, [_RT, _LRI, _RI], [0, 0, 128 | 0]]; +var ResourceDetail = [ + 3, + n0, + _RDe, + 0, + [_RT, _LRI, _RI, _RSes, _RSR, _W], + [0, 0, 128 | 0, 0, 0, () => WarningDetails], +]; +var ResourceDriftIgnoredAttribute = [3, n0, _RDIAe, 0, [_Pat, _Rea], [0, 0]]; +var ResourceIdentifierSummary = [ + 3, + n0, + _RISe, + 0, + [_RT, _LRIo, _RIe], + [0, 64 | 0, 64 | 0], +]; +var ResourceLocation = [3, n0, _RLe, 0, [_SN, _LRI], [0, 0]]; +var ResourceMapping = [ + 3, + n0, + _RMeso, + 0, + [_So, _Des], + [() => ResourceLocation, () => ResourceLocation], +]; +var ResourceScanInProgressException = [ + -3, + n0, + _RSIPE, + { + [_e]: _c, + [_hE]: 400, + [_aQE]: [`ResourceScanInProgress`, 400], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(ResourceScanInProgressException, ResourceScanInProgressException$1); +var ResourceScanLimitExceededException = [ + -3, + n0, + _RSLEE, + { + [_e]: _c, + [_hE]: 400, + [_aQE]: [`ResourceScanLimitExceeded`, 400], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(ResourceScanLimitExceededException, ResourceScanLimitExceededException$1); +var ResourceScanNotFoundException = [ + -3, + n0, + _RSNFE, + { + [_e]: _c, + [_hE]: 400, + [_aQE]: [`ResourceScanNotFound`, 400], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(ResourceScanNotFoundException, ResourceScanNotFoundException$1); +var ResourceScanSummary = [ + 3, + n0, + _RSSe, + 0, + [_RSI, _S, _SR, _ST, _ET, _PC, _STc], + [0, 0, 0, 4, 4, 1, 0], +]; +var ResourceTargetDefinition = [ + 3, + n0, + _RTDe, + 0, + [_At, _N, _RReq, _Pat, _BV, _AVf, _BVF, _AVF, _Dr, _ACT], + [0, 0, 0, 0, 0, 0, 0, 0, () => LiveResourceDrift, 0], +]; +var ResourceToImport = [3, n0, _RTIes, 0, [_RT, _LRI, _RI], [0, 0, 128 | 0]]; +var RollbackConfiguration = [3, n0, _RCo, 0, [_RTo, _MTIM], [() => RollbackTriggers, 1]]; +var RollbackStackInput = [3, n0, _RSIo, 0, [_SN, _RARN, _CRT, _REOC], [0, 0, 0, 2]]; +var RollbackStackOutput = [3, n0, _RSO, 0, [_SI, _OI], [0, 0]]; +var RollbackTrigger = [3, n0, _RTol, 0, [_A, _T], [0, 0]]; +var ScanFilter = [3, n0, _SFc, 0, [_Ty], [64 | 0]]; +var ScannedResource = [3, n0, _SRc, 0, [_RT, _RI, _MBS], [0, 128 | 0, 2]]; +var ScannedResourceIdentifier = [3, n0, _SRIc, 0, [_RT, _RI], [0, 128 | 0]]; +var SetStackPolicyInput = [3, n0, _SSPI, 0, [_SN, _SPB, _SPURL], [0, 0, 0]]; +var SetTypeConfigurationInput = [ + 3, + n0, + _STCI, + 0, + [_TA, _Co, _CAon, _TN, _T], + [0, 0, 0, 0, 0], +]; +var SetTypeConfigurationOutput = [3, n0, _STCO, 0, [_CAonf], [0]]; +var SetTypeDefaultVersionInput = [3, n0, _STDVI, 0, [_A, _T, _TN, _VI], [0, 0, 0, 0]]; +var SetTypeDefaultVersionOutput = [3, n0, _STDVO, 0, [], []]; +var SignalResourceInput = [3, n0, _SRIi, 0, [_SN, _LRI, _UI, _S], [0, 0, 0, 0]]; +var Stack = [ + 3, + n0, + _Sta, + 0, + [ + _SI, + _SN, + _CSI, + _D, + _P, + _CT, + _DTel, + _LUT, + _RCo, + _SSta, + _SSR, + _DR, + _NARN, + _TIM, + _Ca, + _Ou, + _RARN, + _Ta, + _ETP, + _PIa, + _RIo, + _DI, + _REOC, + _DMe, + _DSet, + _LO, + ], + [ + 0, + 0, + 0, + 0, + () => _Parameters, + 4, + 4, + 4, + () => RollbackConfiguration, + 0, + 0, + 2, + 64 | 0, + 1, + 64 | 0, + () => Outputs, + 0, + () => Tags, + 2, + 0, + 0, + () => StackDriftInformation, + 2, + 0, + 0, + () => LastOperations, + ], +]; +var StackDefinition = [3, n0, _SDt, 0, [_SN, _TB, _TURL], [0, 0, 0]]; +var StackDriftInformation = [3, n0, _SDI, 0, [_SDS, _LCT], [0, 4]]; +var StackDriftInformationSummary = [3, n0, _SDIS, 0, [_SDS, _LCT], [0, 4]]; +var StackEvent = [ + 3, + n0, + _SEt, + 0, + [_SI, _EI, _SN, _OI, _LRI, _PRI, _RT, _Ti, _RSes, _RSR, _RP, _CRT, _HTo, _HS, _HSR, _HIP, _HII, _HFM, _DSet], + [0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], +]; +var StackInstance = [ + 3, + n0, + _SIt, + 0, + [_SSI, _Reg, _Acc, _SI, _PO, _S, _SIS, _SR, _OUIr, _DSr, _LDCT, _LOI], + [0, 0, 0, 0, () => _Parameters, 0, () => StackInstanceComprehensiveStatus, 0, 0, 0, 4, 0], +]; +var StackInstanceComprehensiveStatus = [3, n0, _SICS, 0, [_DSet], [0]]; +var StackInstanceFilter = [3, n0, _SIF, 0, [_N, _Va], [0, 0]]; +var StackInstanceNotFoundException = [ + -3, + n0, + _SINFE, + { + [_e]: _c, + [_hE]: 404, + [_aQE]: [`StackInstanceNotFoundException`, 404], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(StackInstanceNotFoundException, StackInstanceNotFoundException$1); +var StackInstanceResourceDriftsSummary = [ + 3, + n0, + _SIRDSt, + 0, + [_SI, _LRI, _PRI, _PRIC, _RT, _PDro, _SRDS, _Ti], + [0, 0, 0, () => PhysicalResourceIdContext, 0, () => PropertyDifferences, 0, 4], +]; +var StackInstanceSummary = [ + 3, + n0, + _SISt, + 0, + [_SSI, _Reg, _Acc, _SI, _S, _SR, _SIS, _OUIr, _DSr, _LDCT, _LOI], + [0, 0, 0, 0, 0, 0, () => StackInstanceComprehensiveStatus, 0, 0, 4, 0], +]; +var StackNotFoundException = [ + -3, + n0, + _SNFE, + { + [_e]: _c, + [_hE]: 404, + [_aQE]: [`StackNotFoundException`, 404], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(StackNotFoundException, StackNotFoundException$1); +var StackRefactorAction = [ + 3, + n0, + _SRAt, + 0, + [_Act, _En, _PRI, _RI, _D, _Det, _DRe, _TR, _UR, _RMeso], + [0, 0, 0, 0, 0, 0, 0, () => StackRefactorTagResources, 64 | 0, () => ResourceMapping], +]; +var StackRefactorNotFoundException = [ + -3, + n0, + _SRNFE, + { + [_e]: _c, + [_hE]: 404, + [_aQE]: [`StackRefactorNotFoundException`, 404], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(StackRefactorNotFoundException, StackRefactorNotFoundException$1); +var StackRefactorSummary = [ + 3, + n0, + _SRSta, + 0, + [_SRI, _D, _ES, _ESR, _S, _SR], + [0, 0, 0, 0, 0, 0], +]; +var StackResource = [ + 3, + n0, + _SRta, + 0, + [_SN, _SI, _LRI, _PRI, _RT, _Ti, _RSes, _RSR, _D, _DI, _MI], + [0, 0, 0, 0, 0, 4, 0, 0, 0, () => StackResourceDriftInformation, () => ModuleInfo], +]; +var StackResourceDetail = [ + 3, + n0, + _SRDt, + 0, + [_SN, _SI, _LRI, _PRI, _RT, _LUTa, _RSes, _RSR, _D, _Me, _DI, _MI], + [0, 0, 0, 0, 0, 4, 0, 0, 0, 0, () => StackResourceDriftInformation, () => ModuleInfo], +]; +var StackResourceDrift = [ + 3, + n0, + _SRDta, + 0, + [_SI, _LRI, _PRI, _PRIC, _RT, _EP, _AP, _PDro, _SRDS, _Ti, _MI, _DSRr], + [0, 0, 0, () => PhysicalResourceIdContext, 0, 0, 0, () => PropertyDifferences, 0, 4, () => ModuleInfo, 0], +]; +var StackResourceDriftInformation = [3, n0, _SRDI, 0, [_SRDS, _LCT], [0, 4]]; +var StackResourceDriftInformationSummary = [3, n0, _SRDIS, 0, [_SRDS, _LCT], [0, 4]]; +var StackResourceSummary = [ + 3, + n0, + _SRStac, + 0, + [_LRI, _PRI, _RT, _LUTa, _RSes, _RSR, _DI, _MI], + [0, 0, 0, 4, 0, 0, () => StackResourceDriftInformationSummary, () => ModuleInfo], +]; +var StackSet = [ + 3, + n0, + _SS, + 0, + [_SSN, _SSI, _D, _S, _TB, _P, _Ca, _Ta, _SSARN, _ARARN, _ERN, _SSDDD, _AD, _PM, _OUI, _ME, _Re], + [ + 0, + 0, + 0, + 0, + 0, + () => _Parameters, + 64 | 0, + () => Tags, + 0, + 0, + 0, + () => StackSetDriftDetectionDetails, + () => AutoDeployment, + 0, + 64 | 0, + () => ManagedExecution, + 64 | 0, + ], +]; +var StackSetAutoDeploymentTargetSummary = [3, n0, _SSADTS, 0, [_OUIr, _Re], [0, 64 | 0]]; +var StackSetDriftDetectionDetails = [ + 3, + n0, + _SSDDD, + 0, + [_DSr, _DDS, _LDCT, _TSIC, _DSIC, _ISSIC, _IPSIC, _FSIC], + [0, 0, 4, 1, 1, 1, 1, 1], +]; +var StackSetNotEmptyException = [ + -3, + n0, + _SSNEE, + { + [_e]: _c, + [_hE]: 409, + [_aQE]: [`StackSetNotEmptyException`, 409], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(StackSetNotEmptyException, StackSetNotEmptyException$1); +var StackSetNotFoundException = [ + -3, + n0, + _SSNFE, + { + [_e]: _c, + [_hE]: 404, + [_aQE]: [`StackSetNotFoundException`, 404], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(StackSetNotFoundException, StackSetNotFoundException$1); +var StackSetOperation = [ + 3, + n0, + _SSO, + 0, + [_OI, _SSI, _Act, _S, _OP, _RS, _ARARN, _ERN, _CTr, _ETn, _DT, _SSDDD, _SR, _SDta], + [ + 0, + 0, + 0, + 0, + () => StackSetOperationPreferences, + 2, + 0, + 0, + 4, + 4, + () => DeploymentTargets, + () => StackSetDriftDetectionDetails, + 0, + () => StackSetOperationStatusDetails, + ], +]; +var StackSetOperationPreferences = [ + 3, + n0, + _SSOP, + 0, + [_RCT, _RO, _FTC, _FTP, _MCC, _MCP, _CM], + [0, 64 | 0, 1, 1, 1, 1, 0], +]; +var StackSetOperationResultSummary = [ + 3, + n0, + _SSORS, + 0, + [_Acc, _Reg, _S, _SR, _AGR, _OUIr], + [0, 0, 0, 0, () => AccountGateResult, 0], +]; +var StackSetOperationStatusDetails = [3, n0, _SSOSD, 0, [_FSIC], [1]]; +var StackSetOperationSummary = [ + 3, + n0, + _SSOS, + 0, + [_OI, _Act, _S, _CTr, _ETn, _SR, _SDta, _OP], + [0, 0, 0, 4, 4, 0, () => StackSetOperationStatusDetails, () => StackSetOperationPreferences], +]; +var StackSetSummary = [ + 3, + n0, + _SSS, + 0, + [_SSN, _SSI, _D, _S, _AD, _PM, _DSr, _LDCT, _ME], + [0, 0, 0, 0, () => AutoDeployment, 0, 0, 4, () => ManagedExecution], +]; +var StackSummary = [ + 3, + n0, + _SStac, + 0, + [_SI, _SN, _TDe, _CT, _LUT, _DTel, _SSta, _SSR, _PIa, _RIo, _DI, _LO], + [0, 0, 0, 4, 4, 4, 0, 0, 0, 0, () => StackDriftInformationSummary, () => LastOperations], +]; +var StaleRequestException = [ + -3, + n0, + _SRE, + { + [_e]: _c, + [_hE]: 409, + [_aQE]: [`StaleRequestException`, 409], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(StaleRequestException, StaleRequestException$1); +var StartResourceScanInput = [3, n0, _SRSI, 0, [_CRT, _SF], [0, () => ScanFilters]]; +var StartResourceScanOutput = [3, n0, _SRSO, 0, [_RSI], [0]]; +var StopStackSetOperationInput = [3, n0, _SSSOI, 0, [_SSN, _OI, _CA], [0, 0, 0]]; +var StopStackSetOperationOutput = [3, n0, _SSSOO, 0, [], []]; +var Tag = [3, n0, _Tag, 0, [_K, _V], [0, 0]]; +var TemplateConfiguration = [3, n0, _TCe, 0, [_DP, _URP], [0, 0]]; +var TemplateParameter = [3, n0, _TP, 0, [_PK, _DV, _NE, _D], [0, 0, 2, 0]]; +var TemplateProgress = [3, n0, _TPe, 0, [_RSeso, _RF, _RPe, _RPes], [1, 1, 1, 1]]; +var TemplateSummary = [ + 3, + n0, + _TSe, + 0, + [_GTI, _GTN, _S, _SR, _CT, _LUT, _NOR], + [0, 0, 0, 0, 4, 4, 1], +]; +var TemplateSummaryConfig = [3, n0, _TSC, 0, [_TURTAW], [2]]; +var TestTypeInput = [3, n0, _TTI, 0, [_A, _T, _TN, _VI, _LDB], [0, 0, 0, 0, 0]]; +var TestTypeOutput = [3, n0, _TTO, 0, [_TVA], [0]]; +var TokenAlreadyExistsException = [ + -3, + n0, + _TAEE, + { + [_e]: _c, + [_hE]: 400, + [_aQE]: [`TokenAlreadyExistsException`, 400], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(TokenAlreadyExistsException, TokenAlreadyExistsException$1); +var TypeConfigurationDetails = [ + 3, + n0, + _TCD, + 0, + [_A, _Al, _Co, _LU, _TA, _TN, _IDC], + [0, 0, 0, 4, 0, 0, 2], +]; +var TypeConfigurationIdentifier = [ + 3, + n0, + _TCI, + 0, + [_TA, _TCA, _TCAy, _T, _TN], + [0, 0, 0, 0, 0], +]; +var TypeConfigurationNotFoundException = [ + -3, + n0, + _TCNFE, + { + [_e]: _c, + [_hE]: 404, + [_aQE]: [`TypeConfigurationNotFoundException`, 404], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(TypeConfigurationNotFoundException, TypeConfigurationNotFoundException$1); +var TypeFilters = [3, n0, _TF, 0, [_Cat, _PI, _TNP], [0, 0, 0]]; +var TypeNotFoundException = [ + -3, + n0, + _TNFE, + { + [_e]: _c, + [_hE]: 404, + [_aQE]: [`TypeNotFoundException`, 404], + }, + [_M], + [0], +]; +schema.TypeRegistry.for(n0).registerError(TypeNotFoundException, TypeNotFoundException$1); +var TypeSummary = [ + 3, + n0, + _TSyp, + 0, + [_T, _TN, _DVI, _TA, _LU, _D, _PI, _OTN, _PVN, _LPV, _PIu, _PN, _IA], + [0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 2], +]; +var TypeVersionSummary = [ + 3, + n0, + _TVSy, + 0, + [_T, _TN, _VI, _IDV, _A, _TCi, _D, _PVN], + [0, 0, 0, 2, 0, 4, 0, 0], +]; +var UpdateGeneratedTemplateInput = [ + 3, + n0, + _UGTI, + 0, + [_GTN, _NGTN, _AR, _RRem, _RAR, _TCe], + [0, 0, () => ResourceDefinitions, 64 | 0, 2, () => TemplateConfiguration], +]; +var UpdateGeneratedTemplateOutput = [3, n0, _UGTO, 0, [_GTI], [0]]; +var UpdateStackInput = [ + 3, + n0, + _USI, + 0, + [_SN, _TB, _TURL, _UPT, _SPDUB, _SPDUURL, _P, _Ca, _RTe, _RARN, _RCo, _SPB, _SPURL, _NARN, _Ta, _DR, _CRT, _REOC], + [ + 0, + 0, + 0, + 2, + 0, + 0, + () => _Parameters, + 64 | 0, + 64 | 0, + 0, + () => RollbackConfiguration, + 0, + 0, + 64 | 0, + () => Tags, + 2, + 0, + 2, + ], +]; +var UpdateStackInstancesInput = [ + 3, + n0, + _USII, + 0, + [_SSN, _Ac, _DT, _Re, _PO, _OP, _OI, _CA], + [0, 64 | 0, () => DeploymentTargets, 64 | 0, () => _Parameters, () => StackSetOperationPreferences, [0, 4], 0], +]; +var UpdateStackInstancesOutput = [3, n0, _USIO, 0, [_OI], [0]]; +var UpdateStackOutput = [3, n0, _USO, 0, [_SI, _OI], [0, 0]]; +var UpdateStackSetInput = [ + 3, + n0, + _USSI, + 0, + [_SSN, _D, _TB, _TURL, _UPT, _P, _Ca, _Ta, _OP, _ARARN, _ERN, _DT, _PM, _AD, _OI, _Ac, _Re, _CA, _ME], + [ + 0, + 0, + 0, + 0, + 2, + () => _Parameters, + 64 | 0, + () => Tags, + () => StackSetOperationPreferences, + 0, + 0, + () => DeploymentTargets, + 0, + () => AutoDeployment, + [0, 4], + 64 | 0, + 64 | 0, + 0, + () => ManagedExecution, + ], +]; +var UpdateStackSetOutput = [3, n0, _USSO, 0, [_OI], [0]]; +var UpdateTerminationProtectionInput = [3, n0, _UTPI, 0, [_ETP, _SN], [2, 0]]; +var UpdateTerminationProtectionOutput = [3, n0, _UTPO, 0, [_SI], [0]]; +var ValidateTemplateInput = [3, n0, _VTI, 0, [_TB, _TURL], [0, 0]]; +var ValidateTemplateOutput = [ + 3, + n0, + _VTO, + 0, + [_P, _D, _Ca, _CR, _DTe], + [() => TemplateParameters, 0, 64 | 0, 0, 64 | 0], +]; +var WarningDetail = [3, n0, _WD, 0, [_T, _Pro], [0, () => WarningProperties]]; +var WarningProperty = [3, n0, _WP, 0, [_PPr, _Req, _D], [0, 2, 0]]; +var Warnings = [3, n0, _W, 0, [_URT], [64 | 0]]; +var __Unit = "unit"; +var CloudFormationServiceException = [-3, _s, "CloudFormationServiceException", 0, [], []]; +schema.TypeRegistry.for(_s).registerError(CloudFormationServiceException, CloudFormationServiceException$1); +var AccountLimitList = [1, n0, _ALL, 0, () => AccountLimit]; +var AnnotationList = [1, n0, _ALn, 0, () => Annotation]; +var BatchDescribeTypeConfigurationsErrors = [ + 1, + n0, + _BDTCEa, + 0, + () => BatchDescribeTypeConfigurationsError, +]; +var Changes = [1, n0, _Ch, 0, () => Change]; +var ChangeSetHooks = [1, n0, _CSHh, 0, () => ChangeSetHook]; +var ChangeSetSummaries = [1, n0, _CSSh, 0, () => ChangeSetSummary]; +var Exports = [1, n0, _Exp, 0, () => Export]; +var HookResultSummaries = [1, n0, _HRSo, 0, () => HookResultSummary]; +var LastOperations = [1, n0, _LO, 0, () => OperationEntry]; +var OperationEvents = [1, n0, _OE, 0, () => OperationEvent]; +var OperationResultFilters = [1, n0, _ORFp, 0, () => OperationResultFilter]; +var Outputs = [1, n0, _Ou, 0, () => Output]; +var ParameterDeclarations = [1, n0, _PDa, 0, () => ParameterDeclaration]; +var _Parameters = [1, n0, _P, 0, () => Parameter]; +var PhysicalResourceIdContext = [1, n0, _PRIC, 0, () => PhysicalResourceIdContextKeyValuePair]; +var PropertyDifferences = [1, n0, _PDro, 0, () => PropertyDifference]; +var RelatedResources = [1, n0, _RRel, 0, () => ScannedResource]; +var RequiredActivatedTypes = [1, n0, _RAT, 0, () => RequiredActivatedType]; +var ResourceChangeDetails = [1, n0, _RCDe, 0, () => ResourceChangeDetail]; +var ResourceDefinitions = [1, n0, _RDes, 0, () => ResourceDefinition]; +var ResourceDetails = [1, n0, _RDeso, 0, () => ResourceDetail]; +var ResourceDriftIgnoredAttributes = [1, n0, _RDIA, 0, () => ResourceDriftIgnoredAttribute]; +var ResourceIdentifierSummaries = [1, n0, _RIS, 0, () => ResourceIdentifierSummary]; +var ResourceMappings = [1, n0, _RMe, 0, () => ResourceMapping]; +var ResourceScanSummaries = [1, n0, _RSS, 0, () => ResourceScanSummary]; +var ResourcesToImport = [1, n0, _RTI, 0, () => ResourceToImport]; +var RollbackTriggers = [1, n0, _RTo, 0, () => RollbackTrigger]; +var ScanFilters = [1, n0, _SF, 0, () => ScanFilter]; +var ScannedResourceIdentifiers = [1, n0, _SRIca, 0, () => ScannedResourceIdentifier]; +var ScannedResources = [1, n0, _SRca, 0, () => ScannedResource]; +var StackDefinitions = [1, n0, _SD, 0, () => StackDefinition]; +var StackEvents = [1, n0, _SE, 0, () => StackEvent]; +var StackInstanceFilters = [1, n0, _SIFt, 0, () => StackInstanceFilter]; +var StackInstanceResourceDriftsSummaries = [ + 1, + n0, + _SIRDSta, + 0, + () => StackInstanceResourceDriftsSummary, +]; +var StackInstanceSummaries = [1, n0, _SISta, 0, () => StackInstanceSummary]; +var StackRefactorActions = [1, n0, _SRA, 0, () => StackRefactorAction]; +var StackRefactorSummaries = [1, n0, _SRS, 0, () => StackRefactorSummary]; +var StackRefactorTagResources = [1, n0, _SRTR, 0, () => Tag]; +var StackResourceDrifts = [1, n0, _SRD, 0, () => StackResourceDrift]; +var StackResources = [1, n0, _SRt, 0, () => StackResource]; +var StackResourceSummaries = [1, n0, _SRSt, 0, () => StackResourceSummary]; +var Stacks = [1, n0, _St, 0, () => Stack]; +var StackSetAutoDeploymentTargetSummaries = [ + 1, + n0, + _SSADTSt, + 0, + () => StackSetAutoDeploymentTargetSummary, +]; +var StackSetOperationResultSummaries = [ + 1, + n0, + _SSORSt, + 0, + () => StackSetOperationResultSummary, +]; +var StackSetOperationSummaries = [1, n0, _SSOSt, 0, () => StackSetOperationSummary]; +var StackSetSummaries = [1, n0, _SSSt, 0, () => StackSetSummary]; +var StackSummaries = [1, n0, _SSt, 0, () => StackSummary]; +var Tags = [1, n0, _Ta, 0, () => Tag]; +var TemplateParameters = [1, n0, _TPem, 0, () => TemplateParameter]; +var TemplateSummaries = [1, n0, _TSem, 0, () => TemplateSummary]; +var TypeConfigurationDetailsList = [1, n0, _TCDL, 0, () => TypeConfigurationDetails]; +var TypeConfigurationIdentifiers = [1, n0, _TCIy, 0, () => TypeConfigurationIdentifier]; +var TypeSummaries = [1, n0, _TSy, 0, () => TypeSummary]; +var TypeVersionSummaries = [1, n0, _TVS, 0, () => TypeVersionSummary]; +var UnprocessedTypeConfigurations = [1, n0, _UTC, 0, () => TypeConfigurationIdentifier]; +var WarningDetails = [1, n0, _WDa, 0, () => WarningDetail]; +var WarningProperties = [1, n0, _WPa, 0, () => WarningProperty]; +var ActivateOrganizationsAccess = [ + 9, + n0, + _AOA, + 0, + () => ActivateOrganizationsAccessInput, + () => ActivateOrganizationsAccessOutput, +]; +var ActivateType = [9, n0, _AT, 2, () => ActivateTypeInput, () => ActivateTypeOutput]; +var BatchDescribeTypeConfigurations = [ + 9, + n0, + _BDTC, + 0, + () => BatchDescribeTypeConfigurationsInput, + () => BatchDescribeTypeConfigurationsOutput, +]; +var CancelUpdateStack = [9, n0, _CUS, 0, () => CancelUpdateStackInput, () => __Unit]; +var ContinueUpdateRollback = [ + 9, + n0, + _CUR, + 0, + () => ContinueUpdateRollbackInput, + () => ContinueUpdateRollbackOutput, +]; +var CreateChangeSet = [ + 9, + n0, + _CCS, + 0, + () => CreateChangeSetInput, + () => CreateChangeSetOutput, +]; +var CreateGeneratedTemplate = [ + 9, + n0, + _CGT, + 0, + () => CreateGeneratedTemplateInput, + () => CreateGeneratedTemplateOutput, +]; +var CreateStack = [9, n0, _CSr, 0, () => CreateStackInput, () => CreateStackOutput]; +var CreateStackInstances = [ + 9, + n0, + _CSIre, + 0, + () => CreateStackInstancesInput, + () => CreateStackInstancesOutput, +]; +var CreateStackRefactor = [ + 9, + n0, + _CSR, + 0, + () => CreateStackRefactorInput, + () => CreateStackRefactorOutput, +]; +var CreateStackSet = [ + 9, + n0, + _CSSr, + 0, + () => CreateStackSetInput, + () => CreateStackSetOutput, +]; +var DeactivateOrganizationsAccess = [ + 9, + n0, + _DOA, + 0, + () => DeactivateOrganizationsAccessInput, + () => DeactivateOrganizationsAccessOutput, +]; +var DeactivateType = [ + 9, + n0, + _DTea, + 2, + () => DeactivateTypeInput, + () => DeactivateTypeOutput, +]; +var DeleteChangeSet = [ + 9, + n0, + _DCS, + 0, + () => DeleteChangeSetInput, + () => DeleteChangeSetOutput, +]; +var DeleteGeneratedTemplate = [ + 9, + n0, + _DGT, + 0, + () => DeleteGeneratedTemplateInput, + () => __Unit, +]; +var DeleteStack = [9, n0, _DSel, 0, () => DeleteStackInput, () => __Unit]; +var DeleteStackInstances = [ + 9, + n0, + _DSIel, + 0, + () => DeleteStackInstancesInput, + () => DeleteStackInstancesOutput, +]; +var DeleteStackSet = [ + 9, + n0, + _DSS, + 0, + () => DeleteStackSetInput, + () => DeleteStackSetOutput, +]; +var DeregisterType = [ + 9, + n0, + _DTer, + 2, + () => DeregisterTypeInput, + () => DeregisterTypeOutput, +]; +var DescribeAccountLimits = [ + 9, + n0, + _DAL, + 0, + () => DescribeAccountLimitsInput, + () => DescribeAccountLimitsOutput, +]; +var DescribeChangeSet = [ + 9, + n0, + _DCSe, + 0, + () => DescribeChangeSetInput, + () => DescribeChangeSetOutput, +]; +var DescribeChangeSetHooks = [ + 9, + n0, + _DCSH, + 0, + () => DescribeChangeSetHooksInput, + () => DescribeChangeSetHooksOutput, +]; +var DescribeEvents = [ + 9, + n0, + _DE, + 0, + () => DescribeEventsInput, + () => DescribeEventsOutput, +]; +var DescribeGeneratedTemplate = [ + 9, + n0, + _DGTe, + 0, + () => DescribeGeneratedTemplateInput, + () => DescribeGeneratedTemplateOutput, +]; +var DescribeOrganizationsAccess = [ + 9, + n0, + _DOAe, + 0, + () => DescribeOrganizationsAccessInput, + () => DescribeOrganizationsAccessOutput, +]; +var DescribePublisher = [ + 9, + n0, + _DPe, + 2, + () => DescribePublisherInput, + () => DescribePublisherOutput, +]; +var DescribeResourceScan = [ + 9, + n0, + _DRS, + 0, + () => DescribeResourceScanInput, + () => DescribeResourceScanOutput, +]; +var DescribeStackDriftDetectionStatus = [ + 9, + n0, + _DSDDS, + 0, + () => DescribeStackDriftDetectionStatusInput, + () => DescribeStackDriftDetectionStatusOutput, +]; +var DescribeStackEvents = [ + 9, + n0, + _DSE, + 0, + () => DescribeStackEventsInput, + () => DescribeStackEventsOutput, +]; +var DescribeStackInstance = [ + 9, + n0, + _DSIes, + 0, + () => DescribeStackInstanceInput, + () => DescribeStackInstanceOutput, +]; +var DescribeStackRefactor = [ + 9, + n0, + _DSRe, + 0, + () => DescribeStackRefactorInput, + () => DescribeStackRefactorOutput, +]; +var DescribeStackResource = [ + 9, + n0, + _DSRes, + 0, + () => DescribeStackResourceInput, + () => DescribeStackResourceOutput, +]; +var DescribeStackResourceDrifts = [ + 9, + n0, + _DSRD, + 0, + () => DescribeStackResourceDriftsInput, + () => DescribeStackResourceDriftsOutput, +]; +var DescribeStackResources = [ + 9, + n0, + _DSResc, + 0, + () => DescribeStackResourcesInput, + () => DescribeStackResourcesOutput, +]; +var DescribeStacks = [ + 9, + n0, + _DSes, + 0, + () => DescribeStacksInput, + () => DescribeStacksOutput, +]; +var DescribeStackSet = [ + 9, + n0, + _DSSe, + 0, + () => DescribeStackSetInput, + () => DescribeStackSetOutput, +]; +var DescribeStackSetOperation = [ + 9, + n0, + _DSSOes, + 0, + () => DescribeStackSetOperationInput, + () => DescribeStackSetOperationOutput, +]; +var DescribeType = [9, n0, _DTes, 2, () => DescribeTypeInput, () => DescribeTypeOutput]; +var DescribeTypeRegistration = [ + 9, + n0, + _DTR, + 2, + () => DescribeTypeRegistrationInput, + () => DescribeTypeRegistrationOutput, +]; +var DetectStackDrift = [ + 9, + n0, + _DSD, + 0, + () => DetectStackDriftInput, + () => DetectStackDriftOutput, +]; +var DetectStackResourceDrift = [ + 9, + n0, + _DSRDe, + 0, + () => DetectStackResourceDriftInput, + () => DetectStackResourceDriftOutput, +]; +var DetectStackSetDrift = [ + 9, + n0, + _DSSD, + 0, + () => DetectStackSetDriftInput, + () => DetectStackSetDriftOutput, +]; +var EstimateTemplateCost = [ + 9, + n0, + _ETC, + 0, + () => EstimateTemplateCostInput, + () => EstimateTemplateCostOutput, +]; +var ExecuteChangeSet = [ + 9, + n0, + _ECS, + 0, + () => ExecuteChangeSetInput, + () => ExecuteChangeSetOutput, +]; +var ExecuteStackRefactor = [ + 9, + n0, + _ESRx, + 0, + () => ExecuteStackRefactorInput, + () => __Unit, +]; +var GetGeneratedTemplate = [ + 9, + n0, + _GGT, + 0, + () => GetGeneratedTemplateInput, + () => GetGeneratedTemplateOutput, +]; +var GetHookResult = [9, n0, _GHR, 0, () => GetHookResultInput, () => GetHookResultOutput]; +var GetStackPolicy = [ + 9, + n0, + _GSP, + 0, + () => GetStackPolicyInput, + () => GetStackPolicyOutput, +]; +var GetTemplate = [9, n0, _GT, 0, () => GetTemplateInput, () => GetTemplateOutput]; +var GetTemplateSummary = [ + 9, + n0, + _GTS, + 0, + () => GetTemplateSummaryInput, + () => GetTemplateSummaryOutput, +]; +var ImportStacksToStackSet = [ + 9, + n0, + _ISTSS, + 0, + () => ImportStacksToStackSetInput, + () => ImportStacksToStackSetOutput, +]; +var ListChangeSets = [ + 9, + n0, + _LCS, + 0, + () => ListChangeSetsInput, + () => ListChangeSetsOutput, +]; +var ListExports = [9, n0, _LE, 0, () => ListExportsInput, () => ListExportsOutput]; +var ListGeneratedTemplates = [ + 9, + n0, + _LGT, + 0, + () => ListGeneratedTemplatesInput, + () => ListGeneratedTemplatesOutput, +]; +var ListHookResults = [ + 9, + n0, + _LHR, + 0, + () => ListHookResultsInput, + () => ListHookResultsOutput, +]; +var ListImports = [9, n0, _LI, 0, () => ListImportsInput, () => ListImportsOutput]; +var ListResourceScanRelatedResources = [ + 9, + n0, + _LRSRR, + 0, + () => ListResourceScanRelatedResourcesInput, + () => ListResourceScanRelatedResourcesOutput, +]; +var ListResourceScanResources = [ + 9, + n0, + _LRSR, + 0, + () => ListResourceScanResourcesInput, + () => ListResourceScanResourcesOutput, +]; +var ListResourceScans = [ + 9, + n0, + _LRS, + 0, + () => ListResourceScansInput, + () => ListResourceScansOutput, +]; +var ListStackInstanceResourceDrifts = [ + 9, + n0, + _LSIRD, + 0, + () => ListStackInstanceResourceDriftsInput, + () => ListStackInstanceResourceDriftsOutput, +]; +var ListStackInstances = [ + 9, + n0, + _LSIi, + 0, + () => ListStackInstancesInput, + () => ListStackInstancesOutput, +]; +var ListStackRefactorActions = [ + 9, + n0, + _LSRA, + 0, + () => ListStackRefactorActionsInput, + () => ListStackRefactorActionsOutput, +]; +var ListStackRefactors = [ + 9, + n0, + _LSR, + 0, + () => ListStackRefactorsInput, + () => ListStackRefactorsOutput, +]; +var ListStackResources = [ + 9, + n0, + _LSRi, + 0, + () => ListStackResourcesInput, + () => ListStackResourcesOutput, +]; +var ListStacks = [9, n0, _LS, 0, () => ListStacksInput, () => ListStacksOutput]; +var ListStackSetAutoDeploymentTargets = [ + 9, + n0, + _LSSADT, + 0, + () => ListStackSetAutoDeploymentTargetsInput, + () => ListStackSetAutoDeploymentTargetsOutput, +]; +var ListStackSetOperationResults = [ + 9, + n0, + _LSSOR, + 0, + () => ListStackSetOperationResultsInput, + () => ListStackSetOperationResultsOutput, +]; +var ListStackSetOperations = [ + 9, + n0, + _LSSOi, + 0, + () => ListStackSetOperationsInput, + () => ListStackSetOperationsOutput, +]; +var ListStackSets = [9, n0, _LSS, 0, () => ListStackSetsInput, () => ListStackSetsOutput]; +var ListTypeRegistrations = [ + 9, + n0, + _LTR, + 2, + () => ListTypeRegistrationsInput, + () => ListTypeRegistrationsOutput, +]; +var ListTypes = [9, n0, _LT, 2, () => ListTypesInput, () => ListTypesOutput]; +var ListTypeVersions = [ + 9, + n0, + _LTV, + 2, + () => ListTypeVersionsInput, + () => ListTypeVersionsOutput, +]; +var PublishType = [9, n0, _PTu, 2, () => PublishTypeInput, () => PublishTypeOutput]; +var RecordHandlerProgress = [ + 9, + n0, + _RHP, + 2, + () => RecordHandlerProgressInput, + () => RecordHandlerProgressOutput, +]; +var RegisterPublisher = [ + 9, + n0, + _RPeg, + 2, + () => RegisterPublisherInput, + () => RegisterPublisherOutput, +]; +var RegisterType = [9, n0, _RTegi, 2, () => RegisterTypeInput, () => RegisterTypeOutput]; +var RollbackStack = [9, n0, _RSo, 0, () => RollbackStackInput, () => RollbackStackOutput]; +var SetStackPolicy = [9, n0, _SSP, 0, () => SetStackPolicyInput, () => __Unit]; +var SetTypeConfiguration = [ + 9, + n0, + _STC, + 0, + () => SetTypeConfigurationInput, + () => SetTypeConfigurationOutput, +]; +var SetTypeDefaultVersion = [ + 9, + n0, + _STDV, + 2, + () => SetTypeDefaultVersionInput, + () => SetTypeDefaultVersionOutput, +]; +var SignalResource = [9, n0, _SRi, 0, () => SignalResourceInput, () => __Unit]; +var StartResourceScan = [ + 9, + n0, + _SRStar, + 0, + () => StartResourceScanInput, + () => StartResourceScanOutput, +]; +var StopStackSetOperation = [ + 9, + n0, + _SSSO, + 0, + () => StopStackSetOperationInput, + () => StopStackSetOperationOutput, +]; +var TestType = [9, n0, _TTe, 2, () => TestTypeInput, () => TestTypeOutput]; +var UpdateGeneratedTemplate = [ + 9, + n0, + _UGT, + 0, + () => UpdateGeneratedTemplateInput, + () => UpdateGeneratedTemplateOutput, +]; +var UpdateStack = [9, n0, _US, 0, () => UpdateStackInput, () => UpdateStackOutput]; +var UpdateStackInstances = [ + 9, + n0, + _USIp, + 0, + () => UpdateStackInstancesInput, + () => UpdateStackInstancesOutput, +]; +var UpdateStackSet = [ + 9, + n0, + _USS, + 0, + () => UpdateStackSetInput, + () => UpdateStackSetOutput, +]; +var UpdateTerminationProtection = [ + 9, + n0, + _UTP, + 0, + () => UpdateTerminationProtectionInput, + () => UpdateTerminationProtectionOutput, +]; +var ValidateTemplate = [ + 9, + n0, + _VT, + 0, + () => ValidateTemplateInput, + () => ValidateTemplateOutput, +]; - if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey); - else return false; - } +class ActivateOrganizationsAccessCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ActivateOrganizationsAccess", {}) + .n("CloudFormationClient", "ActivateOrganizationsAccessCommand") + .sc(ActivateOrganizationsAccess) + .build() { +} - return true; +class ActivateTypeCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ActivateType", {}) + .n("CloudFormationClient", "ActivateTypeCommand") + .sc(ActivateType) + .build() { } -function constructYamlOmap(data) { - return data !== null ? data : []; +class BatchDescribeTypeConfigurationsCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "BatchDescribeTypeConfigurations", {}) + .n("CloudFormationClient", "BatchDescribeTypeConfigurationsCommand") + .sc(BatchDescribeTypeConfigurations) + .build() { } -module.exports = new Type('tag:yaml.org,2002:omap', { - kind: 'sequence', - resolve: resolveYamlOmap, - construct: constructYamlOmap -}); - - -/***/ }), - -/***/ 848: -/***/ (function(module) { - -module.exports = {"pagination":{"ListDomains":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults","result_key":"domains"},"ListPackageVersionAssets":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults","result_key":"assets"},"ListPackageVersions":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults","result_key":"versions"},"ListPackages":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults","result_key":"packages"},"ListRepositories":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults","result_key":"repositories"},"ListRepositoriesInDomain":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults","result_key":"repositories"}}}; - -/***/ }), - -/***/ 858: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2015-07-01","endpointPrefix":"marketplacecommerceanalytics","jsonVersion":"1.1","protocol":"json","serviceFullName":"AWS Marketplace Commerce Analytics","serviceId":"Marketplace Commerce Analytics","signatureVersion":"v4","signingName":"marketplacecommerceanalytics","targetPrefix":"MarketplaceCommerceAnalytics20150701","uid":"marketplacecommerceanalytics-2015-07-01"},"operations":{"GenerateDataSet":{"input":{"type":"structure","required":["dataSetType","dataSetPublicationDate","roleNameArn","destinationS3BucketName","snsTopicArn"],"members":{"dataSetType":{},"dataSetPublicationDate":{"type":"timestamp"},"roleNameArn":{},"destinationS3BucketName":{},"destinationS3Prefix":{},"snsTopicArn":{},"customerDefinedValues":{"shape":"S8"}}},"output":{"type":"structure","members":{"dataSetRequestId":{}}}},"StartSupportDataExport":{"input":{"type":"structure","required":["dataSetType","fromDate","roleNameArn","destinationS3BucketName","snsTopicArn"],"members":{"dataSetType":{},"fromDate":{"type":"timestamp"},"roleNameArn":{},"destinationS3BucketName":{},"destinationS3Prefix":{},"snsTopicArn":{},"customerDefinedValues":{"shape":"S8"}}},"output":{"type":"structure","members":{"dataSetRequestId":{}}}}},"shapes":{"S8":{"type":"map","key":{},"value":{}}}}; - -/***/ }), - -/***/ 872: -/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) { - -var AWS = __webpack_require__(395); - -/** - * Represents credentials from the environment. - * - * By default, this class will look for the matching environment variables - * prefixed by a given {envPrefix}. The un-prefixed environment variable names - * for each credential value is listed below: - * - * ```javascript - * accessKeyId: ACCESS_KEY_ID - * secretAccessKey: SECRET_ACCESS_KEY - * sessionToken: SESSION_TOKEN - * ``` - * - * With the default prefix of 'AWS', the environment variables would be: - * - * AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_SESSION_TOKEN - * - * @!attribute envPrefix - * @readonly - * @return [String] the prefix for the environment variable names excluding - * the separating underscore ('_'). - */ -AWS.EnvironmentCredentials = AWS.util.inherit(AWS.Credentials, { - - /** - * Creates a new EnvironmentCredentials class with a given variable - * prefix {envPrefix}. For example, to load credentials using the 'AWS' - * prefix: - * - * ```javascript - * var creds = new AWS.EnvironmentCredentials('AWS'); - * creds.accessKeyId == 'AKID' // from AWS_ACCESS_KEY_ID env var - * ``` - * - * @param envPrefix [String] the prefix to use (e.g., 'AWS') for environment - * variables. Do not include the separating underscore. - */ - constructor: function EnvironmentCredentials(envPrefix) { - AWS.Credentials.call(this); - this.envPrefix = envPrefix; - this.get(function() {}); - }, +class CancelUpdateStackCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "CancelUpdateStack", {}) + .n("CloudFormationClient", "CancelUpdateStackCommand") + .sc(CancelUpdateStack) + .build() { +} - /** - * Loads credentials from the environment using the prefixed - * environment variables. - * - * @callback callback function(err) - * Called after the (prefixed) ACCESS_KEY_ID, SECRET_ACCESS_KEY, and - * SESSION_TOKEN environment variables are read. When this callback is - * called with no error, it means that the credentials information has - * been loaded into the object (as the `accessKeyId`, `secretAccessKey`, - * and `sessionToken` properties). - * @param err [Error] if an error occurred, this value will be filled - * @see get - */ - refresh: function refresh(callback) { - if (!callback) callback = AWS.util.fn.callback; - - if (!process || !process.env) { - callback(AWS.util.error( - new Error('No process info or environment variables available'), - { code: 'EnvironmentCredentialsProviderFailure' } - )); - return; - } +class ContinueUpdateRollbackCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ContinueUpdateRollback", {}) + .n("CloudFormationClient", "ContinueUpdateRollbackCommand") + .sc(ContinueUpdateRollback) + .build() { +} - var keys = ['ACCESS_KEY_ID', 'SECRET_ACCESS_KEY', 'SESSION_TOKEN']; - var values = []; +class CreateChangeSetCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "CreateChangeSet", {}) + .n("CloudFormationClient", "CreateChangeSetCommand") + .sc(CreateChangeSet) + .build() { +} - for (var i = 0; i < keys.length; i++) { - var prefix = ''; - if (this.envPrefix) prefix = this.envPrefix + '_'; - values[i] = process.env[prefix + keys[i]]; - if (!values[i] && keys[i] !== 'SESSION_TOKEN') { - callback(AWS.util.error( - new Error('Variable ' + prefix + keys[i] + ' not set.'), - { code: 'EnvironmentCredentialsProviderFailure' } - )); - return; - } - } +class CreateGeneratedTemplateCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "CreateGeneratedTemplate", {}) + .n("CloudFormationClient", "CreateGeneratedTemplateCommand") + .sc(CreateGeneratedTemplate) + .build() { +} - this.expired = false; - AWS.Credentials.apply(this, values); - callback(); - } +class CreateStackCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "CreateStack", {}) + .n("CloudFormationClient", "CreateStackCommand") + .sc(CreateStack) + .build() { +} -}); +class CreateStackInstancesCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "CreateStackInstances", {}) + .n("CloudFormationClient", "CreateStackInstancesCommand") + .sc(CreateStackInstances) + .build() { +} +class CreateStackRefactorCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "CreateStackRefactor", {}) + .n("CloudFormationClient", "CreateStackRefactorCommand") + .sc(CreateStackRefactor) + .build() { +} -/***/ }), +class CreateStackSetCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "CreateStackSet", {}) + .n("CloudFormationClient", "CreateStackSetCommand") + .sc(CreateStackSet) + .build() { +} -/***/ 877: -/***/ (function(module, __unusedexports, __webpack_require__) { +class DeactivateOrganizationsAccessCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DeactivateOrganizationsAccess", {}) + .n("CloudFormationClient", "DeactivateOrganizationsAccessCommand") + .sc(DeactivateOrganizationsAccess) + .build() { +} -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +class DeactivateTypeCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DeactivateType", {}) + .n("CloudFormationClient", "DeactivateTypeCommand") + .sc(DeactivateType) + .build() { +} -apiLoader.services['cloud9'] = {}; -AWS.Cloud9 = Service.defineService('cloud9', ['2017-09-23']); -Object.defineProperty(apiLoader.services['cloud9'], '2017-09-23', { - get: function get() { - var model = __webpack_require__(8656); - model.paginators = __webpack_require__(590).pagination; - return model; - }, - enumerable: true, - configurable: true -}); +class DeleteChangeSetCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DeleteChangeSet", {}) + .n("CloudFormationClient", "DeleteChangeSetCommand") + .sc(DeleteChangeSet) + .build() { +} -module.exports = AWS.Cloud9; +class DeleteGeneratedTemplateCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DeleteGeneratedTemplate", {}) + .n("CloudFormationClient", "DeleteGeneratedTemplateCommand") + .sc(DeleteGeneratedTemplate) + .build() { +} +class DeleteStackCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DeleteStack", {}) + .n("CloudFormationClient", "DeleteStackCommand") + .sc(DeleteStack) + .build() { +} -/***/ }), +class DeleteStackInstancesCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DeleteStackInstances", {}) + .n("CloudFormationClient", "DeleteStackInstancesCommand") + .sc(DeleteStackInstances) + .build() { +} -/***/ 887: -/***/ (function(module) { +class DeleteStackSetCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DeleteStackSet", {}) + .n("CloudFormationClient", "DeleteStackSetCommand") + .sc(DeleteStackSet) + .build() { +} -module.exports = {"version":"2.0","metadata":{"apiVersion":"2015-10-07","endpointPrefix":"events","jsonVersion":"1.1","protocol":"json","serviceFullName":"Amazon EventBridge","serviceId":"EventBridge","signatureVersion":"v4","targetPrefix":"AWSEvents","uid":"eventbridge-2015-10-07"},"operations":{"ActivateEventSource":{"input":{"type":"structure","required":["Name"],"members":{"Name":{}}}},"CreateEventBus":{"input":{"type":"structure","required":["Name"],"members":{"Name":{},"EventSourceName":{},"Tags":{"shape":"S5"}}},"output":{"type":"structure","members":{"EventBusArn":{}}}},"CreatePartnerEventSource":{"input":{"type":"structure","required":["Name","Account"],"members":{"Name":{},"Account":{}}},"output":{"type":"structure","members":{"EventSourceArn":{}}}},"DeactivateEventSource":{"input":{"type":"structure","required":["Name"],"members":{"Name":{}}}},"DeleteEventBus":{"input":{"type":"structure","required":["Name"],"members":{"Name":{}}}},"DeletePartnerEventSource":{"input":{"type":"structure","required":["Name","Account"],"members":{"Name":{},"Account":{}}}},"DeleteRule":{"input":{"type":"structure","required":["Name"],"members":{"Name":{},"EventBusName":{},"Force":{"type":"boolean"}}}},"DescribeEventBus":{"input":{"type":"structure","members":{"Name":{}}},"output":{"type":"structure","members":{"Name":{},"Arn":{},"Policy":{}}}},"DescribeEventSource":{"input":{"type":"structure","required":["Name"],"members":{"Name":{}}},"output":{"type":"structure","members":{"Arn":{},"CreatedBy":{},"CreationTime":{"type":"timestamp"},"ExpirationTime":{"type":"timestamp"},"Name":{},"State":{}}}},"DescribePartnerEventSource":{"input":{"type":"structure","required":["Name"],"members":{"Name":{}}},"output":{"type":"structure","members":{"Arn":{},"Name":{}}}},"DescribeRule":{"input":{"type":"structure","required":["Name"],"members":{"Name":{},"EventBusName":{}}},"output":{"type":"structure","members":{"Name":{},"Arn":{},"EventPattern":{},"ScheduleExpression":{},"State":{},"Description":{},"RoleArn":{},"ManagedBy":{},"EventBusName":{}}}},"DisableRule":{"input":{"type":"structure","required":["Name"],"members":{"Name":{},"EventBusName":{}}}},"EnableRule":{"input":{"type":"structure","required":["Name"],"members":{"Name":{},"EventBusName":{}}}},"ListEventBuses":{"input":{"type":"structure","members":{"NamePrefix":{},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"EventBuses":{"type":"list","member":{"type":"structure","members":{"Name":{},"Arn":{},"Policy":{}}}},"NextToken":{}}}},"ListEventSources":{"input":{"type":"structure","members":{"NamePrefix":{},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"EventSources":{"type":"list","member":{"type":"structure","members":{"Arn":{},"CreatedBy":{},"CreationTime":{"type":"timestamp"},"ExpirationTime":{"type":"timestamp"},"Name":{},"State":{}}}},"NextToken":{}}}},"ListPartnerEventSourceAccounts":{"input":{"type":"structure","required":["EventSourceName"],"members":{"EventSourceName":{},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"PartnerEventSourceAccounts":{"type":"list","member":{"type":"structure","members":{"Account":{},"CreationTime":{"type":"timestamp"},"ExpirationTime":{"type":"timestamp"},"State":{}}}},"NextToken":{}}}},"ListPartnerEventSources":{"input":{"type":"structure","required":["NamePrefix"],"members":{"NamePrefix":{},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"PartnerEventSources":{"type":"list","member":{"type":"structure","members":{"Arn":{},"Name":{}}}},"NextToken":{}}}},"ListRuleNamesByTarget":{"input":{"type":"structure","required":["TargetArn"],"members":{"TargetArn":{},"EventBusName":{},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"RuleNames":{"type":"list","member":{}},"NextToken":{}}}},"ListRules":{"input":{"type":"structure","members":{"NamePrefix":{},"EventBusName":{},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"Rules":{"type":"list","member":{"type":"structure","members":{"Name":{},"Arn":{},"EventPattern":{},"State":{},"Description":{},"ScheduleExpression":{},"RoleArn":{},"ManagedBy":{},"EventBusName":{}}}},"NextToken":{}}}},"ListTagsForResource":{"input":{"type":"structure","required":["ResourceARN"],"members":{"ResourceARN":{}}},"output":{"type":"structure","members":{"Tags":{"shape":"S5"}}}},"ListTargetsByRule":{"input":{"type":"structure","required":["Rule"],"members":{"Rule":{},"EventBusName":{},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"Targets":{"shape":"S20"},"NextToken":{}}}},"PutEvents":{"input":{"type":"structure","required":["Entries"],"members":{"Entries":{"type":"list","member":{"type":"structure","members":{"Time":{"type":"timestamp"},"Source":{},"Resources":{"shape":"S37"},"DetailType":{},"Detail":{},"EventBusName":{}}}}}},"output":{"type":"structure","members":{"FailedEntryCount":{"type":"integer"},"Entries":{"type":"list","member":{"type":"structure","members":{"EventId":{},"ErrorCode":{},"ErrorMessage":{}}}}}}},"PutPartnerEvents":{"input":{"type":"structure","required":["Entries"],"members":{"Entries":{"type":"list","member":{"type":"structure","members":{"Time":{"type":"timestamp"},"Source":{},"Resources":{"shape":"S37"},"DetailType":{},"Detail":{}}}}}},"output":{"type":"structure","members":{"FailedEntryCount":{"type":"integer"},"Entries":{"type":"list","member":{"type":"structure","members":{"EventId":{},"ErrorCode":{},"ErrorMessage":{}}}}}}},"PutPermission":{"input":{"type":"structure","required":["Action","Principal","StatementId"],"members":{"EventBusName":{},"Action":{},"Principal":{},"StatementId":{},"Condition":{"type":"structure","required":["Type","Key","Value"],"members":{"Type":{},"Key":{},"Value":{}}}}}},"PutRule":{"input":{"type":"structure","required":["Name"],"members":{"Name":{},"ScheduleExpression":{},"EventPattern":{},"State":{},"Description":{},"RoleArn":{},"Tags":{"shape":"S5"},"EventBusName":{}}},"output":{"type":"structure","members":{"RuleArn":{}}}},"PutTargets":{"input":{"type":"structure","required":["Rule","Targets"],"members":{"Rule":{},"EventBusName":{},"Targets":{"shape":"S20"}}},"output":{"type":"structure","members":{"FailedEntryCount":{"type":"integer"},"FailedEntries":{"type":"list","member":{"type":"structure","members":{"TargetId":{},"ErrorCode":{},"ErrorMessage":{}}}}}}},"RemovePermission":{"input":{"type":"structure","required":["StatementId"],"members":{"StatementId":{},"EventBusName":{}}}},"RemoveTargets":{"input":{"type":"structure","required":["Rule","Ids"],"members":{"Rule":{},"EventBusName":{},"Ids":{"type":"list","member":{}},"Force":{"type":"boolean"}}},"output":{"type":"structure","members":{"FailedEntryCount":{"type":"integer"},"FailedEntries":{"type":"list","member":{"type":"structure","members":{"TargetId":{},"ErrorCode":{},"ErrorMessage":{}}}}}}},"TagResource":{"input":{"type":"structure","required":["ResourceARN","Tags"],"members":{"ResourceARN":{},"Tags":{"shape":"S5"}}},"output":{"type":"structure","members":{}}},"TestEventPattern":{"input":{"type":"structure","required":["EventPattern","Event"],"members":{"EventPattern":{},"Event":{}}},"output":{"type":"structure","members":{"Result":{"type":"boolean"}}}},"UntagResource":{"input":{"type":"structure","required":["ResourceARN","TagKeys"],"members":{"ResourceARN":{},"TagKeys":{"type":"list","member":{}}}},"output":{"type":"structure","members":{}}}},"shapes":{"S5":{"type":"list","member":{"type":"structure","required":["Key","Value"],"members":{"Key":{},"Value":{}}}},"S20":{"type":"list","member":{"type":"structure","required":["Id","Arn"],"members":{"Id":{},"Arn":{},"RoleArn":{},"Input":{},"InputPath":{},"InputTransformer":{"type":"structure","required":["InputTemplate"],"members":{"InputPathsMap":{"type":"map","key":{},"value":{}},"InputTemplate":{}}},"KinesisParameters":{"type":"structure","required":["PartitionKeyPath"],"members":{"PartitionKeyPath":{}}},"RunCommandParameters":{"type":"structure","required":["RunCommandTargets"],"members":{"RunCommandTargets":{"type":"list","member":{"type":"structure","required":["Key","Values"],"members":{"Key":{},"Values":{"type":"list","member":{}}}}}}},"EcsParameters":{"type":"structure","required":["TaskDefinitionArn"],"members":{"TaskDefinitionArn":{},"TaskCount":{"type":"integer"},"LaunchType":{},"NetworkConfiguration":{"type":"structure","members":{"awsvpcConfiguration":{"type":"structure","required":["Subnets"],"members":{"Subnets":{"shape":"S2m"},"SecurityGroups":{"shape":"S2m"},"AssignPublicIp":{}}}}},"PlatformVersion":{},"Group":{}}},"BatchParameters":{"type":"structure","required":["JobDefinition","JobName"],"members":{"JobDefinition":{},"JobName":{},"ArrayProperties":{"type":"structure","members":{"Size":{"type":"integer"}}},"RetryStrategy":{"type":"structure","members":{"Attempts":{"type":"integer"}}}}},"SqsParameters":{"type":"structure","members":{"MessageGroupId":{}}},"HttpParameters":{"type":"structure","members":{"PathParameterValues":{"type":"list","member":{}},"HeaderParameters":{"type":"map","key":{},"value":{}},"QueryStringParameters":{"type":"map","key":{},"value":{}}}}}}},"S2m":{"type":"list","member":{}},"S37":{"type":"list","member":{}}}}; +class DeregisterTypeCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DeregisterType", {}) + .n("CloudFormationClient", "DeregisterTypeCommand") + .sc(DeregisterType) + .build() { +} -/***/ }), +class DescribeAccountLimitsCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DescribeAccountLimits", {}) + .n("CloudFormationClient", "DescribeAccountLimitsCommand") + .sc(DescribeAccountLimits) + .build() { +} -/***/ 889: -/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) { +class DescribeChangeSetCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DescribeChangeSet", {}) + .n("CloudFormationClient", "DescribeChangeSetCommand") + .sc(DescribeChangeSet) + .build() { +} -var AWS = __webpack_require__(395); +class DescribeChangeSetHooksCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DescribeChangeSetHooks", {}) + .n("CloudFormationClient", "DescribeChangeSetHooksCommand") + .sc(DescribeChangeSetHooks) + .build() { +} -AWS.util.update(AWS.SQS.prototype, { - /** - * @api private - */ - setupRequestListeners: function setupRequestListeners(request) { - request.addListener('build', this.buildEndpoint); +class DescribeEventsCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DescribeEvents", {}) + .n("CloudFormationClient", "DescribeEventsCommand") + .sc(DescribeEvents) + .build() { +} - if (request.service.config.computeChecksums) { - if (request.operation === 'sendMessage') { - request.addListener('extractData', this.verifySendMessageChecksum); - } else if (request.operation === 'sendMessageBatch') { - request.addListener('extractData', this.verifySendMessageBatchChecksum); - } else if (request.operation === 'receiveMessage') { - request.addListener('extractData', this.verifyReceiveMessageChecksum); - } - } - }, +class DescribeGeneratedTemplateCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DescribeGeneratedTemplate", {}) + .n("CloudFormationClient", "DescribeGeneratedTemplateCommand") + .sc(DescribeGeneratedTemplate) + .build() { +} - /** - * @api private - */ - verifySendMessageChecksum: function verifySendMessageChecksum(response) { - if (!response.data) return; - - var md5 = response.data.MD5OfMessageBody; - var body = this.params.MessageBody; - var calculatedMd5 = this.service.calculateChecksum(body); - if (calculatedMd5 !== md5) { - var msg = 'Got "' + response.data.MD5OfMessageBody + - '", expecting "' + calculatedMd5 + '".'; - this.service.throwInvalidChecksumError(response, - [response.data.MessageId], msg); - } - }, +class DescribeOrganizationsAccessCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DescribeOrganizationsAccess", {}) + .n("CloudFormationClient", "DescribeOrganizationsAccessCommand") + .sc(DescribeOrganizationsAccess) + .build() { +} - /** - * @api private - */ - verifySendMessageBatchChecksum: function verifySendMessageBatchChecksum(response) { - if (!response.data) return; +class DescribePublisherCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DescribePublisher", {}) + .n("CloudFormationClient", "DescribePublisherCommand") + .sc(DescribePublisher) + .build() { +} - var service = this.service; - var entries = {}; - var errors = []; - var messageIds = []; - AWS.util.arrayEach(response.data.Successful, function (entry) { - entries[entry.Id] = entry; - }); - AWS.util.arrayEach(this.params.Entries, function (entry) { - if (entries[entry.Id]) { - var md5 = entries[entry.Id].MD5OfMessageBody; - var body = entry.MessageBody; - if (!service.isChecksumValid(md5, body)) { - errors.push(entry.Id); - messageIds.push(entries[entry.Id].MessageId); - } - } - }); +class DescribeResourceScanCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DescribeResourceScan", {}) + .n("CloudFormationClient", "DescribeResourceScanCommand") + .sc(DescribeResourceScan) + .build() { +} - if (errors.length > 0) { - service.throwInvalidChecksumError(response, messageIds, - 'Invalid messages: ' + errors.join(', ')); - } - }, +class DescribeStackDriftDetectionStatusCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DescribeStackDriftDetectionStatus", {}) + .n("CloudFormationClient", "DescribeStackDriftDetectionStatusCommand") + .sc(DescribeStackDriftDetectionStatus) + .build() { +} - /** - * @api private - */ - verifyReceiveMessageChecksum: function verifyReceiveMessageChecksum(response) { - if (!response.data) return; +class DescribeStackEventsCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DescribeStackEvents", {}) + .n("CloudFormationClient", "DescribeStackEventsCommand") + .sc(DescribeStackEvents) + .build() { +} - var service = this.service; - var messageIds = []; - AWS.util.arrayEach(response.data.Messages, function(message) { - var md5 = message.MD5OfBody; - var body = message.Body; - if (!service.isChecksumValid(md5, body)) { - messageIds.push(message.MessageId); - } - }); +class DescribeStackInstanceCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DescribeStackInstance", {}) + .n("CloudFormationClient", "DescribeStackInstanceCommand") + .sc(DescribeStackInstance) + .build() { +} - if (messageIds.length > 0) { - service.throwInvalidChecksumError(response, messageIds, - 'Invalid messages: ' + messageIds.join(', ')); - } - }, +class DescribeStackRefactorCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DescribeStackRefactor", {}) + .n("CloudFormationClient", "DescribeStackRefactorCommand") + .sc(DescribeStackRefactor) + .build() { +} - /** - * @api private - */ - throwInvalidChecksumError: function throwInvalidChecksumError(response, ids, message) { - response.error = AWS.util.error(new Error(), { - retryable: true, - code: 'InvalidChecksum', - messageIds: ids, - message: response.request.operation + - ' returned an invalid MD5 response. ' + message - }); - }, +class DescribeStackResourceCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DescribeStackResource", {}) + .n("CloudFormationClient", "DescribeStackResourceCommand") + .sc(DescribeStackResource) + .build() { +} - /** - * @api private - */ - isChecksumValid: function isChecksumValid(checksum, data) { - return this.calculateChecksum(data) === checksum; - }, +class DescribeStackResourceDriftsCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DescribeStackResourceDrifts", {}) + .n("CloudFormationClient", "DescribeStackResourceDriftsCommand") + .sc(DescribeStackResourceDrifts) + .build() { +} - /** - * @api private - */ - calculateChecksum: function calculateChecksum(data) { - return AWS.util.crypto.md5(data, 'hex'); - }, +class DescribeStackResourcesCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DescribeStackResources", {}) + .n("CloudFormationClient", "DescribeStackResourcesCommand") + .sc(DescribeStackResources) + .build() { +} - /** - * @api private - */ - buildEndpoint: function buildEndpoint(request) { - var url = request.httpRequest.params.QueueUrl; - if (url) { - request.httpRequest.endpoint = new AWS.Endpoint(url); +class DescribeStacksCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DescribeStacks", {}) + .n("CloudFormationClient", "DescribeStacksCommand") + .sc(DescribeStacks) + .build() { +} - // signature version 4 requires the region name to be set, - // sqs queue urls contain the region name - var matches = request.httpRequest.endpoint.host.match(/^sqs\.(.+?)\./); - if (matches) request.httpRequest.region = matches[1]; - } - } -}); +class DescribeStackSetCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DescribeStackSet", {}) + .n("CloudFormationClient", "DescribeStackSetCommand") + .sc(DescribeStackSet) + .build() { +} +class DescribeStackSetOperationCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DescribeStackSetOperation", {}) + .n("CloudFormationClient", "DescribeStackSetOperationCommand") + .sc(DescribeStackSetOperation) + .build() { +} -/***/ }), +class DescribeTypeCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DescribeType", {}) + .n("CloudFormationClient", "DescribeTypeCommand") + .sc(DescribeType) + .build() { +} -/***/ 890: -/***/ (function(module) { +class DescribeTypeRegistrationCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DescribeTypeRegistration", {}) + .n("CloudFormationClient", "DescribeTypeRegistrationCommand") + .sc(DescribeTypeRegistration) + .build() { +} -module.exports = {"version":"2.0","metadata":{"apiVersion":"2018-06-26","endpointPrefix":"forecastquery","jsonVersion":"1.1","protocol":"json","serviceFullName":"Amazon Forecast Query Service","serviceId":"forecastquery","signatureVersion":"v4","signingName":"forecast","targetPrefix":"AmazonForecastRuntime","uid":"forecastquery-2018-06-26"},"operations":{"QueryForecast":{"input":{"type":"structure","required":["ForecastArn","Filters"],"members":{"ForecastArn":{},"StartDate":{},"EndDate":{},"Filters":{"type":"map","key":{},"value":{}},"NextToken":{}}},"output":{"type":"structure","members":{"Forecast":{"type":"structure","members":{"Predictions":{"type":"map","key":{},"value":{"type":"list","member":{"type":"structure","members":{"Timestamp":{},"Value":{"type":"double"}}}}}}}}}}},"shapes":{}}; +class DetectStackDriftCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DetectStackDrift", {}) + .n("CloudFormationClient", "DetectStackDriftCommand") + .sc(DetectStackDrift) + .build() { +} -/***/ }), +class DetectStackResourceDriftCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DetectStackResourceDrift", {}) + .n("CloudFormationClient", "DetectStackResourceDriftCommand") + .sc(DetectStackResourceDrift) + .build() { +} -/***/ 904: -/***/ (function(module, __unusedexports, __webpack_require__) { +class DetectStackSetDriftCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "DetectStackSetDrift", {}) + .n("CloudFormationClient", "DetectStackSetDriftCommand") + .sc(DetectStackSetDrift) + .build() { +} -var util = __webpack_require__(153); -var AWS = __webpack_require__(395); +class EstimateTemplateCostCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "EstimateTemplateCost", {}) + .n("CloudFormationClient", "EstimateTemplateCostCommand") + .sc(EstimateTemplateCost) + .build() { +} -/** - * Prepend prefix defined by API model to endpoint that's already - * constructed. This feature does not apply to operations using - * endpoint discovery and can be disabled. - * @api private - */ -function populateHostPrefix(request) { - var enabled = request.service.config.hostPrefixEnabled; - if (!enabled) return request; - var operationModel = request.service.api.operations[request.operation]; - //don't marshal host prefix when operation has endpoint discovery traits - if (hasEndpointDiscover(request)) return request; - if (operationModel.endpoint && operationModel.endpoint.hostPrefix) { - var hostPrefixNotation = operationModel.endpoint.hostPrefix; - var hostPrefix = expandHostPrefix(hostPrefixNotation, request.params, operationModel.input); - prependEndpointPrefix(request.httpRequest.endpoint, hostPrefix); - validateHostname(request.httpRequest.endpoint.hostname); - } - return request; +class ExecuteChangeSetCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ExecuteChangeSet", {}) + .n("CloudFormationClient", "ExecuteChangeSetCommand") + .sc(ExecuteChangeSet) + .build() { } -/** - * @api private - */ -function hasEndpointDiscover(request) { - var api = request.service.api; - var operationModel = api.operations[request.operation]; - var isEndpointOperation = api.endpointOperation && (api.endpointOperation === util.string.lowerFirst(operationModel.name)); - return (operationModel.endpointDiscoveryRequired !== 'NULL' || isEndpointOperation === true); +class ExecuteStackRefactorCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ExecuteStackRefactor", {}) + .n("CloudFormationClient", "ExecuteStackRefactorCommand") + .sc(ExecuteStackRefactor) + .build() { } -/** - * @api private - */ -function expandHostPrefix(hostPrefixNotation, params, shape) { - util.each(shape.members, function(name, member) { - if (member.hostLabel === true) { - if (typeof params[name] !== 'string' || params[name] === '') { - throw util.error(new Error(), { - message: 'Parameter ' + name + ' should be a non-empty string.', - code: 'InvalidParameter' - }); - } - var regex = new RegExp('\\{' + name + '\\}', 'g'); - hostPrefixNotation = hostPrefixNotation.replace(regex, params[name]); - } - }); - return hostPrefixNotation; +class GetGeneratedTemplateCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "GetGeneratedTemplate", {}) + .n("CloudFormationClient", "GetGeneratedTemplateCommand") + .sc(GetGeneratedTemplate) + .build() { } -/** - * @api private - */ -function prependEndpointPrefix(endpoint, prefix) { - if (endpoint.host) { - endpoint.host = prefix + endpoint.host; - } - if (endpoint.hostname) { - endpoint.hostname = prefix + endpoint.hostname; - } +class GetHookResultCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "GetHookResult", {}) + .n("CloudFormationClient", "GetHookResultCommand") + .sc(GetHookResult) + .build() { } -/** - * @api private - */ -function validateHostname(hostname) { - var labels = hostname.split('.'); - //Reference: https://tools.ietf.org/html/rfc1123#section-2 - var hostPattern = /^[a-zA-Z0-9]{1}$|^[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9]$/; - util.arrayEach(labels, function(label) { - if (!label.length || label.length < 1 || label.length > 63) { - throw util.error(new Error(), { - code: 'ValidationError', - message: 'Hostname label length should be between 1 to 63 characters, inclusive.' - }); - } - if (!hostPattern.test(label)) { - throw AWS.util.error(new Error(), - {code: 'ValidationError', message: label + ' is not hostname compatible.'}); - } - }); +class GetStackPolicyCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "GetStackPolicy", {}) + .n("CloudFormationClient", "GetStackPolicyCommand") + .sc(GetStackPolicy) + .build() { } -module.exports = { - populateHostPrefix: populateHostPrefix -}; +class GetTemplateCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "GetTemplate", {}) + .n("CloudFormationClient", "GetTemplateCommand") + .sc(GetTemplate) + .build() { +} +class GetTemplateSummaryCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "GetTemplateSummary", {}) + .n("CloudFormationClient", "GetTemplateSummaryCommand") + .sc(GetTemplateSummary) + .build() { +} -/***/ }), +class ImportStacksToStackSetCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ImportStacksToStackSet", {}) + .n("CloudFormationClient", "ImportStacksToStackSetCommand") + .sc(ImportStacksToStackSet) + .build() { +} -/***/ 910: -/***/ (function(module, __unusedexports, __webpack_require__) { +class ListChangeSetsCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ListChangeSets", {}) + .n("CloudFormationClient", "ListChangeSetsCommand") + .sc(ListChangeSets) + .build() { +} -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +class ListExportsCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ListExports", {}) + .n("CloudFormationClient", "ListExportsCommand") + .sc(ListExports) + .build() { +} -apiLoader.services['storagegateway'] = {}; -AWS.StorageGateway = Service.defineService('storagegateway', ['2013-06-30']); -Object.defineProperty(apiLoader.services['storagegateway'], '2013-06-30', { - get: function get() { - var model = __webpack_require__(4540); - model.paginators = __webpack_require__(1009).pagination; - return model; - }, - enumerable: true, - configurable: true -}); +class ListGeneratedTemplatesCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ListGeneratedTemplates", {}) + .n("CloudFormationClient", "ListGeneratedTemplatesCommand") + .sc(ListGeneratedTemplates) + .build() { +} -module.exports = AWS.StorageGateway; +class ListHookResultsCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ListHookResults", {}) + .n("CloudFormationClient", "ListHookResultsCommand") + .sc(ListHookResults) + .build() { +} +class ListImportsCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ListImports", {}) + .n("CloudFormationClient", "ListImportsCommand") + .sc(ListImports) + .build() { +} -/***/ }), +class ListResourceScanRelatedResourcesCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ListResourceScanRelatedResources", {}) + .n("CloudFormationClient", "ListResourceScanRelatedResourcesCommand") + .sc(ListResourceScanRelatedResources) + .build() { +} -/***/ 912: -/***/ (function(module) { +class ListResourceScanResourcesCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ListResourceScanResources", {}) + .n("CloudFormationClient", "ListResourceScanResourcesCommand") + .sc(ListResourceScanResources) + .build() { +} -module.exports = {"version":2,"waiters":{"ClusterActive":{"delay":30,"operation":"DescribeCluster","maxAttempts":40,"acceptors":[{"expected":"DELETING","matcher":"path","state":"failure","argument":"cluster.status"},{"expected":"FAILED","matcher":"path","state":"failure","argument":"cluster.status"},{"expected":"ACTIVE","matcher":"path","state":"success","argument":"cluster.status"}]},"ClusterDeleted":{"delay":30,"operation":"DescribeCluster","maxAttempts":40,"acceptors":[{"expected":"ACTIVE","matcher":"path","state":"failure","argument":"cluster.status"},{"expected":"CREATING","matcher":"path","state":"failure","argument":"cluster.status"},{"expected":"ResourceNotFoundException","matcher":"error","state":"success"}]},"NodegroupActive":{"delay":30,"operation":"DescribeNodegroup","maxAttempts":80,"acceptors":[{"expected":"CREATE_FAILED","matcher":"path","state":"failure","argument":"nodegroup.status"},{"expected":"ACTIVE","matcher":"path","state":"success","argument":"nodegroup.status"}]},"NodegroupDeleted":{"delay":30,"operation":"DescribeNodegroup","maxAttempts":40,"acceptors":[{"expected":"DELETE_FAILED","matcher":"path","state":"failure","argument":"nodegroup.status"},{"expected":"ResourceNotFoundException","matcher":"error","state":"success"}]}}}; +class ListResourceScansCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ListResourceScans", {}) + .n("CloudFormationClient", "ListResourceScansCommand") + .sc(ListResourceScans) + .build() { +} -/***/ }), +class ListStackInstanceResourceDriftsCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ListStackInstanceResourceDrifts", {}) + .n("CloudFormationClient", "ListStackInstanceResourceDriftsCommand") + .sc(ListStackInstanceResourceDrifts) + .build() { +} -/***/ 918: -/***/ (function(module) { +class ListStackInstancesCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ListStackInstances", {}) + .n("CloudFormationClient", "ListStackInstancesCommand") + .sc(ListStackInstances) + .build() { +} -module.exports = {"version":"2.0","metadata":{"apiVersion":"2018-06-27","endpointPrefix":"textract","jsonVersion":"1.1","protocol":"json","serviceFullName":"Amazon Textract","serviceId":"Textract","signatureVersion":"v4","targetPrefix":"Textract","uid":"textract-2018-06-27"},"operations":{"AnalyzeDocument":{"input":{"type":"structure","required":["Document","FeatureTypes"],"members":{"Document":{"shape":"S2"},"FeatureTypes":{"shape":"S8"},"HumanLoopConfig":{"type":"structure","required":["HumanLoopName","FlowDefinitionArn"],"members":{"HumanLoopName":{},"FlowDefinitionArn":{},"DataAttributes":{"type":"structure","members":{"ContentClassifiers":{"type":"list","member":{}}}}}}}},"output":{"type":"structure","members":{"DocumentMetadata":{"shape":"Sh"},"Blocks":{"shape":"Sj"},"HumanLoopActivationOutput":{"type":"structure","members":{"HumanLoopArn":{},"HumanLoopActivationReasons":{"type":"list","member":{}},"HumanLoopActivationConditionsEvaluationResults":{"jsonvalue":true}}},"AnalyzeDocumentModelVersion":{}}}},"DetectDocumentText":{"input":{"type":"structure","required":["Document"],"members":{"Document":{"shape":"S2"}}},"output":{"type":"structure","members":{"DocumentMetadata":{"shape":"Sh"},"Blocks":{"shape":"Sj"},"DetectDocumentTextModelVersion":{}}}},"GetDocumentAnalysis":{"input":{"type":"structure","required":["JobId"],"members":{"JobId":{},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"DocumentMetadata":{"shape":"Sh"},"JobStatus":{},"NextToken":{},"Blocks":{"shape":"Sj"},"Warnings":{"shape":"S1e"},"StatusMessage":{},"AnalyzeDocumentModelVersion":{}}}},"GetDocumentTextDetection":{"input":{"type":"structure","required":["JobId"],"members":{"JobId":{},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"DocumentMetadata":{"shape":"Sh"},"JobStatus":{},"NextToken":{},"Blocks":{"shape":"Sj"},"Warnings":{"shape":"S1e"},"StatusMessage":{},"DetectDocumentTextModelVersion":{}}}},"StartDocumentAnalysis":{"input":{"type":"structure","required":["DocumentLocation","FeatureTypes"],"members":{"DocumentLocation":{"shape":"S1m"},"FeatureTypes":{"shape":"S8"},"ClientRequestToken":{},"JobTag":{},"NotificationChannel":{"shape":"S1p"}}},"output":{"type":"structure","members":{"JobId":{}}}},"StartDocumentTextDetection":{"input":{"type":"structure","required":["DocumentLocation"],"members":{"DocumentLocation":{"shape":"S1m"},"ClientRequestToken":{},"JobTag":{},"NotificationChannel":{"shape":"S1p"}}},"output":{"type":"structure","members":{"JobId":{}}}}},"shapes":{"S2":{"type":"structure","members":{"Bytes":{"type":"blob"},"S3Object":{"shape":"S4"}}},"S4":{"type":"structure","members":{"Bucket":{},"Name":{},"Version":{}}},"S8":{"type":"list","member":{}},"Sh":{"type":"structure","members":{"Pages":{"type":"integer"}}},"Sj":{"type":"list","member":{"type":"structure","members":{"BlockType":{},"Confidence":{"type":"float"},"Text":{},"RowIndex":{"type":"integer"},"ColumnIndex":{"type":"integer"},"RowSpan":{"type":"integer"},"ColumnSpan":{"type":"integer"},"Geometry":{"type":"structure","members":{"BoundingBox":{"type":"structure","members":{"Width":{"type":"float"},"Height":{"type":"float"},"Left":{"type":"float"},"Top":{"type":"float"}}},"Polygon":{"type":"list","member":{"type":"structure","members":{"X":{"type":"float"},"Y":{"type":"float"}}}}}},"Id":{},"Relationships":{"type":"list","member":{"type":"structure","members":{"Type":{},"Ids":{"type":"list","member":{}}}}},"EntityTypes":{"type":"list","member":{}},"SelectionStatus":{},"Page":{"type":"integer"}}}},"S1e":{"type":"list","member":{"type":"structure","members":{"ErrorCode":{},"Pages":{"type":"list","member":{"type":"integer"}}}}},"S1m":{"type":"structure","members":{"S3Object":{"shape":"S4"}}},"S1p":{"type":"structure","required":["SNSTopicArn","RoleArn"],"members":{"SNSTopicArn":{},"RoleArn":{}}}}}; +class ListStackRefactorActionsCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ListStackRefactorActions", {}) + .n("CloudFormationClient", "ListStackRefactorActionsCommand") + .sc(ListStackRefactorActions) + .build() { +} -/***/ }), +class ListStackRefactorsCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ListStackRefactors", {}) + .n("CloudFormationClient", "ListStackRefactorsCommand") + .sc(ListStackRefactors) + .build() { +} -/***/ 952: -/***/ (function(module) { +class ListStackResourcesCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ListStackResources", {}) + .n("CloudFormationClient", "ListStackResourcesCommand") + .sc(ListStackResources) + .build() { +} -module.exports = {"version":"2.0","metadata":{"apiVersion":"2017-03-25","endpointPrefix":"cloudfront","globalEndpoint":"cloudfront.amazonaws.com","protocol":"rest-xml","serviceAbbreviation":"CloudFront","serviceFullName":"Amazon CloudFront","serviceId":"CloudFront","signatureVersion":"v4","uid":"cloudfront-2017-03-25"},"operations":{"CreateCloudFrontOriginAccessIdentity":{"http":{"requestUri":"/2017-03-25/origin-access-identity/cloudfront","responseCode":201},"input":{"type":"structure","required":["CloudFrontOriginAccessIdentityConfig"],"members":{"CloudFrontOriginAccessIdentityConfig":{"shape":"S2","locationName":"CloudFrontOriginAccessIdentityConfig","xmlNamespace":{"uri":"http://cloudfront.amazonaws.com/doc/2017-03-25/"}}},"payload":"CloudFrontOriginAccessIdentityConfig"},"output":{"type":"structure","members":{"CloudFrontOriginAccessIdentity":{"shape":"S5"},"Location":{"location":"header","locationName":"Location"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"CloudFrontOriginAccessIdentity"}},"CreateDistribution":{"http":{"requestUri":"/2017-03-25/distribution","responseCode":201},"input":{"type":"structure","required":["DistributionConfig"],"members":{"DistributionConfig":{"shape":"S7","locationName":"DistributionConfig","xmlNamespace":{"uri":"http://cloudfront.amazonaws.com/doc/2017-03-25/"}}},"payload":"DistributionConfig"},"output":{"type":"structure","members":{"Distribution":{"shape":"S1s"},"Location":{"location":"header","locationName":"Location"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"Distribution"}},"CreateDistributionWithTags":{"http":{"requestUri":"/2017-03-25/distribution?WithTags","responseCode":201},"input":{"type":"structure","required":["DistributionConfigWithTags"],"members":{"DistributionConfigWithTags":{"locationName":"DistributionConfigWithTags","xmlNamespace":{"uri":"http://cloudfront.amazonaws.com/doc/2017-03-25/"},"type":"structure","required":["DistributionConfig","Tags"],"members":{"DistributionConfig":{"shape":"S7"},"Tags":{"shape":"S21"}}}},"payload":"DistributionConfigWithTags"},"output":{"type":"structure","members":{"Distribution":{"shape":"S1s"},"Location":{"location":"header","locationName":"Location"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"Distribution"}},"CreateInvalidation":{"http":{"requestUri":"/2017-03-25/distribution/{DistributionId}/invalidation","responseCode":201},"input":{"type":"structure","required":["DistributionId","InvalidationBatch"],"members":{"DistributionId":{"location":"uri","locationName":"DistributionId"},"InvalidationBatch":{"shape":"S28","locationName":"InvalidationBatch","xmlNamespace":{"uri":"http://cloudfront.amazonaws.com/doc/2017-03-25/"}}},"payload":"InvalidationBatch"},"output":{"type":"structure","members":{"Location":{"location":"header","locationName":"Location"},"Invalidation":{"shape":"S2c"}},"payload":"Invalidation"}},"CreateStreamingDistribution":{"http":{"requestUri":"/2017-03-25/streaming-distribution","responseCode":201},"input":{"type":"structure","required":["StreamingDistributionConfig"],"members":{"StreamingDistributionConfig":{"shape":"S2e","locationName":"StreamingDistributionConfig","xmlNamespace":{"uri":"http://cloudfront.amazonaws.com/doc/2017-03-25/"}}},"payload":"StreamingDistributionConfig"},"output":{"type":"structure","members":{"StreamingDistribution":{"shape":"S2i"},"Location":{"location":"header","locationName":"Location"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"StreamingDistribution"}},"CreateStreamingDistributionWithTags":{"http":{"requestUri":"/2017-03-25/streaming-distribution?WithTags","responseCode":201},"input":{"type":"structure","required":["StreamingDistributionConfigWithTags"],"members":{"StreamingDistributionConfigWithTags":{"locationName":"StreamingDistributionConfigWithTags","xmlNamespace":{"uri":"http://cloudfront.amazonaws.com/doc/2017-03-25/"},"type":"structure","required":["StreamingDistributionConfig","Tags"],"members":{"StreamingDistributionConfig":{"shape":"S2e"},"Tags":{"shape":"S21"}}}},"payload":"StreamingDistributionConfigWithTags"},"output":{"type":"structure","members":{"StreamingDistribution":{"shape":"S2i"},"Location":{"location":"header","locationName":"Location"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"StreamingDistribution"}},"DeleteCloudFrontOriginAccessIdentity":{"http":{"method":"DELETE","requestUri":"/2017-03-25/origin-access-identity/cloudfront/{Id}","responseCode":204},"input":{"type":"structure","required":["Id"],"members":{"Id":{"location":"uri","locationName":"Id"},"IfMatch":{"location":"header","locationName":"If-Match"}}}},"DeleteDistribution":{"http":{"method":"DELETE","requestUri":"/2017-03-25/distribution/{Id}","responseCode":204},"input":{"type":"structure","required":["Id"],"members":{"Id":{"location":"uri","locationName":"Id"},"IfMatch":{"location":"header","locationName":"If-Match"}}}},"DeleteServiceLinkedRole":{"http":{"method":"DELETE","requestUri":"/2017-03-25/service-linked-role/{RoleName}","responseCode":204},"input":{"type":"structure","required":["RoleName"],"members":{"RoleName":{"location":"uri","locationName":"RoleName"}}}},"DeleteStreamingDistribution":{"http":{"method":"DELETE","requestUri":"/2017-03-25/streaming-distribution/{Id}","responseCode":204},"input":{"type":"structure","required":["Id"],"members":{"Id":{"location":"uri","locationName":"Id"},"IfMatch":{"location":"header","locationName":"If-Match"}}}},"GetCloudFrontOriginAccessIdentity":{"http":{"method":"GET","requestUri":"/2017-03-25/origin-access-identity/cloudfront/{Id}"},"input":{"type":"structure","required":["Id"],"members":{"Id":{"location":"uri","locationName":"Id"}}},"output":{"type":"structure","members":{"CloudFrontOriginAccessIdentity":{"shape":"S5"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"CloudFrontOriginAccessIdentity"}},"GetCloudFrontOriginAccessIdentityConfig":{"http":{"method":"GET","requestUri":"/2017-03-25/origin-access-identity/cloudfront/{Id}/config"},"input":{"type":"structure","required":["Id"],"members":{"Id":{"location":"uri","locationName":"Id"}}},"output":{"type":"structure","members":{"CloudFrontOriginAccessIdentityConfig":{"shape":"S2"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"CloudFrontOriginAccessIdentityConfig"}},"GetDistribution":{"http":{"method":"GET","requestUri":"/2017-03-25/distribution/{Id}"},"input":{"type":"structure","required":["Id"],"members":{"Id":{"location":"uri","locationName":"Id"}}},"output":{"type":"structure","members":{"Distribution":{"shape":"S1s"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"Distribution"}},"GetDistributionConfig":{"http":{"method":"GET","requestUri":"/2017-03-25/distribution/{Id}/config"},"input":{"type":"structure","required":["Id"],"members":{"Id":{"location":"uri","locationName":"Id"}}},"output":{"type":"structure","members":{"DistributionConfig":{"shape":"S7"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"DistributionConfig"}},"GetInvalidation":{"http":{"method":"GET","requestUri":"/2017-03-25/distribution/{DistributionId}/invalidation/{Id}"},"input":{"type":"structure","required":["DistributionId","Id"],"members":{"DistributionId":{"location":"uri","locationName":"DistributionId"},"Id":{"location":"uri","locationName":"Id"}}},"output":{"type":"structure","members":{"Invalidation":{"shape":"S2c"}},"payload":"Invalidation"}},"GetStreamingDistribution":{"http":{"method":"GET","requestUri":"/2017-03-25/streaming-distribution/{Id}"},"input":{"type":"structure","required":["Id"],"members":{"Id":{"location":"uri","locationName":"Id"}}},"output":{"type":"structure","members":{"StreamingDistribution":{"shape":"S2i"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"StreamingDistribution"}},"GetStreamingDistributionConfig":{"http":{"method":"GET","requestUri":"/2017-03-25/streaming-distribution/{Id}/config"},"input":{"type":"structure","required":["Id"],"members":{"Id":{"location":"uri","locationName":"Id"}}},"output":{"type":"structure","members":{"StreamingDistributionConfig":{"shape":"S2e"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"StreamingDistributionConfig"}},"ListCloudFrontOriginAccessIdentities":{"http":{"method":"GET","requestUri":"/2017-03-25/origin-access-identity/cloudfront"},"input":{"type":"structure","members":{"Marker":{"location":"querystring","locationName":"Marker"},"MaxItems":{"location":"querystring","locationName":"MaxItems"}}},"output":{"type":"structure","members":{"CloudFrontOriginAccessIdentityList":{"type":"structure","required":["Marker","MaxItems","IsTruncated","Quantity"],"members":{"Marker":{},"NextMarker":{},"MaxItems":{"type":"integer"},"IsTruncated":{"type":"boolean"},"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"CloudFrontOriginAccessIdentitySummary","type":"structure","required":["Id","S3CanonicalUserId","Comment"],"members":{"Id":{},"S3CanonicalUserId":{},"Comment":{}}}}}}},"payload":"CloudFrontOriginAccessIdentityList"}},"ListDistributions":{"http":{"method":"GET","requestUri":"/2017-03-25/distribution"},"input":{"type":"structure","members":{"Marker":{"location":"querystring","locationName":"Marker"},"MaxItems":{"location":"querystring","locationName":"MaxItems"}}},"output":{"type":"structure","members":{"DistributionList":{"shape":"S3b"}},"payload":"DistributionList"}},"ListDistributionsByWebACLId":{"http":{"method":"GET","requestUri":"/2017-03-25/distributionsByWebACLId/{WebACLId}"},"input":{"type":"structure","required":["WebACLId"],"members":{"Marker":{"location":"querystring","locationName":"Marker"},"MaxItems":{"location":"querystring","locationName":"MaxItems"},"WebACLId":{"location":"uri","locationName":"WebACLId"}}},"output":{"type":"structure","members":{"DistributionList":{"shape":"S3b"}},"payload":"DistributionList"}},"ListInvalidations":{"http":{"method":"GET","requestUri":"/2017-03-25/distribution/{DistributionId}/invalidation"},"input":{"type":"structure","required":["DistributionId"],"members":{"DistributionId":{"location":"uri","locationName":"DistributionId"},"Marker":{"location":"querystring","locationName":"Marker"},"MaxItems":{"location":"querystring","locationName":"MaxItems"}}},"output":{"type":"structure","members":{"InvalidationList":{"type":"structure","required":["Marker","MaxItems","IsTruncated","Quantity"],"members":{"Marker":{},"NextMarker":{},"MaxItems":{"type":"integer"},"IsTruncated":{"type":"boolean"},"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"InvalidationSummary","type":"structure","required":["Id","CreateTime","Status"],"members":{"Id":{},"CreateTime":{"type":"timestamp"},"Status":{}}}}}}},"payload":"InvalidationList"}},"ListStreamingDistributions":{"http":{"method":"GET","requestUri":"/2017-03-25/streaming-distribution"},"input":{"type":"structure","members":{"Marker":{"location":"querystring","locationName":"Marker"},"MaxItems":{"location":"querystring","locationName":"MaxItems"}}},"output":{"type":"structure","members":{"StreamingDistributionList":{"type":"structure","required":["Marker","MaxItems","IsTruncated","Quantity"],"members":{"Marker":{},"NextMarker":{},"MaxItems":{"type":"integer"},"IsTruncated":{"type":"boolean"},"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"StreamingDistributionSummary","type":"structure","required":["Id","ARN","Status","LastModifiedTime","DomainName","S3Origin","Aliases","TrustedSigners","Comment","PriceClass","Enabled"],"members":{"Id":{},"ARN":{},"Status":{},"LastModifiedTime":{"type":"timestamp"},"DomainName":{},"S3Origin":{"shape":"S2f"},"Aliases":{"shape":"S8"},"TrustedSigners":{"shape":"Sy"},"Comment":{},"PriceClass":{},"Enabled":{"type":"boolean"}}}}}}},"payload":"StreamingDistributionList"}},"ListTagsForResource":{"http":{"method":"GET","requestUri":"/2017-03-25/tagging"},"input":{"type":"structure","required":["Resource"],"members":{"Resource":{"location":"querystring","locationName":"Resource"}}},"output":{"type":"structure","required":["Tags"],"members":{"Tags":{"shape":"S21"}},"payload":"Tags"}},"TagResource":{"http":{"requestUri":"/2017-03-25/tagging?Operation=Tag","responseCode":204},"input":{"type":"structure","required":["Resource","Tags"],"members":{"Resource":{"location":"querystring","locationName":"Resource"},"Tags":{"shape":"S21","locationName":"Tags","xmlNamespace":{"uri":"http://cloudfront.amazonaws.com/doc/2017-03-25/"}}},"payload":"Tags"}},"UntagResource":{"http":{"requestUri":"/2017-03-25/tagging?Operation=Untag","responseCode":204},"input":{"type":"structure","required":["Resource","TagKeys"],"members":{"Resource":{"location":"querystring","locationName":"Resource"},"TagKeys":{"locationName":"TagKeys","xmlNamespace":{"uri":"http://cloudfront.amazonaws.com/doc/2017-03-25/"},"type":"structure","members":{"Items":{"type":"list","member":{"locationName":"Key"}}}}},"payload":"TagKeys"}},"UpdateCloudFrontOriginAccessIdentity":{"http":{"method":"PUT","requestUri":"/2017-03-25/origin-access-identity/cloudfront/{Id}/config"},"input":{"type":"structure","required":["CloudFrontOriginAccessIdentityConfig","Id"],"members":{"CloudFrontOriginAccessIdentityConfig":{"shape":"S2","locationName":"CloudFrontOriginAccessIdentityConfig","xmlNamespace":{"uri":"http://cloudfront.amazonaws.com/doc/2017-03-25/"}},"Id":{"location":"uri","locationName":"Id"},"IfMatch":{"location":"header","locationName":"If-Match"}},"payload":"CloudFrontOriginAccessIdentityConfig"},"output":{"type":"structure","members":{"CloudFrontOriginAccessIdentity":{"shape":"S5"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"CloudFrontOriginAccessIdentity"}},"UpdateDistribution":{"http":{"method":"PUT","requestUri":"/2017-03-25/distribution/{Id}/config"},"input":{"type":"structure","required":["DistributionConfig","Id"],"members":{"DistributionConfig":{"shape":"S7","locationName":"DistributionConfig","xmlNamespace":{"uri":"http://cloudfront.amazonaws.com/doc/2017-03-25/"}},"Id":{"location":"uri","locationName":"Id"},"IfMatch":{"location":"header","locationName":"If-Match"}},"payload":"DistributionConfig"},"output":{"type":"structure","members":{"Distribution":{"shape":"S1s"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"Distribution"}},"UpdateStreamingDistribution":{"http":{"method":"PUT","requestUri":"/2017-03-25/streaming-distribution/{Id}/config"},"input":{"type":"structure","required":["StreamingDistributionConfig","Id"],"members":{"StreamingDistributionConfig":{"shape":"S2e","locationName":"StreamingDistributionConfig","xmlNamespace":{"uri":"http://cloudfront.amazonaws.com/doc/2017-03-25/"}},"Id":{"location":"uri","locationName":"Id"},"IfMatch":{"location":"header","locationName":"If-Match"}},"payload":"StreamingDistributionConfig"},"output":{"type":"structure","members":{"StreamingDistribution":{"shape":"S2i"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"StreamingDistribution"}}},"shapes":{"S2":{"type":"structure","required":["CallerReference","Comment"],"members":{"CallerReference":{},"Comment":{}}},"S5":{"type":"structure","required":["Id","S3CanonicalUserId"],"members":{"Id":{},"S3CanonicalUserId":{},"CloudFrontOriginAccessIdentityConfig":{"shape":"S2"}}},"S7":{"type":"structure","required":["CallerReference","Origins","DefaultCacheBehavior","Comment","Enabled"],"members":{"CallerReference":{},"Aliases":{"shape":"S8"},"DefaultRootObject":{},"Origins":{"shape":"Sb"},"DefaultCacheBehavior":{"shape":"Sn"},"CacheBehaviors":{"shape":"S1a"},"CustomErrorResponses":{"shape":"S1d"},"Comment":{},"Logging":{"type":"structure","required":["Enabled","IncludeCookies","Bucket","Prefix"],"members":{"Enabled":{"type":"boolean"},"IncludeCookies":{"type":"boolean"},"Bucket":{},"Prefix":{}}},"PriceClass":{},"Enabled":{"type":"boolean"},"ViewerCertificate":{"shape":"S1i"},"Restrictions":{"shape":"S1m"},"WebACLId":{},"HttpVersion":{},"IsIPV6Enabled":{"type":"boolean"}}},"S8":{"type":"structure","required":["Quantity"],"members":{"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"CNAME"}}}},"Sb":{"type":"structure","required":["Quantity"],"members":{"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"Origin","type":"structure","required":["Id","DomainName"],"members":{"Id":{},"DomainName":{},"OriginPath":{},"CustomHeaders":{"type":"structure","required":["Quantity"],"members":{"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"OriginCustomHeader","type":"structure","required":["HeaderName","HeaderValue"],"members":{"HeaderName":{},"HeaderValue":{}}}}}},"S3OriginConfig":{"type":"structure","required":["OriginAccessIdentity"],"members":{"OriginAccessIdentity":{}}},"CustomOriginConfig":{"type":"structure","required":["HTTPPort","HTTPSPort","OriginProtocolPolicy"],"members":{"HTTPPort":{"type":"integer"},"HTTPSPort":{"type":"integer"},"OriginProtocolPolicy":{},"OriginSslProtocols":{"type":"structure","required":["Quantity","Items"],"members":{"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"SslProtocol"}}}},"OriginReadTimeout":{"type":"integer"},"OriginKeepaliveTimeout":{"type":"integer"}}}}}}}},"Sn":{"type":"structure","required":["TargetOriginId","ForwardedValues","TrustedSigners","ViewerProtocolPolicy","MinTTL"],"members":{"TargetOriginId":{},"ForwardedValues":{"shape":"So"},"TrustedSigners":{"shape":"Sy"},"ViewerProtocolPolicy":{},"MinTTL":{"type":"long"},"AllowedMethods":{"shape":"S12"},"SmoothStreaming":{"type":"boolean"},"DefaultTTL":{"type":"long"},"MaxTTL":{"type":"long"},"Compress":{"type":"boolean"},"LambdaFunctionAssociations":{"shape":"S16"}}},"So":{"type":"structure","required":["QueryString","Cookies"],"members":{"QueryString":{"type":"boolean"},"Cookies":{"type":"structure","required":["Forward"],"members":{"Forward":{},"WhitelistedNames":{"type":"structure","required":["Quantity"],"members":{"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"Name"}}}}}},"Headers":{"type":"structure","required":["Quantity"],"members":{"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"Name"}}}},"QueryStringCacheKeys":{"type":"structure","required":["Quantity"],"members":{"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"Name"}}}}}},"Sy":{"type":"structure","required":["Enabled","Quantity"],"members":{"Enabled":{"type":"boolean"},"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"AwsAccountNumber"}}}},"S12":{"type":"structure","required":["Quantity","Items"],"members":{"Quantity":{"type":"integer"},"Items":{"shape":"S13"},"CachedMethods":{"type":"structure","required":["Quantity","Items"],"members":{"Quantity":{"type":"integer"},"Items":{"shape":"S13"}}}}},"S13":{"type":"list","member":{"locationName":"Method"}},"S16":{"type":"structure","required":["Quantity"],"members":{"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"LambdaFunctionAssociation","type":"structure","members":{"LambdaFunctionARN":{},"EventType":{}}}}}},"S1a":{"type":"structure","required":["Quantity"],"members":{"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"CacheBehavior","type":"structure","required":["PathPattern","TargetOriginId","ForwardedValues","TrustedSigners","ViewerProtocolPolicy","MinTTL"],"members":{"PathPattern":{},"TargetOriginId":{},"ForwardedValues":{"shape":"So"},"TrustedSigners":{"shape":"Sy"},"ViewerProtocolPolicy":{},"MinTTL":{"type":"long"},"AllowedMethods":{"shape":"S12"},"SmoothStreaming":{"type":"boolean"},"DefaultTTL":{"type":"long"},"MaxTTL":{"type":"long"},"Compress":{"type":"boolean"},"LambdaFunctionAssociations":{"shape":"S16"}}}}}},"S1d":{"type":"structure","required":["Quantity"],"members":{"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"CustomErrorResponse","type":"structure","required":["ErrorCode"],"members":{"ErrorCode":{"type":"integer"},"ResponsePagePath":{},"ResponseCode":{},"ErrorCachingMinTTL":{"type":"long"}}}}}},"S1i":{"type":"structure","members":{"CloudFrontDefaultCertificate":{"type":"boolean"},"IAMCertificateId":{},"ACMCertificateArn":{},"SSLSupportMethod":{},"MinimumProtocolVersion":{},"Certificate":{"deprecated":true},"CertificateSource":{"deprecated":true}}},"S1m":{"type":"structure","required":["GeoRestriction"],"members":{"GeoRestriction":{"type":"structure","required":["RestrictionType","Quantity"],"members":{"RestrictionType":{},"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"Location"}}}}}},"S1s":{"type":"structure","required":["Id","ARN","Status","LastModifiedTime","InProgressInvalidationBatches","DomainName","ActiveTrustedSigners","DistributionConfig"],"members":{"Id":{},"ARN":{},"Status":{},"LastModifiedTime":{"type":"timestamp"},"InProgressInvalidationBatches":{"type":"integer"},"DomainName":{},"ActiveTrustedSigners":{"shape":"S1u"},"DistributionConfig":{"shape":"S7"}}},"S1u":{"type":"structure","required":["Enabled","Quantity"],"members":{"Enabled":{"type":"boolean"},"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"Signer","type":"structure","members":{"AwsAccountNumber":{},"KeyPairIds":{"type":"structure","required":["Quantity"],"members":{"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"KeyPairId"}}}}}}}}},"S21":{"type":"structure","members":{"Items":{"type":"list","member":{"locationName":"Tag","type":"structure","required":["Key"],"members":{"Key":{},"Value":{}}}}}},"S28":{"type":"structure","required":["Paths","CallerReference"],"members":{"Paths":{"type":"structure","required":["Quantity"],"members":{"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"Path"}}}},"CallerReference":{}}},"S2c":{"type":"structure","required":["Id","Status","CreateTime","InvalidationBatch"],"members":{"Id":{},"Status":{},"CreateTime":{"type":"timestamp"},"InvalidationBatch":{"shape":"S28"}}},"S2e":{"type":"structure","required":["CallerReference","S3Origin","Comment","TrustedSigners","Enabled"],"members":{"CallerReference":{},"S3Origin":{"shape":"S2f"},"Aliases":{"shape":"S8"},"Comment":{},"Logging":{"type":"structure","required":["Enabled","Bucket","Prefix"],"members":{"Enabled":{"type":"boolean"},"Bucket":{},"Prefix":{}}},"TrustedSigners":{"shape":"Sy"},"PriceClass":{},"Enabled":{"type":"boolean"}}},"S2f":{"type":"structure","required":["DomainName","OriginAccessIdentity"],"members":{"DomainName":{},"OriginAccessIdentity":{}}},"S2i":{"type":"structure","required":["Id","ARN","Status","DomainName","ActiveTrustedSigners","StreamingDistributionConfig"],"members":{"Id":{},"ARN":{},"Status":{},"LastModifiedTime":{"type":"timestamp"},"DomainName":{},"ActiveTrustedSigners":{"shape":"S1u"},"StreamingDistributionConfig":{"shape":"S2e"}}},"S3b":{"type":"structure","required":["Marker","MaxItems","IsTruncated","Quantity"],"members":{"Marker":{},"NextMarker":{},"MaxItems":{"type":"integer"},"IsTruncated":{"type":"boolean"},"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"DistributionSummary","type":"structure","required":["Id","ARN","Status","LastModifiedTime","DomainName","Aliases","Origins","DefaultCacheBehavior","CacheBehaviors","CustomErrorResponses","Comment","PriceClass","Enabled","ViewerCertificate","Restrictions","WebACLId","HttpVersion","IsIPV6Enabled"],"members":{"Id":{},"ARN":{},"Status":{},"LastModifiedTime":{"type":"timestamp"},"DomainName":{},"Aliases":{"shape":"S8"},"Origins":{"shape":"Sb"},"DefaultCacheBehavior":{"shape":"Sn"},"CacheBehaviors":{"shape":"S1a"},"CustomErrorResponses":{"shape":"S1d"},"Comment":{},"PriceClass":{},"Enabled":{"type":"boolean"},"ViewerCertificate":{"shape":"S1i"},"Restrictions":{"shape":"S1m"},"WebACLId":{},"HttpVersion":{},"IsIPV6Enabled":{"type":"boolean"}}}}}}}}; +class ListStacksCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ListStacks", {}) + .n("CloudFormationClient", "ListStacksCommand") + .sc(ListStacks) + .build() { +} -/***/ }), +class ListStackSetAutoDeploymentTargetsCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ListStackSetAutoDeploymentTargets", {}) + .n("CloudFormationClient", "ListStackSetAutoDeploymentTargetsCommand") + .sc(ListStackSetAutoDeploymentTargets) + .build() { +} -/***/ 956: -/***/ (function(module) { +class ListStackSetOperationResultsCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ListStackSetOperationResults", {}) + .n("CloudFormationClient", "ListStackSetOperationResultsCommand") + .sc(ListStackSetOperationResults) + .build() { +} -module.exports = {"pagination":{"DescribeListeners":{"input_token":"Marker","output_token":"NextMarker","result_key":"Listeners"},"DescribeLoadBalancers":{"input_token":"Marker","output_token":"NextMarker","result_key":"LoadBalancers"},"DescribeTargetGroups":{"input_token":"Marker","output_token":"NextMarker","result_key":"TargetGroups"}}}; +class ListStackSetOperationsCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ListStackSetOperations", {}) + .n("CloudFormationClient", "ListStackSetOperationsCommand") + .sc(ListStackSetOperations) + .build() { +} -/***/ }), +class ListStackSetsCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ListStackSets", {}) + .n("CloudFormationClient", "ListStackSetsCommand") + .sc(ListStackSets) + .build() { +} -/***/ 988: -/***/ (function(module) { +class ListTypeRegistrationsCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ListTypeRegistrations", {}) + .n("CloudFormationClient", "ListTypeRegistrationsCommand") + .sc(ListTypeRegistrations) + .build() { +} -module.exports = {"version":"2.0","metadata":{"apiVersion":"2016-12-01","endpointPrefix":"appstream2","jsonVersion":"1.1","protocol":"json","serviceFullName":"Amazon AppStream","serviceId":"AppStream","signatureVersion":"v4","signingName":"appstream","targetPrefix":"PhotonAdminProxyService","uid":"appstream-2016-12-01"},"operations":{"AssociateFleet":{"input":{"type":"structure","required":["FleetName","StackName"],"members":{"FleetName":{},"StackName":{}}},"output":{"type":"structure","members":{}}},"BatchAssociateUserStack":{"input":{"type":"structure","required":["UserStackAssociations"],"members":{"UserStackAssociations":{"shape":"S5"}}},"output":{"type":"structure","members":{"errors":{"shape":"Sb"}}}},"BatchDisassociateUserStack":{"input":{"type":"structure","required":["UserStackAssociations"],"members":{"UserStackAssociations":{"shape":"S5"}}},"output":{"type":"structure","members":{"errors":{"shape":"Sb"}}}},"CopyImage":{"input":{"type":"structure","required":["SourceImageName","DestinationImageName","DestinationRegion"],"members":{"SourceImageName":{},"DestinationImageName":{},"DestinationRegion":{},"DestinationImageDescription":{}}},"output":{"type":"structure","members":{"DestinationImageName":{}}}},"CreateDirectoryConfig":{"input":{"type":"structure","required":["DirectoryName","OrganizationalUnitDistinguishedNames","ServiceAccountCredentials"],"members":{"DirectoryName":{},"OrganizationalUnitDistinguishedNames":{"shape":"Sn"},"ServiceAccountCredentials":{"shape":"Sp"}}},"output":{"type":"structure","members":{"DirectoryConfig":{"shape":"St"}}}},"CreateFleet":{"input":{"type":"structure","required":["Name","InstanceType","ComputeCapacity"],"members":{"Name":{},"ImageName":{},"ImageArn":{},"InstanceType":{},"FleetType":{},"ComputeCapacity":{"shape":"Sy"},"VpcConfig":{"shape":"S10"},"MaxUserDurationInSeconds":{"type":"integer"},"DisconnectTimeoutInSeconds":{"type":"integer"},"Description":{},"DisplayName":{},"EnableDefaultInternetAccess":{"type":"boolean"},"DomainJoinInfo":{"shape":"S15"},"Tags":{"shape":"S16"},"IdleDisconnectTimeoutInSeconds":{"type":"integer"},"IamRoleArn":{}}},"output":{"type":"structure","members":{"Fleet":{"shape":"S1a"}}}},"CreateImageBuilder":{"input":{"type":"structure","required":["Name","InstanceType"],"members":{"Name":{},"ImageName":{},"ImageArn":{},"InstanceType":{},"Description":{},"DisplayName":{},"VpcConfig":{"shape":"S10"},"IamRoleArn":{},"EnableDefaultInternetAccess":{"type":"boolean"},"DomainJoinInfo":{"shape":"S15"},"AppstreamAgentVersion":{},"Tags":{"shape":"S16"},"AccessEndpoints":{"shape":"S1i"}}},"output":{"type":"structure","members":{"ImageBuilder":{"shape":"S1m"}}}},"CreateImageBuilderStreamingURL":{"input":{"type":"structure","required":["Name"],"members":{"Name":{},"Validity":{"type":"long"}}},"output":{"type":"structure","members":{"StreamingURL":{},"Expires":{"type":"timestamp"}}}},"CreateStack":{"input":{"type":"structure","required":["Name"],"members":{"Name":{},"Description":{},"DisplayName":{},"StorageConnectors":{"shape":"S1y"},"RedirectURL":{},"FeedbackURL":{},"UserSettings":{"shape":"S26"},"ApplicationSettings":{"shape":"S2a"},"Tags":{"shape":"S16"},"AccessEndpoints":{"shape":"S1i"},"EmbedHostDomains":{"shape":"S2c"}}},"output":{"type":"structure","members":{"Stack":{"shape":"S2f"}}}},"CreateStreamingURL":{"input":{"type":"structure","required":["StackName","FleetName","UserId"],"members":{"StackName":{},"FleetName":{},"UserId":{},"ApplicationId":{},"Validity":{"type":"long"},"SessionContext":{}}},"output":{"type":"structure","members":{"StreamingURL":{},"Expires":{"type":"timestamp"}}}},"CreateUsageReportSubscription":{"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"S3BucketName":{},"Schedule":{}}}},"CreateUser":{"input":{"type":"structure","required":["UserName","AuthenticationType"],"members":{"UserName":{"shape":"S7"},"MessageAction":{},"FirstName":{"shape":"S2s"},"LastName":{"shape":"S2s"},"AuthenticationType":{}}},"output":{"type":"structure","members":{}}},"DeleteDirectoryConfig":{"input":{"type":"structure","required":["DirectoryName"],"members":{"DirectoryName":{}}},"output":{"type":"structure","members":{}}},"DeleteFleet":{"input":{"type":"structure","required":["Name"],"members":{"Name":{}}},"output":{"type":"structure","members":{}}},"DeleteImage":{"input":{"type":"structure","required":["Name"],"members":{"Name":{}}},"output":{"type":"structure","members":{"Image":{"shape":"S30"}}}},"DeleteImageBuilder":{"input":{"type":"structure","required":["Name"],"members":{"Name":{}}},"output":{"type":"structure","members":{"ImageBuilder":{"shape":"S1m"}}}},"DeleteImagePermissions":{"input":{"type":"structure","required":["Name","SharedAccountId"],"members":{"Name":{},"SharedAccountId":{}}},"output":{"type":"structure","members":{}}},"DeleteStack":{"input":{"type":"structure","required":["Name"],"members":{"Name":{}}},"output":{"type":"structure","members":{}}},"DeleteUsageReportSubscription":{"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{}}},"DeleteUser":{"input":{"type":"structure","required":["UserName","AuthenticationType"],"members":{"UserName":{"shape":"S7"},"AuthenticationType":{}}},"output":{"type":"structure","members":{}}},"DescribeDirectoryConfigs":{"input":{"type":"structure","members":{"DirectoryNames":{"type":"list","member":{}},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"DirectoryConfigs":{"type":"list","member":{"shape":"St"}},"NextToken":{}}}},"DescribeFleets":{"input":{"type":"structure","members":{"Names":{"shape":"S3p"},"NextToken":{}}},"output":{"type":"structure","members":{"Fleets":{"type":"list","member":{"shape":"S1a"}},"NextToken":{}}}},"DescribeImageBuilders":{"input":{"type":"structure","members":{"Names":{"shape":"S3p"},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"ImageBuilders":{"type":"list","member":{"shape":"S1m"}},"NextToken":{}}}},"DescribeImagePermissions":{"input":{"type":"structure","required":["Name"],"members":{"Name":{},"MaxResults":{"type":"integer"},"SharedAwsAccountIds":{"type":"list","member":{}},"NextToken":{}}},"output":{"type":"structure","members":{"Name":{},"SharedImagePermissionsList":{"type":"list","member":{"type":"structure","required":["sharedAccountId","imagePermissions"],"members":{"sharedAccountId":{},"imagePermissions":{"shape":"S38"}}}},"NextToken":{}}}},"DescribeImages":{"input":{"type":"structure","members":{"Names":{"shape":"S3p"},"Arns":{"type":"list","member":{}},"Type":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"Images":{"type":"list","member":{"shape":"S30"}},"NextToken":{}}}},"DescribeSessions":{"input":{"type":"structure","required":["StackName","FleetName"],"members":{"StackName":{},"FleetName":{},"UserId":{},"NextToken":{},"Limit":{"type":"integer"},"AuthenticationType":{}}},"output":{"type":"structure","members":{"Sessions":{"type":"list","member":{"type":"structure","required":["Id","UserId","StackName","FleetName","State"],"members":{"Id":{},"UserId":{},"StackName":{},"FleetName":{},"State":{},"ConnectionState":{},"StartTime":{"type":"timestamp"},"MaxExpirationTime":{"type":"timestamp"},"AuthenticationType":{},"NetworkAccessConfiguration":{"shape":"S1r"}}}},"NextToken":{}}}},"DescribeStacks":{"input":{"type":"structure","members":{"Names":{"shape":"S3p"},"NextToken":{}}},"output":{"type":"structure","members":{"Stacks":{"type":"list","member":{"shape":"S2f"}},"NextToken":{}}}},"DescribeUsageReportSubscriptions":{"input":{"type":"structure","members":{"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"UsageReportSubscriptions":{"type":"list","member":{"type":"structure","members":{"S3BucketName":{},"Schedule":{},"LastGeneratedReportDate":{"type":"timestamp"},"SubscriptionErrors":{"type":"list","member":{"type":"structure","members":{"ErrorCode":{},"ErrorMessage":{}}}}}}},"NextToken":{}}}},"DescribeUserStackAssociations":{"input":{"type":"structure","members":{"StackName":{},"UserName":{"shape":"S7"},"AuthenticationType":{},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"UserStackAssociations":{"shape":"S5"},"NextToken":{}}}},"DescribeUsers":{"input":{"type":"structure","required":["AuthenticationType"],"members":{"AuthenticationType":{},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"Users":{"type":"list","member":{"type":"structure","required":["AuthenticationType"],"members":{"Arn":{},"UserName":{"shape":"S7"},"Enabled":{"type":"boolean"},"Status":{},"FirstName":{"shape":"S2s"},"LastName":{"shape":"S2s"},"CreatedTime":{"type":"timestamp"},"AuthenticationType":{}}}},"NextToken":{}}}},"DisableUser":{"input":{"type":"structure","required":["UserName","AuthenticationType"],"members":{"UserName":{"shape":"S7"},"AuthenticationType":{}}},"output":{"type":"structure","members":{}}},"DisassociateFleet":{"input":{"type":"structure","required":["FleetName","StackName"],"members":{"FleetName":{},"StackName":{}}},"output":{"type":"structure","members":{}}},"EnableUser":{"input":{"type":"structure","required":["UserName","AuthenticationType"],"members":{"UserName":{"shape":"S7"},"AuthenticationType":{}}},"output":{"type":"structure","members":{}}},"ExpireSession":{"input":{"type":"structure","required":["SessionId"],"members":{"SessionId":{}}},"output":{"type":"structure","members":{}}},"ListAssociatedFleets":{"input":{"type":"structure","required":["StackName"],"members":{"StackName":{},"NextToken":{}}},"output":{"type":"structure","members":{"Names":{"shape":"S3p"},"NextToken":{}}}},"ListAssociatedStacks":{"input":{"type":"structure","required":["FleetName"],"members":{"FleetName":{},"NextToken":{}}},"output":{"type":"structure","members":{"Names":{"shape":"S3p"},"NextToken":{}}}},"ListTagsForResource":{"input":{"type":"structure","required":["ResourceArn"],"members":{"ResourceArn":{}}},"output":{"type":"structure","members":{"Tags":{"shape":"S16"}}}},"StartFleet":{"input":{"type":"structure","required":["Name"],"members":{"Name":{}}},"output":{"type":"structure","members":{}}},"StartImageBuilder":{"input":{"type":"structure","required":["Name"],"members":{"Name":{},"AppstreamAgentVersion":{}}},"output":{"type":"structure","members":{"ImageBuilder":{"shape":"S1m"}}}},"StopFleet":{"input":{"type":"structure","required":["Name"],"members":{"Name":{}}},"output":{"type":"structure","members":{}}},"StopImageBuilder":{"input":{"type":"structure","required":["Name"],"members":{"Name":{}}},"output":{"type":"structure","members":{"ImageBuilder":{"shape":"S1m"}}}},"TagResource":{"input":{"type":"structure","required":["ResourceArn","Tags"],"members":{"ResourceArn":{},"Tags":{"shape":"S16"}}},"output":{"type":"structure","members":{}}},"UntagResource":{"input":{"type":"structure","required":["ResourceArn","TagKeys"],"members":{"ResourceArn":{},"TagKeys":{"type":"list","member":{}}}},"output":{"type":"structure","members":{}}},"UpdateDirectoryConfig":{"input":{"type":"structure","required":["DirectoryName"],"members":{"DirectoryName":{},"OrganizationalUnitDistinguishedNames":{"shape":"Sn"},"ServiceAccountCredentials":{"shape":"Sp"}}},"output":{"type":"structure","members":{"DirectoryConfig":{"shape":"St"}}}},"UpdateFleet":{"input":{"type":"structure","members":{"ImageName":{},"ImageArn":{},"Name":{},"InstanceType":{},"ComputeCapacity":{"shape":"Sy"},"VpcConfig":{"shape":"S10"},"MaxUserDurationInSeconds":{"type":"integer"},"DisconnectTimeoutInSeconds":{"type":"integer"},"DeleteVpcConfig":{"deprecated":true,"type":"boolean"},"Description":{},"DisplayName":{},"EnableDefaultInternetAccess":{"type":"boolean"},"DomainJoinInfo":{"shape":"S15"},"IdleDisconnectTimeoutInSeconds":{"type":"integer"},"AttributesToDelete":{"type":"list","member":{}},"IamRoleArn":{}}},"output":{"type":"structure","members":{"Fleet":{"shape":"S1a"}}}},"UpdateImagePermissions":{"input":{"type":"structure","required":["Name","SharedAccountId","ImagePermissions"],"members":{"Name":{},"SharedAccountId":{},"ImagePermissions":{"shape":"S38"}}},"output":{"type":"structure","members":{}}},"UpdateStack":{"input":{"type":"structure","required":["Name"],"members":{"DisplayName":{},"Description":{},"Name":{},"StorageConnectors":{"shape":"S1y"},"DeleteStorageConnectors":{"deprecated":true,"type":"boolean"},"RedirectURL":{},"FeedbackURL":{},"AttributesToDelete":{"type":"list","member":{}},"UserSettings":{"shape":"S26"},"ApplicationSettings":{"shape":"S2a"},"AccessEndpoints":{"shape":"S1i"},"EmbedHostDomains":{"shape":"S2c"}}},"output":{"type":"structure","members":{"Stack":{"shape":"S2f"}}}}},"shapes":{"S5":{"type":"list","member":{"shape":"S6"}},"S6":{"type":"structure","required":["StackName","UserName","AuthenticationType"],"members":{"StackName":{},"UserName":{"shape":"S7"},"AuthenticationType":{},"SendEmailNotification":{"type":"boolean"}}},"S7":{"type":"string","sensitive":true},"Sb":{"type":"list","member":{"type":"structure","members":{"UserStackAssociation":{"shape":"S6"},"ErrorCode":{},"ErrorMessage":{}}}},"Sn":{"type":"list","member":{}},"Sp":{"type":"structure","required":["AccountName","AccountPassword"],"members":{"AccountName":{"type":"string","sensitive":true},"AccountPassword":{"type":"string","sensitive":true}}},"St":{"type":"structure","required":["DirectoryName"],"members":{"DirectoryName":{},"OrganizationalUnitDistinguishedNames":{"shape":"Sn"},"ServiceAccountCredentials":{"shape":"Sp"},"CreatedTime":{"type":"timestamp"}}},"Sy":{"type":"structure","required":["DesiredInstances"],"members":{"DesiredInstances":{"type":"integer"}}},"S10":{"type":"structure","members":{"SubnetIds":{"type":"list","member":{}},"SecurityGroupIds":{"type":"list","member":{}}}},"S15":{"type":"structure","members":{"DirectoryName":{},"OrganizationalUnitDistinguishedName":{}}},"S16":{"type":"map","key":{},"value":{}},"S1a":{"type":"structure","required":["Arn","Name","InstanceType","ComputeCapacityStatus","State"],"members":{"Arn":{},"Name":{},"DisplayName":{},"Description":{},"ImageName":{},"ImageArn":{},"InstanceType":{},"FleetType":{},"ComputeCapacityStatus":{"type":"structure","required":["Desired"],"members":{"Desired":{"type":"integer"},"Running":{"type":"integer"},"InUse":{"type":"integer"},"Available":{"type":"integer"}}},"MaxUserDurationInSeconds":{"type":"integer"},"DisconnectTimeoutInSeconds":{"type":"integer"},"State":{},"VpcConfig":{"shape":"S10"},"CreatedTime":{"type":"timestamp"},"FleetErrors":{"type":"list","member":{"type":"structure","members":{"ErrorCode":{},"ErrorMessage":{}}}},"EnableDefaultInternetAccess":{"type":"boolean"},"DomainJoinInfo":{"shape":"S15"},"IdleDisconnectTimeoutInSeconds":{"type":"integer"},"IamRoleArn":{}}},"S1i":{"type":"list","member":{"type":"structure","required":["EndpointType"],"members":{"EndpointType":{},"VpceId":{}}}},"S1m":{"type":"structure","required":["Name"],"members":{"Name":{},"Arn":{},"ImageArn":{},"Description":{},"DisplayName":{},"VpcConfig":{"shape":"S10"},"InstanceType":{},"Platform":{},"IamRoleArn":{},"State":{},"StateChangeReason":{"type":"structure","members":{"Code":{},"Message":{}}},"CreatedTime":{"type":"timestamp"},"EnableDefaultInternetAccess":{"type":"boolean"},"DomainJoinInfo":{"shape":"S15"},"NetworkAccessConfiguration":{"shape":"S1r"},"ImageBuilderErrors":{"type":"list","member":{"type":"structure","members":{"ErrorCode":{},"ErrorMessage":{},"ErrorTimestamp":{"type":"timestamp"}}}},"AppstreamAgentVersion":{},"AccessEndpoints":{"shape":"S1i"}}},"S1r":{"type":"structure","members":{"EniPrivateIpAddress":{},"EniId":{}}},"S1y":{"type":"list","member":{"type":"structure","required":["ConnectorType"],"members":{"ConnectorType":{},"ResourceIdentifier":{},"Domains":{"type":"list","member":{}}}}},"S26":{"type":"list","member":{"type":"structure","required":["Action","Permission"],"members":{"Action":{},"Permission":{}}}},"S2a":{"type":"structure","required":["Enabled"],"members":{"Enabled":{"type":"boolean"},"SettingsGroup":{}}},"S2c":{"type":"list","member":{}},"S2f":{"type":"structure","required":["Name"],"members":{"Arn":{},"Name":{},"Description":{},"DisplayName":{},"CreatedTime":{"type":"timestamp"},"StorageConnectors":{"shape":"S1y"},"RedirectURL":{},"FeedbackURL":{},"StackErrors":{"type":"list","member":{"type":"structure","members":{"ErrorCode":{},"ErrorMessage":{}}}},"UserSettings":{"shape":"S26"},"ApplicationSettings":{"type":"structure","members":{"Enabled":{"type":"boolean"},"SettingsGroup":{},"S3BucketName":{}}},"AccessEndpoints":{"shape":"S1i"},"EmbedHostDomains":{"shape":"S2c"}}},"S2s":{"type":"string","sensitive":true},"S30":{"type":"structure","required":["Name"],"members":{"Name":{},"Arn":{},"BaseImageArn":{},"DisplayName":{},"State":{},"Visibility":{},"ImageBuilderSupported":{"type":"boolean"},"ImageBuilderName":{},"Platform":{},"Description":{},"StateChangeReason":{"type":"structure","members":{"Code":{},"Message":{}}},"Applications":{"type":"list","member":{"type":"structure","members":{"Name":{},"DisplayName":{},"IconURL":{},"LaunchPath":{},"LaunchParameters":{},"Enabled":{"type":"boolean"},"Metadata":{"type":"map","key":{},"value":{}}}}},"CreatedTime":{"type":"timestamp"},"PublicBaseImageReleasedDate":{"type":"timestamp"},"AppstreamAgentVersion":{},"ImagePermissions":{"shape":"S38"}}},"S38":{"type":"structure","members":{"allowFleet":{"type":"boolean"},"allowImageBuilder":{"type":"boolean"}}},"S3p":{"type":"list","member":{}}}}; +class ListTypesCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ListTypes", {}) + .n("CloudFormationClient", "ListTypesCommand") + .sc(ListTypes) + .build() { +} -/***/ }), +class ListTypeVersionsCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ListTypeVersions", {}) + .n("CloudFormationClient", "ListTypeVersionsCommand") + .sc(ListTypeVersions) + .build() { +} -/***/ 997: -/***/ (function(module) { +class PublishTypeCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "PublishType", {}) + .n("CloudFormationClient", "PublishTypeCommand") + .sc(PublishType) + .build() { +} -module.exports = {"metadata":{"apiVersion":"2016-12-01","endpointPrefix":"pinpoint","signingName":"mobiletargeting","serviceFullName":"Amazon Pinpoint","serviceId":"Pinpoint","protocol":"rest-json","jsonVersion":"1.1","uid":"pinpoint-2016-12-01","signatureVersion":"v4"},"operations":{"CreateApp":{"http":{"requestUri":"/v1/apps","responseCode":201},"input":{"type":"structure","members":{"CreateApplicationRequest":{"type":"structure","members":{"Name":{},"tags":{"shape":"S4","locationName":"tags"}},"required":["Name"]}},"required":["CreateApplicationRequest"],"payload":"CreateApplicationRequest"},"output":{"type":"structure","members":{"ApplicationResponse":{"shape":"S6"}},"required":["ApplicationResponse"],"payload":"ApplicationResponse"}},"CreateCampaign":{"http":{"requestUri":"/v1/apps/{application-id}/campaigns","responseCode":201},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"WriteCampaignRequest":{"shape":"S8"}},"required":["ApplicationId","WriteCampaignRequest"],"payload":"WriteCampaignRequest"},"output":{"type":"structure","members":{"CampaignResponse":{"shape":"S18"}},"required":["CampaignResponse"],"payload":"CampaignResponse"}},"CreateEmailTemplate":{"http":{"requestUri":"/v1/templates/{template-name}/email","responseCode":201},"input":{"type":"structure","members":{"EmailTemplateRequest":{"shape":"S1e"},"TemplateName":{"location":"uri","locationName":"template-name"}},"required":["TemplateName","EmailTemplateRequest"],"payload":"EmailTemplateRequest"},"output":{"type":"structure","members":{"CreateTemplateMessageBody":{"shape":"S1g"}},"required":["CreateTemplateMessageBody"],"payload":"CreateTemplateMessageBody"}},"CreateExportJob":{"http":{"requestUri":"/v1/apps/{application-id}/jobs/export","responseCode":202},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"ExportJobRequest":{"type":"structure","members":{"RoleArn":{},"S3UrlPrefix":{},"SegmentId":{},"SegmentVersion":{"type":"integer"}},"required":["S3UrlPrefix","RoleArn"]}},"required":["ApplicationId","ExportJobRequest"],"payload":"ExportJobRequest"},"output":{"type":"structure","members":{"ExportJobResponse":{"shape":"S1k"}},"required":["ExportJobResponse"],"payload":"ExportJobResponse"}},"CreateImportJob":{"http":{"requestUri":"/v1/apps/{application-id}/jobs/import","responseCode":201},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"ImportJobRequest":{"type":"structure","members":{"DefineSegment":{"type":"boolean"},"ExternalId":{},"Format":{},"RegisterEndpoints":{"type":"boolean"},"RoleArn":{},"S3Url":{},"SegmentId":{},"SegmentName":{}},"required":["Format","S3Url","RoleArn"]}},"required":["ApplicationId","ImportJobRequest"],"payload":"ImportJobRequest"},"output":{"type":"structure","members":{"ImportJobResponse":{"shape":"S1r"}},"required":["ImportJobResponse"],"payload":"ImportJobResponse"}},"CreateJourney":{"http":{"requestUri":"/v1/apps/{application-id}/journeys","responseCode":201},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"WriteJourneyRequest":{"shape":"S1u"}},"required":["ApplicationId","WriteJourneyRequest"],"payload":"WriteJourneyRequest"},"output":{"type":"structure","members":{"JourneyResponse":{"shape":"S30"}},"required":["JourneyResponse"],"payload":"JourneyResponse"}},"CreatePushTemplate":{"http":{"requestUri":"/v1/templates/{template-name}/push","responseCode":201},"input":{"type":"structure","members":{"PushNotificationTemplateRequest":{"shape":"S32"},"TemplateName":{"location":"uri","locationName":"template-name"}},"required":["TemplateName","PushNotificationTemplateRequest"],"payload":"PushNotificationTemplateRequest"},"output":{"type":"structure","members":{"CreateTemplateMessageBody":{"shape":"S1g"}},"required":["CreateTemplateMessageBody"],"payload":"CreateTemplateMessageBody"}},"CreateRecommenderConfiguration":{"http":{"requestUri":"/v1/recommenders","responseCode":201},"input":{"type":"structure","members":{"CreateRecommenderConfiguration":{"type":"structure","members":{"Attributes":{"shape":"S4"},"Description":{},"Name":{},"RecommendationProviderIdType":{},"RecommendationProviderRoleArn":{},"RecommendationProviderUri":{},"RecommendationTransformerUri":{},"RecommendationsDisplayName":{},"RecommendationsPerMessage":{"type":"integer"}},"required":["RecommendationProviderUri","RecommendationProviderRoleArn"]}},"required":["CreateRecommenderConfiguration"],"payload":"CreateRecommenderConfiguration"},"output":{"type":"structure","members":{"RecommenderConfigurationResponse":{"shape":"S3a"}},"required":["RecommenderConfigurationResponse"],"payload":"RecommenderConfigurationResponse"}},"CreateSegment":{"http":{"requestUri":"/v1/apps/{application-id}/segments","responseCode":201},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"WriteSegmentRequest":{"shape":"S3c"}},"required":["ApplicationId","WriteSegmentRequest"],"payload":"WriteSegmentRequest"},"output":{"type":"structure","members":{"SegmentResponse":{"shape":"S3n"}},"required":["SegmentResponse"],"payload":"SegmentResponse"}},"CreateSmsTemplate":{"http":{"requestUri":"/v1/templates/{template-name}/sms","responseCode":201},"input":{"type":"structure","members":{"SMSTemplateRequest":{"shape":"S3s"},"TemplateName":{"location":"uri","locationName":"template-name"}},"required":["TemplateName","SMSTemplateRequest"],"payload":"SMSTemplateRequest"},"output":{"type":"structure","members":{"CreateTemplateMessageBody":{"shape":"S1g"}},"required":["CreateTemplateMessageBody"],"payload":"CreateTemplateMessageBody"}},"CreateVoiceTemplate":{"http":{"requestUri":"/v1/templates/{template-name}/voice","responseCode":201},"input":{"type":"structure","members":{"TemplateName":{"location":"uri","locationName":"template-name"},"VoiceTemplateRequest":{"shape":"S3v"}},"required":["TemplateName","VoiceTemplateRequest"],"payload":"VoiceTemplateRequest"},"output":{"type":"structure","members":{"CreateTemplateMessageBody":{"shape":"S1g"}},"required":["CreateTemplateMessageBody"],"payload":"CreateTemplateMessageBody"}},"DeleteAdmChannel":{"http":{"method":"DELETE","requestUri":"/v1/apps/{application-id}/channels/adm","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"ADMChannelResponse":{"shape":"S3z"}},"required":["ADMChannelResponse"],"payload":"ADMChannelResponse"}},"DeleteApnsChannel":{"http":{"method":"DELETE","requestUri":"/v1/apps/{application-id}/channels/apns","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"APNSChannelResponse":{"shape":"S42"}},"required":["APNSChannelResponse"],"payload":"APNSChannelResponse"}},"DeleteApnsSandboxChannel":{"http":{"method":"DELETE","requestUri":"/v1/apps/{application-id}/channels/apns_sandbox","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"APNSSandboxChannelResponse":{"shape":"S45"}},"required":["APNSSandboxChannelResponse"],"payload":"APNSSandboxChannelResponse"}},"DeleteApnsVoipChannel":{"http":{"method":"DELETE","requestUri":"/v1/apps/{application-id}/channels/apns_voip","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"APNSVoipChannelResponse":{"shape":"S48"}},"required":["APNSVoipChannelResponse"],"payload":"APNSVoipChannelResponse"}},"DeleteApnsVoipSandboxChannel":{"http":{"method":"DELETE","requestUri":"/v1/apps/{application-id}/channels/apns_voip_sandbox","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"APNSVoipSandboxChannelResponse":{"shape":"S4b"}},"required":["APNSVoipSandboxChannelResponse"],"payload":"APNSVoipSandboxChannelResponse"}},"DeleteApp":{"http":{"method":"DELETE","requestUri":"/v1/apps/{application-id}","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"ApplicationResponse":{"shape":"S6"}},"required":["ApplicationResponse"],"payload":"ApplicationResponse"}},"DeleteBaiduChannel":{"http":{"method":"DELETE","requestUri":"/v1/apps/{application-id}/channels/baidu","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"BaiduChannelResponse":{"shape":"S4g"}},"required":["BaiduChannelResponse"],"payload":"BaiduChannelResponse"}},"DeleteCampaign":{"http":{"method":"DELETE","requestUri":"/v1/apps/{application-id}/campaigns/{campaign-id}","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"CampaignId":{"location":"uri","locationName":"campaign-id"}},"required":["CampaignId","ApplicationId"]},"output":{"type":"structure","members":{"CampaignResponse":{"shape":"S18"}},"required":["CampaignResponse"],"payload":"CampaignResponse"}},"DeleteEmailChannel":{"http":{"method":"DELETE","requestUri":"/v1/apps/{application-id}/channels/email","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"EmailChannelResponse":{"shape":"S4l"}},"required":["EmailChannelResponse"],"payload":"EmailChannelResponse"}},"DeleteEmailTemplate":{"http":{"method":"DELETE","requestUri":"/v1/templates/{template-name}/email","responseCode":202},"input":{"type":"structure","members":{"TemplateName":{"location":"uri","locationName":"template-name"},"Version":{"location":"querystring","locationName":"version"}},"required":["TemplateName"]},"output":{"type":"structure","members":{"MessageBody":{"shape":"S4o"}},"required":["MessageBody"],"payload":"MessageBody"}},"DeleteEndpoint":{"http":{"method":"DELETE","requestUri":"/v1/apps/{application-id}/endpoints/{endpoint-id}","responseCode":202},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"EndpointId":{"location":"uri","locationName":"endpoint-id"}},"required":["ApplicationId","EndpointId"]},"output":{"type":"structure","members":{"EndpointResponse":{"shape":"S4r"}},"required":["EndpointResponse"],"payload":"EndpointResponse"}},"DeleteEventStream":{"http":{"method":"DELETE","requestUri":"/v1/apps/{application-id}/eventstream","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"EventStream":{"shape":"S50"}},"required":["EventStream"],"payload":"EventStream"}},"DeleteGcmChannel":{"http":{"method":"DELETE","requestUri":"/v1/apps/{application-id}/channels/gcm","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"GCMChannelResponse":{"shape":"S53"}},"required":["GCMChannelResponse"],"payload":"GCMChannelResponse"}},"DeleteJourney":{"http":{"method":"DELETE","requestUri":"/v1/apps/{application-id}/journeys/{journey-id}","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"JourneyId":{"location":"uri","locationName":"journey-id"}},"required":["JourneyId","ApplicationId"]},"output":{"type":"structure","members":{"JourneyResponse":{"shape":"S30"}},"required":["JourneyResponse"],"payload":"JourneyResponse"}},"DeletePushTemplate":{"http":{"method":"DELETE","requestUri":"/v1/templates/{template-name}/push","responseCode":202},"input":{"type":"structure","members":{"TemplateName":{"location":"uri","locationName":"template-name"},"Version":{"location":"querystring","locationName":"version"}},"required":["TemplateName"]},"output":{"type":"structure","members":{"MessageBody":{"shape":"S4o"}},"required":["MessageBody"],"payload":"MessageBody"}},"DeleteRecommenderConfiguration":{"http":{"method":"DELETE","requestUri":"/v1/recommenders/{recommender-id}","responseCode":200},"input":{"type":"structure","members":{"RecommenderId":{"location":"uri","locationName":"recommender-id"}},"required":["RecommenderId"]},"output":{"type":"structure","members":{"RecommenderConfigurationResponse":{"shape":"S3a"}},"required":["RecommenderConfigurationResponse"],"payload":"RecommenderConfigurationResponse"}},"DeleteSegment":{"http":{"method":"DELETE","requestUri":"/v1/apps/{application-id}/segments/{segment-id}","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"SegmentId":{"location":"uri","locationName":"segment-id"}},"required":["SegmentId","ApplicationId"]},"output":{"type":"structure","members":{"SegmentResponse":{"shape":"S3n"}},"required":["SegmentResponse"],"payload":"SegmentResponse"}},"DeleteSmsChannel":{"http":{"method":"DELETE","requestUri":"/v1/apps/{application-id}/channels/sms","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"SMSChannelResponse":{"shape":"S5e"}},"required":["SMSChannelResponse"],"payload":"SMSChannelResponse"}},"DeleteSmsTemplate":{"http":{"method":"DELETE","requestUri":"/v1/templates/{template-name}/sms","responseCode":202},"input":{"type":"structure","members":{"TemplateName":{"location":"uri","locationName":"template-name"},"Version":{"location":"querystring","locationName":"version"}},"required":["TemplateName"]},"output":{"type":"structure","members":{"MessageBody":{"shape":"S4o"}},"required":["MessageBody"],"payload":"MessageBody"}},"DeleteUserEndpoints":{"http":{"method":"DELETE","requestUri":"/v1/apps/{application-id}/users/{user-id}","responseCode":202},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"UserId":{"location":"uri","locationName":"user-id"}},"required":["ApplicationId","UserId"]},"output":{"type":"structure","members":{"EndpointsResponse":{"shape":"S5j"}},"required":["EndpointsResponse"],"payload":"EndpointsResponse"}},"DeleteVoiceChannel":{"http":{"method":"DELETE","requestUri":"/v1/apps/{application-id}/channels/voice","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"VoiceChannelResponse":{"shape":"S5n"}},"required":["VoiceChannelResponse"],"payload":"VoiceChannelResponse"}},"DeleteVoiceTemplate":{"http":{"method":"DELETE","requestUri":"/v1/templates/{template-name}/voice","responseCode":202},"input":{"type":"structure","members":{"TemplateName":{"location":"uri","locationName":"template-name"},"Version":{"location":"querystring","locationName":"version"}},"required":["TemplateName"]},"output":{"type":"structure","members":{"MessageBody":{"shape":"S4o"}},"required":["MessageBody"],"payload":"MessageBody"}},"GetAdmChannel":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/channels/adm","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"ADMChannelResponse":{"shape":"S3z"}},"required":["ADMChannelResponse"],"payload":"ADMChannelResponse"}},"GetApnsChannel":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/channels/apns","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"APNSChannelResponse":{"shape":"S42"}},"required":["APNSChannelResponse"],"payload":"APNSChannelResponse"}},"GetApnsSandboxChannel":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/channels/apns_sandbox","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"APNSSandboxChannelResponse":{"shape":"S45"}},"required":["APNSSandboxChannelResponse"],"payload":"APNSSandboxChannelResponse"}},"GetApnsVoipChannel":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/channels/apns_voip","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"APNSVoipChannelResponse":{"shape":"S48"}},"required":["APNSVoipChannelResponse"],"payload":"APNSVoipChannelResponse"}},"GetApnsVoipSandboxChannel":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/channels/apns_voip_sandbox","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"APNSVoipSandboxChannelResponse":{"shape":"S4b"}},"required":["APNSVoipSandboxChannelResponse"],"payload":"APNSVoipSandboxChannelResponse"}},"GetApp":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"ApplicationResponse":{"shape":"S6"}},"required":["ApplicationResponse"],"payload":"ApplicationResponse"}},"GetApplicationDateRangeKpi":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/kpis/daterange/{kpi-name}","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"EndTime":{"shape":"S2w","location":"querystring","locationName":"end-time"},"KpiName":{"location":"uri","locationName":"kpi-name"},"NextToken":{"location":"querystring","locationName":"next-token"},"PageSize":{"location":"querystring","locationName":"page-size"},"StartTime":{"shape":"S2w","location":"querystring","locationName":"start-time"}},"required":["ApplicationId","KpiName"]},"output":{"type":"structure","members":{"ApplicationDateRangeKpiResponse":{"type":"structure","members":{"ApplicationId":{},"EndTime":{"shape":"S2w"},"KpiName":{},"KpiResult":{"shape":"S65"},"NextToken":{},"StartTime":{"shape":"S2w"}},"required":["KpiResult","KpiName","EndTime","StartTime","ApplicationId"]}},"required":["ApplicationDateRangeKpiResponse"],"payload":"ApplicationDateRangeKpiResponse"}},"GetApplicationSettings":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/settings","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"ApplicationSettingsResource":{"shape":"S6c"}},"required":["ApplicationSettingsResource"],"payload":"ApplicationSettingsResource"}},"GetApps":{"http":{"method":"GET","requestUri":"/v1/apps","responseCode":200},"input":{"type":"structure","members":{"PageSize":{"location":"querystring","locationName":"page-size"},"Token":{"location":"querystring","locationName":"token"}}},"output":{"type":"structure","members":{"ApplicationsResponse":{"type":"structure","members":{"Item":{"type":"list","member":{"shape":"S6"}},"NextToken":{}}}},"required":["ApplicationsResponse"],"payload":"ApplicationsResponse"}},"GetBaiduChannel":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/channels/baidu","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"BaiduChannelResponse":{"shape":"S4g"}},"required":["BaiduChannelResponse"],"payload":"BaiduChannelResponse"}},"GetCampaign":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/campaigns/{campaign-id}","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"CampaignId":{"location":"uri","locationName":"campaign-id"}},"required":["CampaignId","ApplicationId"]},"output":{"type":"structure","members":{"CampaignResponse":{"shape":"S18"}},"required":["CampaignResponse"],"payload":"CampaignResponse"}},"GetCampaignActivities":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/campaigns/{campaign-id}/activities","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"CampaignId":{"location":"uri","locationName":"campaign-id"},"PageSize":{"location":"querystring","locationName":"page-size"},"Token":{"location":"querystring","locationName":"token"}},"required":["ApplicationId","CampaignId"]},"output":{"type":"structure","members":{"ActivitiesResponse":{"type":"structure","members":{"Item":{"type":"list","member":{"type":"structure","members":{"ApplicationId":{},"CampaignId":{},"End":{},"Id":{},"Result":{},"ScheduledStart":{},"Start":{},"State":{},"SuccessfulEndpointCount":{"type":"integer"},"TimezonesCompletedCount":{"type":"integer"},"TimezonesTotalCount":{"type":"integer"},"TotalEndpointCount":{"type":"integer"},"TreatmentId":{}},"required":["CampaignId","Id","ApplicationId"]}},"NextToken":{}},"required":["Item"]}},"required":["ActivitiesResponse"],"payload":"ActivitiesResponse"}},"GetCampaignDateRangeKpi":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/campaigns/{campaign-id}/kpis/daterange/{kpi-name}","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"CampaignId":{"location":"uri","locationName":"campaign-id"},"EndTime":{"shape":"S2w","location":"querystring","locationName":"end-time"},"KpiName":{"location":"uri","locationName":"kpi-name"},"NextToken":{"location":"querystring","locationName":"next-token"},"PageSize":{"location":"querystring","locationName":"page-size"},"StartTime":{"shape":"S2w","location":"querystring","locationName":"start-time"}},"required":["ApplicationId","KpiName","CampaignId"]},"output":{"type":"structure","members":{"CampaignDateRangeKpiResponse":{"type":"structure","members":{"ApplicationId":{},"CampaignId":{},"EndTime":{"shape":"S2w"},"KpiName":{},"KpiResult":{"shape":"S65"},"NextToken":{},"StartTime":{"shape":"S2w"}},"required":["KpiResult","KpiName","EndTime","CampaignId","StartTime","ApplicationId"]}},"required":["CampaignDateRangeKpiResponse"],"payload":"CampaignDateRangeKpiResponse"}},"GetCampaignVersion":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/campaigns/{campaign-id}/versions/{version}","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"CampaignId":{"location":"uri","locationName":"campaign-id"},"Version":{"location":"uri","locationName":"version"}},"required":["Version","ApplicationId","CampaignId"]},"output":{"type":"structure","members":{"CampaignResponse":{"shape":"S18"}},"required":["CampaignResponse"],"payload":"CampaignResponse"}},"GetCampaignVersions":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/campaigns/{campaign-id}/versions","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"CampaignId":{"location":"uri","locationName":"campaign-id"},"PageSize":{"location":"querystring","locationName":"page-size"},"Token":{"location":"querystring","locationName":"token"}},"required":["ApplicationId","CampaignId"]},"output":{"type":"structure","members":{"CampaignsResponse":{"shape":"S6x"}},"required":["CampaignsResponse"],"payload":"CampaignsResponse"}},"GetCampaigns":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/campaigns","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"PageSize":{"location":"querystring","locationName":"page-size"},"Token":{"location":"querystring","locationName":"token"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"CampaignsResponse":{"shape":"S6x"}},"required":["CampaignsResponse"],"payload":"CampaignsResponse"}},"GetChannels":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/channels","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"ChannelsResponse":{"type":"structure","members":{"Channels":{"type":"map","key":{},"value":{"type":"structure","members":{"ApplicationId":{},"CreationDate":{},"Enabled":{"type":"boolean"},"HasCredential":{"type":"boolean"},"Id":{},"IsArchived":{"type":"boolean"},"LastModifiedBy":{},"LastModifiedDate":{},"Version":{"type":"integer"}}}}},"required":["Channels"]}},"required":["ChannelsResponse"],"payload":"ChannelsResponse"}},"GetEmailChannel":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/channels/email","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"EmailChannelResponse":{"shape":"S4l"}},"required":["EmailChannelResponse"],"payload":"EmailChannelResponse"}},"GetEmailTemplate":{"http":{"method":"GET","requestUri":"/v1/templates/{template-name}/email","responseCode":200},"input":{"type":"structure","members":{"TemplateName":{"location":"uri","locationName":"template-name"},"Version":{"location":"querystring","locationName":"version"}},"required":["TemplateName"]},"output":{"type":"structure","members":{"EmailTemplateResponse":{"type":"structure","members":{"Arn":{},"CreationDate":{},"DefaultSubstitutions":{},"HtmlPart":{},"LastModifiedDate":{},"RecommenderId":{},"Subject":{},"tags":{"shape":"S4","locationName":"tags"},"TemplateDescription":{},"TemplateName":{},"TemplateType":{},"TextPart":{},"Version":{}},"required":["LastModifiedDate","CreationDate","TemplateName","TemplateType"]}},"required":["EmailTemplateResponse"],"payload":"EmailTemplateResponse"}},"GetEndpoint":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/endpoints/{endpoint-id}","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"EndpointId":{"location":"uri","locationName":"endpoint-id"}},"required":["ApplicationId","EndpointId"]},"output":{"type":"structure","members":{"EndpointResponse":{"shape":"S4r"}},"required":["EndpointResponse"],"payload":"EndpointResponse"}},"GetEventStream":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/eventstream","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"EventStream":{"shape":"S50"}},"required":["EventStream"],"payload":"EventStream"}},"GetExportJob":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/jobs/export/{job-id}","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"JobId":{"location":"uri","locationName":"job-id"}},"required":["ApplicationId","JobId"]},"output":{"type":"structure","members":{"ExportJobResponse":{"shape":"S1k"}},"required":["ExportJobResponse"],"payload":"ExportJobResponse"}},"GetExportJobs":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/jobs/export","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"PageSize":{"location":"querystring","locationName":"page-size"},"Token":{"location":"querystring","locationName":"token"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"ExportJobsResponse":{"shape":"S7k"}},"required":["ExportJobsResponse"],"payload":"ExportJobsResponse"}},"GetGcmChannel":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/channels/gcm","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"GCMChannelResponse":{"shape":"S53"}},"required":["GCMChannelResponse"],"payload":"GCMChannelResponse"}},"GetImportJob":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/jobs/import/{job-id}","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"JobId":{"location":"uri","locationName":"job-id"}},"required":["ApplicationId","JobId"]},"output":{"type":"structure","members":{"ImportJobResponse":{"shape":"S1r"}},"required":["ImportJobResponse"],"payload":"ImportJobResponse"}},"GetImportJobs":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/jobs/import","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"PageSize":{"location":"querystring","locationName":"page-size"},"Token":{"location":"querystring","locationName":"token"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"ImportJobsResponse":{"shape":"S7s"}},"required":["ImportJobsResponse"],"payload":"ImportJobsResponse"}},"GetJourney":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/journeys/{journey-id}","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"JourneyId":{"location":"uri","locationName":"journey-id"}},"required":["JourneyId","ApplicationId"]},"output":{"type":"structure","members":{"JourneyResponse":{"shape":"S30"}},"required":["JourneyResponse"],"payload":"JourneyResponse"}},"GetJourneyDateRangeKpi":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/journeys/{journey-id}/kpis/daterange/{kpi-name}","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"EndTime":{"shape":"S2w","location":"querystring","locationName":"end-time"},"JourneyId":{"location":"uri","locationName":"journey-id"},"KpiName":{"location":"uri","locationName":"kpi-name"},"NextToken":{"location":"querystring","locationName":"next-token"},"PageSize":{"location":"querystring","locationName":"page-size"},"StartTime":{"shape":"S2w","location":"querystring","locationName":"start-time"}},"required":["JourneyId","ApplicationId","KpiName"]},"output":{"type":"structure","members":{"JourneyDateRangeKpiResponse":{"type":"structure","members":{"ApplicationId":{},"EndTime":{"shape":"S2w"},"JourneyId":{},"KpiName":{},"KpiResult":{"shape":"S65"},"NextToken":{},"StartTime":{"shape":"S2w"}},"required":["KpiResult","KpiName","JourneyId","EndTime","StartTime","ApplicationId"]}},"required":["JourneyDateRangeKpiResponse"],"payload":"JourneyDateRangeKpiResponse"}},"GetJourneyExecutionActivityMetrics":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/journeys/{journey-id}/activities/{journey-activity-id}/execution-metrics","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"JourneyActivityId":{"location":"uri","locationName":"journey-activity-id"},"JourneyId":{"location":"uri","locationName":"journey-id"},"NextToken":{"location":"querystring","locationName":"next-token"},"PageSize":{"location":"querystring","locationName":"page-size"}},"required":["JourneyActivityId","ApplicationId","JourneyId"]},"output":{"type":"structure","members":{"JourneyExecutionActivityMetricsResponse":{"type":"structure","members":{"ActivityType":{},"ApplicationId":{},"JourneyActivityId":{},"JourneyId":{},"LastEvaluatedTime":{},"Metrics":{"shape":"S4"}},"required":["Metrics","JourneyId","LastEvaluatedTime","JourneyActivityId","ActivityType","ApplicationId"]}},"required":["JourneyExecutionActivityMetricsResponse"],"payload":"JourneyExecutionActivityMetricsResponse"}},"GetJourneyExecutionMetrics":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/journeys/{journey-id}/execution-metrics","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"JourneyId":{"location":"uri","locationName":"journey-id"},"NextToken":{"location":"querystring","locationName":"next-token"},"PageSize":{"location":"querystring","locationName":"page-size"}},"required":["ApplicationId","JourneyId"]},"output":{"type":"structure","members":{"JourneyExecutionMetricsResponse":{"type":"structure","members":{"ApplicationId":{},"JourneyId":{},"LastEvaluatedTime":{},"Metrics":{"shape":"S4"}},"required":["Metrics","JourneyId","LastEvaluatedTime","ApplicationId"]}},"required":["JourneyExecutionMetricsResponse"],"payload":"JourneyExecutionMetricsResponse"}},"GetPushTemplate":{"http":{"method":"GET","requestUri":"/v1/templates/{template-name}/push","responseCode":200},"input":{"type":"structure","members":{"TemplateName":{"location":"uri","locationName":"template-name"},"Version":{"location":"querystring","locationName":"version"}},"required":["TemplateName"]},"output":{"type":"structure","members":{"PushNotificationTemplateResponse":{"type":"structure","members":{"ADM":{"shape":"S33"},"APNS":{"shape":"S34"},"Arn":{},"Baidu":{"shape":"S33"},"CreationDate":{},"Default":{"shape":"S35"},"DefaultSubstitutions":{},"GCM":{"shape":"S33"},"LastModifiedDate":{},"RecommenderId":{},"tags":{"shape":"S4","locationName":"tags"},"TemplateDescription":{},"TemplateName":{},"TemplateType":{},"Version":{}},"required":["LastModifiedDate","CreationDate","TemplateType","TemplateName"]}},"required":["PushNotificationTemplateResponse"],"payload":"PushNotificationTemplateResponse"}},"GetRecommenderConfiguration":{"http":{"method":"GET","requestUri":"/v1/recommenders/{recommender-id}","responseCode":200},"input":{"type":"structure","members":{"RecommenderId":{"location":"uri","locationName":"recommender-id"}},"required":["RecommenderId"]},"output":{"type":"structure","members":{"RecommenderConfigurationResponse":{"shape":"S3a"}},"required":["RecommenderConfigurationResponse"],"payload":"RecommenderConfigurationResponse"}},"GetRecommenderConfigurations":{"http":{"method":"GET","requestUri":"/v1/recommenders","responseCode":200},"input":{"type":"structure","members":{"PageSize":{"location":"querystring","locationName":"page-size"},"Token":{"location":"querystring","locationName":"token"}}},"output":{"type":"structure","members":{"ListRecommenderConfigurationsResponse":{"type":"structure","members":{"Item":{"type":"list","member":{"shape":"S3a"}},"NextToken":{}},"required":["Item"]}},"required":["ListRecommenderConfigurationsResponse"],"payload":"ListRecommenderConfigurationsResponse"}},"GetSegment":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/segments/{segment-id}","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"SegmentId":{"location":"uri","locationName":"segment-id"}},"required":["SegmentId","ApplicationId"]},"output":{"type":"structure","members":{"SegmentResponse":{"shape":"S3n"}},"required":["SegmentResponse"],"payload":"SegmentResponse"}},"GetSegmentExportJobs":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/segments/{segment-id}/jobs/export","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"PageSize":{"location":"querystring","locationName":"page-size"},"SegmentId":{"location":"uri","locationName":"segment-id"},"Token":{"location":"querystring","locationName":"token"}},"required":["SegmentId","ApplicationId"]},"output":{"type":"structure","members":{"ExportJobsResponse":{"shape":"S7k"}},"required":["ExportJobsResponse"],"payload":"ExportJobsResponse"}},"GetSegmentImportJobs":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/segments/{segment-id}/jobs/import","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"PageSize":{"location":"querystring","locationName":"page-size"},"SegmentId":{"location":"uri","locationName":"segment-id"},"Token":{"location":"querystring","locationName":"token"}},"required":["SegmentId","ApplicationId"]},"output":{"type":"structure","members":{"ImportJobsResponse":{"shape":"S7s"}},"required":["ImportJobsResponse"],"payload":"ImportJobsResponse"}},"GetSegmentVersion":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/segments/{segment-id}/versions/{version}","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"SegmentId":{"location":"uri","locationName":"segment-id"},"Version":{"location":"uri","locationName":"version"}},"required":["SegmentId","Version","ApplicationId"]},"output":{"type":"structure","members":{"SegmentResponse":{"shape":"S3n"}},"required":["SegmentResponse"],"payload":"SegmentResponse"}},"GetSegmentVersions":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/segments/{segment-id}/versions","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"PageSize":{"location":"querystring","locationName":"page-size"},"SegmentId":{"location":"uri","locationName":"segment-id"},"Token":{"location":"querystring","locationName":"token"}},"required":["SegmentId","ApplicationId"]},"output":{"type":"structure","members":{"SegmentsResponse":{"shape":"S8o"}},"required":["SegmentsResponse"],"payload":"SegmentsResponse"}},"GetSegments":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/segments","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"PageSize":{"location":"querystring","locationName":"page-size"},"Token":{"location":"querystring","locationName":"token"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"SegmentsResponse":{"shape":"S8o"}},"required":["SegmentsResponse"],"payload":"SegmentsResponse"}},"GetSmsChannel":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/channels/sms","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"SMSChannelResponse":{"shape":"S5e"}},"required":["SMSChannelResponse"],"payload":"SMSChannelResponse"}},"GetSmsTemplate":{"http":{"method":"GET","requestUri":"/v1/templates/{template-name}/sms","responseCode":200},"input":{"type":"structure","members":{"TemplateName":{"location":"uri","locationName":"template-name"},"Version":{"location":"querystring","locationName":"version"}},"required":["TemplateName"]},"output":{"type":"structure","members":{"SMSTemplateResponse":{"type":"structure","members":{"Arn":{},"Body":{},"CreationDate":{},"DefaultSubstitutions":{},"LastModifiedDate":{},"RecommenderId":{},"tags":{"shape":"S4","locationName":"tags"},"TemplateDescription":{},"TemplateName":{},"TemplateType":{},"Version":{}},"required":["LastModifiedDate","CreationDate","TemplateName","TemplateType"]}},"required":["SMSTemplateResponse"],"payload":"SMSTemplateResponse"}},"GetUserEndpoints":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/users/{user-id}","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"UserId":{"location":"uri","locationName":"user-id"}},"required":["ApplicationId","UserId"]},"output":{"type":"structure","members":{"EndpointsResponse":{"shape":"S5j"}},"required":["EndpointsResponse"],"payload":"EndpointsResponse"}},"GetVoiceChannel":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/channels/voice","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"VoiceChannelResponse":{"shape":"S5n"}},"required":["VoiceChannelResponse"],"payload":"VoiceChannelResponse"}},"GetVoiceTemplate":{"http":{"method":"GET","requestUri":"/v1/templates/{template-name}/voice","responseCode":200},"input":{"type":"structure","members":{"TemplateName":{"location":"uri","locationName":"template-name"},"Version":{"location":"querystring","locationName":"version"}},"required":["TemplateName"]},"output":{"type":"structure","members":{"VoiceTemplateResponse":{"type":"structure","members":{"Arn":{},"Body":{},"CreationDate":{},"DefaultSubstitutions":{},"LanguageCode":{},"LastModifiedDate":{},"tags":{"shape":"S4","locationName":"tags"},"TemplateDescription":{},"TemplateName":{},"TemplateType":{},"Version":{},"VoiceId":{}},"required":["LastModifiedDate","CreationDate","TemplateName","TemplateType"]}},"required":["VoiceTemplateResponse"],"payload":"VoiceTemplateResponse"}},"ListJourneys":{"http":{"method":"GET","requestUri":"/v1/apps/{application-id}/journeys","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"PageSize":{"location":"querystring","locationName":"page-size"},"Token":{"location":"querystring","locationName":"token"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"JourneysResponse":{"type":"structure","members":{"Item":{"type":"list","member":{"shape":"S30"}},"NextToken":{}},"required":["Item"]}},"required":["JourneysResponse"],"payload":"JourneysResponse"}},"ListTagsForResource":{"http":{"method":"GET","requestUri":"/v1/tags/{resource-arn}","responseCode":200},"input":{"type":"structure","members":{"ResourceArn":{"location":"uri","locationName":"resource-arn"}},"required":["ResourceArn"]},"output":{"type":"structure","members":{"TagsModel":{"shape":"S9a"}},"required":["TagsModel"],"payload":"TagsModel"}},"ListTemplateVersions":{"http":{"method":"GET","requestUri":"/v1/templates/{template-name}/{template-type}/versions","responseCode":200},"input":{"type":"structure","members":{"NextToken":{"location":"querystring","locationName":"next-token"},"PageSize":{"location":"querystring","locationName":"page-size"},"TemplateName":{"location":"uri","locationName":"template-name"},"TemplateType":{"location":"uri","locationName":"template-type"}},"required":["TemplateName","TemplateType"]},"output":{"type":"structure","members":{"TemplateVersionsResponse":{"type":"structure","members":{"Item":{"type":"list","member":{"type":"structure","members":{"CreationDate":{},"DefaultSubstitutions":{},"LastModifiedDate":{},"TemplateDescription":{},"TemplateName":{},"TemplateType":{},"Version":{}},"required":["LastModifiedDate","CreationDate","TemplateName","TemplateType"]}},"Message":{},"NextToken":{},"RequestID":{}},"required":["Item"]}},"required":["TemplateVersionsResponse"],"payload":"TemplateVersionsResponse"}},"ListTemplates":{"http":{"method":"GET","requestUri":"/v1/templates","responseCode":200},"input":{"type":"structure","members":{"NextToken":{"location":"querystring","locationName":"next-token"},"PageSize":{"location":"querystring","locationName":"page-size"},"Prefix":{"location":"querystring","locationName":"prefix"},"TemplateType":{"location":"querystring","locationName":"template-type"}}},"output":{"type":"structure","members":{"TemplatesResponse":{"type":"structure","members":{"Item":{"type":"list","member":{"type":"structure","members":{"Arn":{},"CreationDate":{},"DefaultSubstitutions":{},"LastModifiedDate":{},"tags":{"shape":"S4","locationName":"tags"},"TemplateDescription":{},"TemplateName":{},"TemplateType":{},"Version":{}},"required":["LastModifiedDate","CreationDate","TemplateName","TemplateType"]}},"NextToken":{}},"required":["Item"]}},"required":["TemplatesResponse"],"payload":"TemplatesResponse"}},"PhoneNumberValidate":{"http":{"requestUri":"/v1/phone/number/validate","responseCode":200},"input":{"type":"structure","members":{"NumberValidateRequest":{"type":"structure","members":{"IsoCountryCode":{},"PhoneNumber":{}}}},"required":["NumberValidateRequest"],"payload":"NumberValidateRequest"},"output":{"type":"structure","members":{"NumberValidateResponse":{"type":"structure","members":{"Carrier":{},"City":{},"CleansedPhoneNumberE164":{},"CleansedPhoneNumberNational":{},"Country":{},"CountryCodeIso2":{},"CountryCodeNumeric":{},"County":{},"OriginalCountryCodeIso2":{},"OriginalPhoneNumber":{},"PhoneType":{},"PhoneTypeCode":{"type":"integer"},"Timezone":{},"ZipCode":{}}}},"required":["NumberValidateResponse"],"payload":"NumberValidateResponse"}},"PutEventStream":{"http":{"requestUri":"/v1/apps/{application-id}/eventstream","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"WriteEventStream":{"type":"structure","members":{"DestinationStreamArn":{},"RoleArn":{}},"required":["RoleArn","DestinationStreamArn"]}},"required":["ApplicationId","WriteEventStream"],"payload":"WriteEventStream"},"output":{"type":"structure","members":{"EventStream":{"shape":"S50"}},"required":["EventStream"],"payload":"EventStream"}},"PutEvents":{"http":{"requestUri":"/v1/apps/{application-id}/events","responseCode":202},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"EventsRequest":{"type":"structure","members":{"BatchItem":{"type":"map","key":{},"value":{"type":"structure","members":{"Endpoint":{"type":"structure","members":{"Address":{},"Attributes":{"shape":"S4s"},"ChannelType":{},"Demographic":{"shape":"S4u"},"EffectiveDate":{},"EndpointStatus":{},"Location":{"shape":"S4v"},"Metrics":{"shape":"S4w"},"OptOut":{},"RequestId":{},"User":{"shape":"S4x"}}},"Events":{"type":"map","key":{},"value":{"type":"structure","members":{"AppPackageName":{},"AppTitle":{},"AppVersionCode":{},"Attributes":{"shape":"S4"},"ClientSdkVersion":{},"EventType":{},"Metrics":{"shape":"S4w"},"SdkName":{},"Session":{"type":"structure","members":{"Duration":{"type":"integer"},"Id":{},"StartTimestamp":{},"StopTimestamp":{}},"required":["StartTimestamp","Id"]},"Timestamp":{}},"required":["EventType","Timestamp"]}}},"required":["Endpoint","Events"]}}},"required":["BatchItem"]}},"required":["ApplicationId","EventsRequest"],"payload":"EventsRequest"},"output":{"type":"structure","members":{"EventsResponse":{"type":"structure","members":{"Results":{"type":"map","key":{},"value":{"type":"structure","members":{"EndpointItemResponse":{"type":"structure","members":{"Message":{},"StatusCode":{"type":"integer"}}},"EventsItemResponse":{"type":"map","key":{},"value":{"type":"structure","members":{"Message":{},"StatusCode":{"type":"integer"}}}}}}}}}},"required":["EventsResponse"],"payload":"EventsResponse"}},"RemoveAttributes":{"http":{"method":"PUT","requestUri":"/v1/apps/{application-id}/attributes/{attribute-type}","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"AttributeType":{"location":"uri","locationName":"attribute-type"},"UpdateAttributesRequest":{"type":"structure","members":{"Blacklist":{"shape":"St"}}}},"required":["AttributeType","ApplicationId","UpdateAttributesRequest"],"payload":"UpdateAttributesRequest"},"output":{"type":"structure","members":{"AttributesResource":{"type":"structure","members":{"ApplicationId":{},"AttributeType":{},"Attributes":{"shape":"St"}},"required":["AttributeType","ApplicationId"]}},"required":["AttributesResource"],"payload":"AttributesResource"}},"SendMessages":{"http":{"requestUri":"/v1/apps/{application-id}/messages","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"MessageRequest":{"type":"structure","members":{"Addresses":{"type":"map","key":{},"value":{"type":"structure","members":{"BodyOverride":{},"ChannelType":{},"Context":{"shape":"S4"},"RawContent":{},"Substitutions":{"shape":"S4s"},"TitleOverride":{}}}},"Context":{"shape":"S4"},"Endpoints":{"shape":"Saf"},"MessageConfiguration":{"shape":"Sah"},"TemplateConfiguration":{"shape":"S12"},"TraceId":{}},"required":["MessageConfiguration"]}},"required":["ApplicationId","MessageRequest"],"payload":"MessageRequest"},"output":{"type":"structure","members":{"MessageResponse":{"type":"structure","members":{"ApplicationId":{},"EndpointResult":{"shape":"Sax"},"RequestId":{},"Result":{"type":"map","key":{},"value":{"type":"structure","members":{"DeliveryStatus":{},"MessageId":{},"StatusCode":{"type":"integer"},"StatusMessage":{},"UpdatedToken":{}},"required":["DeliveryStatus","StatusCode"]}}},"required":["ApplicationId"]}},"required":["MessageResponse"],"payload":"MessageResponse"}},"SendUsersMessages":{"http":{"requestUri":"/v1/apps/{application-id}/users-messages","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"SendUsersMessageRequest":{"type":"structure","members":{"Context":{"shape":"S4"},"MessageConfiguration":{"shape":"Sah"},"TemplateConfiguration":{"shape":"S12"},"TraceId":{},"Users":{"shape":"Saf"}},"required":["MessageConfiguration","Users"]}},"required":["ApplicationId","SendUsersMessageRequest"],"payload":"SendUsersMessageRequest"},"output":{"type":"structure","members":{"SendUsersMessageResponse":{"type":"structure","members":{"ApplicationId":{},"RequestId":{},"Result":{"type":"map","key":{},"value":{"shape":"Sax"}}},"required":["ApplicationId"]}},"required":["SendUsersMessageResponse"],"payload":"SendUsersMessageResponse"}},"TagResource":{"http":{"requestUri":"/v1/tags/{resource-arn}","responseCode":204},"input":{"type":"structure","members":{"ResourceArn":{"location":"uri","locationName":"resource-arn"},"TagsModel":{"shape":"S9a"}},"required":["ResourceArn","TagsModel"],"payload":"TagsModel"}},"UntagResource":{"http":{"method":"DELETE","requestUri":"/v1/tags/{resource-arn}","responseCode":204},"input":{"type":"structure","members":{"ResourceArn":{"location":"uri","locationName":"resource-arn"},"TagKeys":{"shape":"St","location":"querystring","locationName":"tagKeys"}},"required":["TagKeys","ResourceArn"]}},"UpdateAdmChannel":{"http":{"method":"PUT","requestUri":"/v1/apps/{application-id}/channels/adm","responseCode":200},"input":{"type":"structure","members":{"ADMChannelRequest":{"type":"structure","members":{"ClientId":{},"ClientSecret":{},"Enabled":{"type":"boolean"}},"required":["ClientSecret","ClientId"]},"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId","ADMChannelRequest"],"payload":"ADMChannelRequest"},"output":{"type":"structure","members":{"ADMChannelResponse":{"shape":"S3z"}},"required":["ADMChannelResponse"],"payload":"ADMChannelResponse"}},"UpdateApnsChannel":{"http":{"method":"PUT","requestUri":"/v1/apps/{application-id}/channels/apns","responseCode":200},"input":{"type":"structure","members":{"APNSChannelRequest":{"type":"structure","members":{"BundleId":{},"Certificate":{},"DefaultAuthenticationMethod":{},"Enabled":{"type":"boolean"},"PrivateKey":{},"TeamId":{},"TokenKey":{},"TokenKeyId":{}}},"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId","APNSChannelRequest"],"payload":"APNSChannelRequest"},"output":{"type":"structure","members":{"APNSChannelResponse":{"shape":"S42"}},"required":["APNSChannelResponse"],"payload":"APNSChannelResponse"}},"UpdateApnsSandboxChannel":{"http":{"method":"PUT","requestUri":"/v1/apps/{application-id}/channels/apns_sandbox","responseCode":200},"input":{"type":"structure","members":{"APNSSandboxChannelRequest":{"type":"structure","members":{"BundleId":{},"Certificate":{},"DefaultAuthenticationMethod":{},"Enabled":{"type":"boolean"},"PrivateKey":{},"TeamId":{},"TokenKey":{},"TokenKeyId":{}}},"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId","APNSSandboxChannelRequest"],"payload":"APNSSandboxChannelRequest"},"output":{"type":"structure","members":{"APNSSandboxChannelResponse":{"shape":"S45"}},"required":["APNSSandboxChannelResponse"],"payload":"APNSSandboxChannelResponse"}},"UpdateApnsVoipChannel":{"http":{"method":"PUT","requestUri":"/v1/apps/{application-id}/channels/apns_voip","responseCode":200},"input":{"type":"structure","members":{"APNSVoipChannelRequest":{"type":"structure","members":{"BundleId":{},"Certificate":{},"DefaultAuthenticationMethod":{},"Enabled":{"type":"boolean"},"PrivateKey":{},"TeamId":{},"TokenKey":{},"TokenKeyId":{}}},"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId","APNSVoipChannelRequest"],"payload":"APNSVoipChannelRequest"},"output":{"type":"structure","members":{"APNSVoipChannelResponse":{"shape":"S48"}},"required":["APNSVoipChannelResponse"],"payload":"APNSVoipChannelResponse"}},"UpdateApnsVoipSandboxChannel":{"http":{"method":"PUT","requestUri":"/v1/apps/{application-id}/channels/apns_voip_sandbox","responseCode":200},"input":{"type":"structure","members":{"APNSVoipSandboxChannelRequest":{"type":"structure","members":{"BundleId":{},"Certificate":{},"DefaultAuthenticationMethod":{},"Enabled":{"type":"boolean"},"PrivateKey":{},"TeamId":{},"TokenKey":{},"TokenKeyId":{}}},"ApplicationId":{"location":"uri","locationName":"application-id"}},"required":["ApplicationId","APNSVoipSandboxChannelRequest"],"payload":"APNSVoipSandboxChannelRequest"},"output":{"type":"structure","members":{"APNSVoipSandboxChannelResponse":{"shape":"S4b"}},"required":["APNSVoipSandboxChannelResponse"],"payload":"APNSVoipSandboxChannelResponse"}},"UpdateApplicationSettings":{"http":{"method":"PUT","requestUri":"/v1/apps/{application-id}/settings","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"WriteApplicationSettingsRequest":{"type":"structure","members":{"CampaignHook":{"shape":"S14"},"CloudWatchMetricsEnabled":{"type":"boolean"},"Limits":{"shape":"S16"},"QuietTime":{"shape":"S11"}}}},"required":["ApplicationId","WriteApplicationSettingsRequest"],"payload":"WriteApplicationSettingsRequest"},"output":{"type":"structure","members":{"ApplicationSettingsResource":{"shape":"S6c"}},"required":["ApplicationSettingsResource"],"payload":"ApplicationSettingsResource"}},"UpdateBaiduChannel":{"http":{"method":"PUT","requestUri":"/v1/apps/{application-id}/channels/baidu","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"BaiduChannelRequest":{"type":"structure","members":{"ApiKey":{},"Enabled":{"type":"boolean"},"SecretKey":{}},"required":["SecretKey","ApiKey"]}},"required":["ApplicationId","BaiduChannelRequest"],"payload":"BaiduChannelRequest"},"output":{"type":"structure","members":{"BaiduChannelResponse":{"shape":"S4g"}},"required":["BaiduChannelResponse"],"payload":"BaiduChannelResponse"}},"UpdateCampaign":{"http":{"method":"PUT","requestUri":"/v1/apps/{application-id}/campaigns/{campaign-id}","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"CampaignId":{"location":"uri","locationName":"campaign-id"},"WriteCampaignRequest":{"shape":"S8"}},"required":["CampaignId","ApplicationId","WriteCampaignRequest"],"payload":"WriteCampaignRequest"},"output":{"type":"structure","members":{"CampaignResponse":{"shape":"S18"}},"required":["CampaignResponse"],"payload":"CampaignResponse"}},"UpdateEmailChannel":{"http":{"method":"PUT","requestUri":"/v1/apps/{application-id}/channels/email","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"EmailChannelRequest":{"type":"structure","members":{"ConfigurationSet":{},"Enabled":{"type":"boolean"},"FromAddress":{},"Identity":{},"RoleArn":{}},"required":["FromAddress","Identity"]}},"required":["ApplicationId","EmailChannelRequest"],"payload":"EmailChannelRequest"},"output":{"type":"structure","members":{"EmailChannelResponse":{"shape":"S4l"}},"required":["EmailChannelResponse"],"payload":"EmailChannelResponse"}},"UpdateEmailTemplate":{"http":{"method":"PUT","requestUri":"/v1/templates/{template-name}/email","responseCode":202},"input":{"type":"structure","members":{"CreateNewVersion":{"location":"querystring","locationName":"create-new-version","type":"boolean"},"EmailTemplateRequest":{"shape":"S1e"},"TemplateName":{"location":"uri","locationName":"template-name"},"Version":{"location":"querystring","locationName":"version"}},"required":["TemplateName","EmailTemplateRequest"],"payload":"EmailTemplateRequest"},"output":{"type":"structure","members":{"MessageBody":{"shape":"S4o"}},"required":["MessageBody"],"payload":"MessageBody"}},"UpdateEndpoint":{"http":{"method":"PUT","requestUri":"/v1/apps/{application-id}/endpoints/{endpoint-id}","responseCode":202},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"EndpointId":{"location":"uri","locationName":"endpoint-id"},"EndpointRequest":{"type":"structure","members":{"Address":{},"Attributes":{"shape":"S4s"},"ChannelType":{},"Demographic":{"shape":"S4u"},"EffectiveDate":{},"EndpointStatus":{},"Location":{"shape":"S4v"},"Metrics":{"shape":"S4w"},"OptOut":{},"RequestId":{},"User":{"shape":"S4x"}}}},"required":["ApplicationId","EndpointId","EndpointRequest"],"payload":"EndpointRequest"},"output":{"type":"structure","members":{"MessageBody":{"shape":"S4o"}},"required":["MessageBody"],"payload":"MessageBody"}},"UpdateEndpointsBatch":{"http":{"method":"PUT","requestUri":"/v1/apps/{application-id}/endpoints","responseCode":202},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"EndpointBatchRequest":{"type":"structure","members":{"Item":{"type":"list","member":{"type":"structure","members":{"Address":{},"Attributes":{"shape":"S4s"},"ChannelType":{},"Demographic":{"shape":"S4u"},"EffectiveDate":{},"EndpointStatus":{},"Id":{},"Location":{"shape":"S4v"},"Metrics":{"shape":"S4w"},"OptOut":{},"RequestId":{},"User":{"shape":"S4x"}}}}},"required":["Item"]}},"required":["ApplicationId","EndpointBatchRequest"],"payload":"EndpointBatchRequest"},"output":{"type":"structure","members":{"MessageBody":{"shape":"S4o"}},"required":["MessageBody"],"payload":"MessageBody"}},"UpdateGcmChannel":{"http":{"method":"PUT","requestUri":"/v1/apps/{application-id}/channels/gcm","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"GCMChannelRequest":{"type":"structure","members":{"ApiKey":{},"Enabled":{"type":"boolean"}},"required":["ApiKey"]}},"required":["ApplicationId","GCMChannelRequest"],"payload":"GCMChannelRequest"},"output":{"type":"structure","members":{"GCMChannelResponse":{"shape":"S53"}},"required":["GCMChannelResponse"],"payload":"GCMChannelResponse"}},"UpdateJourney":{"http":{"method":"PUT","requestUri":"/v1/apps/{application-id}/journeys/{journey-id}","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"JourneyId":{"location":"uri","locationName":"journey-id"},"WriteJourneyRequest":{"shape":"S1u"}},"required":["JourneyId","ApplicationId","WriteJourneyRequest"],"payload":"WriteJourneyRequest"},"output":{"type":"structure","members":{"JourneyResponse":{"shape":"S30"}},"required":["JourneyResponse"],"payload":"JourneyResponse"}},"UpdateJourneyState":{"http":{"method":"PUT","requestUri":"/v1/apps/{application-id}/journeys/{journey-id}/state","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"JourneyId":{"location":"uri","locationName":"journey-id"},"JourneyStateRequest":{"type":"structure","members":{"State":{}}}},"required":["JourneyId","ApplicationId","JourneyStateRequest"],"payload":"JourneyStateRequest"},"output":{"type":"structure","members":{"JourneyResponse":{"shape":"S30"}},"required":["JourneyResponse"],"payload":"JourneyResponse"}},"UpdatePushTemplate":{"http":{"method":"PUT","requestUri":"/v1/templates/{template-name}/push","responseCode":202},"input":{"type":"structure","members":{"CreateNewVersion":{"location":"querystring","locationName":"create-new-version","type":"boolean"},"PushNotificationTemplateRequest":{"shape":"S32"},"TemplateName":{"location":"uri","locationName":"template-name"},"Version":{"location":"querystring","locationName":"version"}},"required":["TemplateName","PushNotificationTemplateRequest"],"payload":"PushNotificationTemplateRequest"},"output":{"type":"structure","members":{"MessageBody":{"shape":"S4o"}},"required":["MessageBody"],"payload":"MessageBody"}},"UpdateRecommenderConfiguration":{"http":{"method":"PUT","requestUri":"/v1/recommenders/{recommender-id}","responseCode":200},"input":{"type":"structure","members":{"RecommenderId":{"location":"uri","locationName":"recommender-id"},"UpdateRecommenderConfiguration":{"type":"structure","members":{"Attributes":{"shape":"S4"},"Description":{},"Name":{},"RecommendationProviderIdType":{},"RecommendationProviderRoleArn":{},"RecommendationProviderUri":{},"RecommendationTransformerUri":{},"RecommendationsDisplayName":{},"RecommendationsPerMessage":{"type":"integer"}},"required":["RecommendationProviderUri","RecommendationProviderRoleArn"]}},"required":["RecommenderId","UpdateRecommenderConfiguration"],"payload":"UpdateRecommenderConfiguration"},"output":{"type":"structure","members":{"RecommenderConfigurationResponse":{"shape":"S3a"}},"required":["RecommenderConfigurationResponse"],"payload":"RecommenderConfigurationResponse"}},"UpdateSegment":{"http":{"method":"PUT","requestUri":"/v1/apps/{application-id}/segments/{segment-id}","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"SegmentId":{"location":"uri","locationName":"segment-id"},"WriteSegmentRequest":{"shape":"S3c"}},"required":["SegmentId","ApplicationId","WriteSegmentRequest"],"payload":"WriteSegmentRequest"},"output":{"type":"structure","members":{"SegmentResponse":{"shape":"S3n"}},"required":["SegmentResponse"],"payload":"SegmentResponse"}},"UpdateSmsChannel":{"http":{"method":"PUT","requestUri":"/v1/apps/{application-id}/channels/sms","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"SMSChannelRequest":{"type":"structure","members":{"Enabled":{"type":"boolean"},"SenderId":{},"ShortCode":{}}}},"required":["ApplicationId","SMSChannelRequest"],"payload":"SMSChannelRequest"},"output":{"type":"structure","members":{"SMSChannelResponse":{"shape":"S5e"}},"required":["SMSChannelResponse"],"payload":"SMSChannelResponse"}},"UpdateSmsTemplate":{"http":{"method":"PUT","requestUri":"/v1/templates/{template-name}/sms","responseCode":202},"input":{"type":"structure","members":{"CreateNewVersion":{"location":"querystring","locationName":"create-new-version","type":"boolean"},"SMSTemplateRequest":{"shape":"S3s"},"TemplateName":{"location":"uri","locationName":"template-name"},"Version":{"location":"querystring","locationName":"version"}},"required":["TemplateName","SMSTemplateRequest"],"payload":"SMSTemplateRequest"},"output":{"type":"structure","members":{"MessageBody":{"shape":"S4o"}},"required":["MessageBody"],"payload":"MessageBody"}},"UpdateTemplateActiveVersion":{"http":{"method":"PUT","requestUri":"/v1/templates/{template-name}/{template-type}/active-version","responseCode":200},"input":{"type":"structure","members":{"TemplateActiveVersionRequest":{"type":"structure","members":{"Version":{}}},"TemplateName":{"location":"uri","locationName":"template-name"},"TemplateType":{"location":"uri","locationName":"template-type"}},"required":["TemplateName","TemplateType","TemplateActiveVersionRequest"],"payload":"TemplateActiveVersionRequest"},"output":{"type":"structure","members":{"MessageBody":{"shape":"S4o"}},"required":["MessageBody"],"payload":"MessageBody"}},"UpdateVoiceChannel":{"http":{"method":"PUT","requestUri":"/v1/apps/{application-id}/channels/voice","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"application-id"},"VoiceChannelRequest":{"type":"structure","members":{"Enabled":{"type":"boolean"}}}},"required":["ApplicationId","VoiceChannelRequest"],"payload":"VoiceChannelRequest"},"output":{"type":"structure","members":{"VoiceChannelResponse":{"shape":"S5n"}},"required":["VoiceChannelResponse"],"payload":"VoiceChannelResponse"}},"UpdateVoiceTemplate":{"http":{"method":"PUT","requestUri":"/v1/templates/{template-name}/voice","responseCode":202},"input":{"type":"structure","members":{"CreateNewVersion":{"location":"querystring","locationName":"create-new-version","type":"boolean"},"TemplateName":{"location":"uri","locationName":"template-name"},"Version":{"location":"querystring","locationName":"version"},"VoiceTemplateRequest":{"shape":"S3v"}},"required":["TemplateName","VoiceTemplateRequest"],"payload":"VoiceTemplateRequest"},"output":{"type":"structure","members":{"MessageBody":{"shape":"S4o"}},"required":["MessageBody"],"payload":"MessageBody"}}},"shapes":{"S4":{"type":"map","key":{},"value":{}},"S6":{"type":"structure","members":{"Arn":{},"Id":{},"Name":{},"tags":{"shape":"S4","locationName":"tags"}},"required":["Id","Arn","Name"]},"S8":{"type":"structure","members":{"AdditionalTreatments":{"type":"list","member":{"type":"structure","members":{"CustomDeliveryConfiguration":{"shape":"Sb"},"MessageConfiguration":{"shape":"Se"},"Schedule":{"shape":"Sn"},"SizePercent":{"type":"integer"},"TemplateConfiguration":{"shape":"S12"},"TreatmentDescription":{},"TreatmentName":{}},"required":["SizePercent"]}},"CustomDeliveryConfiguration":{"shape":"Sb"},"Description":{},"HoldoutPercent":{"type":"integer"},"Hook":{"shape":"S14"},"IsPaused":{"type":"boolean"},"Limits":{"shape":"S16"},"MessageConfiguration":{"shape":"Se"},"Name":{},"Schedule":{"shape":"Sn"},"SegmentId":{},"SegmentVersion":{"type":"integer"},"tags":{"shape":"S4","locationName":"tags"},"TemplateConfiguration":{"shape":"S12"},"TreatmentDescription":{},"TreatmentName":{}}},"Sb":{"type":"structure","members":{"DeliveryUri":{},"EndpointTypes":{"shape":"Sc"}},"required":["DeliveryUri"]},"Sc":{"type":"list","member":{}},"Se":{"type":"structure","members":{"ADMMessage":{"shape":"Sf"},"APNSMessage":{"shape":"Sf"},"BaiduMessage":{"shape":"Sf"},"CustomMessage":{"type":"structure","members":{"Data":{}}},"DefaultMessage":{"shape":"Sf"},"EmailMessage":{"type":"structure","members":{"Body":{},"FromAddress":{},"HtmlBody":{},"Title":{}}},"GCMMessage":{"shape":"Sf"},"SMSMessage":{"type":"structure","members":{"Body":{},"MessageType":{},"SenderId":{}}}}},"Sf":{"type":"structure","members":{"Action":{},"Body":{},"ImageIconUrl":{},"ImageSmallIconUrl":{},"ImageUrl":{},"JsonBody":{},"MediaUrl":{},"RawContent":{},"SilentPush":{"type":"boolean"},"TimeToLive":{"type":"integer"},"Title":{},"Url":{}}},"Sn":{"type":"structure","members":{"EndTime":{},"EventFilter":{"type":"structure","members":{"Dimensions":{"shape":"Sp"},"FilterType":{}},"required":["FilterType","Dimensions"]},"Frequency":{},"IsLocalTime":{"type":"boolean"},"QuietTime":{"shape":"S11"},"StartTime":{},"Timezone":{}},"required":["StartTime"]},"Sp":{"type":"structure","members":{"Attributes":{"shape":"Sq"},"EventType":{"shape":"Su"},"Metrics":{"shape":"Sw"}}},"Sq":{"type":"map","key":{},"value":{"type":"structure","members":{"AttributeType":{},"Values":{"shape":"St"}},"required":["Values"]}},"St":{"type":"list","member":{}},"Su":{"type":"structure","members":{"DimensionType":{},"Values":{"shape":"St"}},"required":["Values"]},"Sw":{"type":"map","key":{},"value":{"type":"structure","members":{"ComparisonOperator":{},"Value":{"type":"double"}},"required":["ComparisonOperator","Value"]}},"S11":{"type":"structure","members":{"End":{},"Start":{}}},"S12":{"type":"structure","members":{"EmailTemplate":{"shape":"S13"},"PushTemplate":{"shape":"S13"},"SMSTemplate":{"shape":"S13"},"VoiceTemplate":{"shape":"S13"}}},"S13":{"type":"structure","members":{"Name":{},"Version":{}}},"S14":{"type":"structure","members":{"LambdaFunctionName":{},"Mode":{},"WebUrl":{}}},"S16":{"type":"structure","members":{"Daily":{"type":"integer"},"MaximumDuration":{"type":"integer"},"MessagesPerSecond":{"type":"integer"},"Total":{"type":"integer"}}},"S18":{"type":"structure","members":{"AdditionalTreatments":{"type":"list","member":{"type":"structure","members":{"CustomDeliveryConfiguration":{"shape":"Sb"},"Id":{},"MessageConfiguration":{"shape":"Se"},"Schedule":{"shape":"Sn"},"SizePercent":{"type":"integer"},"State":{"shape":"S1b"},"TemplateConfiguration":{"shape":"S12"},"TreatmentDescription":{},"TreatmentName":{}},"required":["Id","SizePercent"]}},"ApplicationId":{},"Arn":{},"CreationDate":{},"CustomDeliveryConfiguration":{"shape":"Sb"},"DefaultState":{"shape":"S1b"},"Description":{},"HoldoutPercent":{"type":"integer"},"Hook":{"shape":"S14"},"Id":{},"IsPaused":{"type":"boolean"},"LastModifiedDate":{},"Limits":{"shape":"S16"},"MessageConfiguration":{"shape":"Se"},"Name":{},"Schedule":{"shape":"Sn"},"SegmentId":{},"SegmentVersion":{"type":"integer"},"State":{"shape":"S1b"},"tags":{"shape":"S4","locationName":"tags"},"TemplateConfiguration":{"shape":"S12"},"TreatmentDescription":{},"TreatmentName":{},"Version":{"type":"integer"}},"required":["LastModifiedDate","CreationDate","SegmentId","SegmentVersion","Id","Arn","ApplicationId"]},"S1b":{"type":"structure","members":{"CampaignStatus":{}}},"S1e":{"type":"structure","members":{"DefaultSubstitutions":{},"HtmlPart":{},"RecommenderId":{},"Subject":{},"tags":{"shape":"S4","locationName":"tags"},"TemplateDescription":{},"TextPart":{}}},"S1g":{"type":"structure","members":{"Arn":{},"Message":{},"RequestID":{}}},"S1k":{"type":"structure","members":{"ApplicationId":{},"CompletedPieces":{"type":"integer"},"CompletionDate":{},"CreationDate":{},"Definition":{"type":"structure","members":{"RoleArn":{},"S3UrlPrefix":{},"SegmentId":{},"SegmentVersion":{"type":"integer"}},"required":["S3UrlPrefix","RoleArn"]},"FailedPieces":{"type":"integer"},"Failures":{"shape":"St"},"Id":{},"JobStatus":{},"TotalFailures":{"type":"integer"},"TotalPieces":{"type":"integer"},"TotalProcessed":{"type":"integer"},"Type":{}},"required":["JobStatus","CreationDate","Type","Definition","Id","ApplicationId"]},"S1r":{"type":"structure","members":{"ApplicationId":{},"CompletedPieces":{"type":"integer"},"CompletionDate":{},"CreationDate":{},"Definition":{"type":"structure","members":{"DefineSegment":{"type":"boolean"},"ExternalId":{},"Format":{},"RegisterEndpoints":{"type":"boolean"},"RoleArn":{},"S3Url":{},"SegmentId":{},"SegmentName":{}},"required":["Format","S3Url","RoleArn"]},"FailedPieces":{"type":"integer"},"Failures":{"shape":"St"},"Id":{},"JobStatus":{},"TotalFailures":{"type":"integer"},"TotalPieces":{"type":"integer"},"TotalProcessed":{"type":"integer"},"Type":{}},"required":["JobStatus","CreationDate","Type","Definition","Id","ApplicationId"]},"S1u":{"type":"structure","members":{"Activities":{"shape":"S1v"},"CreationDate":{},"LastModifiedDate":{},"Limits":{"shape":"S2u"},"LocalTime":{"type":"boolean"},"Name":{},"QuietTime":{"shape":"S11"},"RefreshFrequency":{},"Schedule":{"shape":"S2v"},"StartActivity":{},"StartCondition":{"shape":"S2x"},"State":{}},"required":["Name"]},"S1v":{"type":"map","key":{},"value":{"type":"structure","members":{"CUSTOM":{"type":"structure","members":{"DeliveryUri":{},"EndpointTypes":{"shape":"Sc"},"MessageConfig":{"type":"structure","members":{"Data":{}}},"NextActivity":{},"TemplateName":{},"TemplateVersion":{}}},"ConditionalSplit":{"type":"structure","members":{"Condition":{"type":"structure","members":{"Conditions":{"type":"list","member":{"shape":"S22"}},"Operator":{}}},"EvaluationWaitTime":{"shape":"S2f"},"FalseActivity":{},"TrueActivity":{}}},"Description":{},"EMAIL":{"type":"structure","members":{"MessageConfig":{"type":"structure","members":{"FromAddress":{}}},"NextActivity":{},"TemplateName":{},"TemplateVersion":{}}},"Holdout":{"type":"structure","members":{"NextActivity":{},"Percentage":{"type":"integer"}},"required":["Percentage"]},"MultiCondition":{"type":"structure","members":{"Branches":{"type":"list","member":{"type":"structure","members":{"Condition":{"shape":"S22"},"NextActivity":{}}}},"DefaultActivity":{},"EvaluationWaitTime":{"shape":"S2f"}}},"PUSH":{"type":"structure","members":{"MessageConfig":{"type":"structure","members":{"TimeToLive":{}}},"NextActivity":{},"TemplateName":{},"TemplateVersion":{}}},"RandomSplit":{"type":"structure","members":{"Branches":{"type":"list","member":{"type":"structure","members":{"NextActivity":{},"Percentage":{"type":"integer"}}}}}},"SMS":{"type":"structure","members":{"MessageConfig":{"type":"structure","members":{"MessageType":{},"SenderId":{}}},"NextActivity":{},"TemplateName":{},"TemplateVersion":{}}},"Wait":{"type":"structure","members":{"NextActivity":{},"WaitTime":{"shape":"S2f"}}}}}},"S22":{"type":"structure","members":{"EventCondition":{"type":"structure","members":{"Dimensions":{"shape":"Sp"},"MessageActivity":{}}},"SegmentCondition":{"shape":"S24"},"SegmentDimensions":{"shape":"S25","locationName":"segmentDimensions"}}},"S24":{"type":"structure","members":{"SegmentId":{}},"required":["SegmentId"]},"S25":{"type":"structure","members":{"Attributes":{"shape":"Sq"},"Behavior":{"type":"structure","members":{"Recency":{"type":"structure","members":{"Duration":{},"RecencyType":{}},"required":["Duration","RecencyType"]}}},"Demographic":{"type":"structure","members":{"AppVersion":{"shape":"Su"},"Channel":{"shape":"Su"},"DeviceType":{"shape":"Su"},"Make":{"shape":"Su"},"Model":{"shape":"Su"},"Platform":{"shape":"Su"}}},"Location":{"type":"structure","members":{"Country":{"shape":"Su"},"GPSPoint":{"type":"structure","members":{"Coordinates":{"type":"structure","members":{"Latitude":{"type":"double"},"Longitude":{"type":"double"}},"required":["Latitude","Longitude"]},"RangeInKilometers":{"type":"double"}},"required":["Coordinates"]}}},"Metrics":{"shape":"Sw"},"UserAttributes":{"shape":"Sq"}}},"S2f":{"type":"structure","members":{"WaitFor":{},"WaitUntil":{}}},"S2u":{"type":"structure","members":{"DailyCap":{"type":"integer"},"EndpointReentryCap":{"type":"integer"},"MessagesPerSecond":{"type":"integer"}}},"S2v":{"type":"structure","members":{"EndTime":{"shape":"S2w"},"StartTime":{"shape":"S2w"},"Timezone":{}}},"S2w":{"type":"timestamp","timestampFormat":"iso8601"},"S2x":{"type":"structure","members":{"Description":{},"SegmentStartCondition":{"shape":"S24"}}},"S30":{"type":"structure","members":{"Activities":{"shape":"S1v"},"ApplicationId":{},"CreationDate":{},"Id":{},"LastModifiedDate":{},"Limits":{"shape":"S2u"},"LocalTime":{"type":"boolean"},"Name":{},"QuietTime":{"shape":"S11"},"RefreshFrequency":{},"Schedule":{"shape":"S2v"},"StartActivity":{},"StartCondition":{"shape":"S2x"},"State":{},"tags":{"shape":"S4","locationName":"tags"}},"required":["Name","Id","ApplicationId"]},"S32":{"type":"structure","members":{"ADM":{"shape":"S33"},"APNS":{"shape":"S34"},"Baidu":{"shape":"S33"},"Default":{"shape":"S35"},"DefaultSubstitutions":{},"GCM":{"shape":"S33"},"RecommenderId":{},"tags":{"shape":"S4","locationName":"tags"},"TemplateDescription":{}}},"S33":{"type":"structure","members":{"Action":{},"Body":{},"ImageIconUrl":{},"ImageUrl":{},"RawContent":{},"SmallImageIconUrl":{},"Sound":{},"Title":{},"Url":{}}},"S34":{"type":"structure","members":{"Action":{},"Body":{},"MediaUrl":{},"RawContent":{},"Sound":{},"Title":{},"Url":{}}},"S35":{"type":"structure","members":{"Action":{},"Body":{},"Sound":{},"Title":{},"Url":{}}},"S3a":{"type":"structure","members":{"Attributes":{"shape":"S4"},"CreationDate":{},"Description":{},"Id":{},"LastModifiedDate":{},"Name":{},"RecommendationProviderIdType":{},"RecommendationProviderRoleArn":{},"RecommendationProviderUri":{},"RecommendationTransformerUri":{},"RecommendationsDisplayName":{},"RecommendationsPerMessage":{"type":"integer"}},"required":["RecommendationProviderUri","LastModifiedDate","CreationDate","RecommendationProviderRoleArn","Id"]},"S3c":{"type":"structure","members":{"Dimensions":{"shape":"S25"},"Name":{},"SegmentGroups":{"shape":"S3d"},"tags":{"shape":"S4","locationName":"tags"}}},"S3d":{"type":"structure","members":{"Groups":{"type":"list","member":{"type":"structure","members":{"Dimensions":{"type":"list","member":{"shape":"S25"}},"SourceSegments":{"type":"list","member":{"type":"structure","members":{"Id":{},"Version":{"type":"integer"}},"required":["Id"]}},"SourceType":{},"Type":{}}}},"Include":{}}},"S3n":{"type":"structure","members":{"ApplicationId":{},"Arn":{},"CreationDate":{},"Dimensions":{"shape":"S25"},"Id":{},"ImportDefinition":{"type":"structure","members":{"ChannelCounts":{"type":"map","key":{},"value":{"type":"integer"}},"ExternalId":{},"Format":{},"RoleArn":{},"S3Url":{},"Size":{"type":"integer"}},"required":["Format","S3Url","Size","ExternalId","RoleArn"]},"LastModifiedDate":{},"Name":{},"SegmentGroups":{"shape":"S3d"},"SegmentType":{},"tags":{"shape":"S4","locationName":"tags"},"Version":{"type":"integer"}},"required":["SegmentType","CreationDate","Id","Arn","ApplicationId"]},"S3s":{"type":"structure","members":{"Body":{},"DefaultSubstitutions":{},"RecommenderId":{},"tags":{"shape":"S4","locationName":"tags"},"TemplateDescription":{}}},"S3v":{"type":"structure","members":{"Body":{},"DefaultSubstitutions":{},"LanguageCode":{},"tags":{"shape":"S4","locationName":"tags"},"TemplateDescription":{},"VoiceId":{}}},"S3z":{"type":"structure","members":{"ApplicationId":{},"CreationDate":{},"Enabled":{"type":"boolean"},"HasCredential":{"type":"boolean"},"Id":{},"IsArchived":{"type":"boolean"},"LastModifiedBy":{},"LastModifiedDate":{},"Platform":{},"Version":{"type":"integer"}},"required":["Platform"]},"S42":{"type":"structure","members":{"ApplicationId":{},"CreationDate":{},"DefaultAuthenticationMethod":{},"Enabled":{"type":"boolean"},"HasCredential":{"type":"boolean"},"HasTokenKey":{"type":"boolean"},"Id":{},"IsArchived":{"type":"boolean"},"LastModifiedBy":{},"LastModifiedDate":{},"Platform":{},"Version":{"type":"integer"}},"required":["Platform"]},"S45":{"type":"structure","members":{"ApplicationId":{},"CreationDate":{},"DefaultAuthenticationMethod":{},"Enabled":{"type":"boolean"},"HasCredential":{"type":"boolean"},"HasTokenKey":{"type":"boolean"},"Id":{},"IsArchived":{"type":"boolean"},"LastModifiedBy":{},"LastModifiedDate":{},"Platform":{},"Version":{"type":"integer"}},"required":["Platform"]},"S48":{"type":"structure","members":{"ApplicationId":{},"CreationDate":{},"DefaultAuthenticationMethod":{},"Enabled":{"type":"boolean"},"HasCredential":{"type":"boolean"},"HasTokenKey":{"type":"boolean"},"Id":{},"IsArchived":{"type":"boolean"},"LastModifiedBy":{},"LastModifiedDate":{},"Platform":{},"Version":{"type":"integer"}},"required":["Platform"]},"S4b":{"type":"structure","members":{"ApplicationId":{},"CreationDate":{},"DefaultAuthenticationMethod":{},"Enabled":{"type":"boolean"},"HasCredential":{"type":"boolean"},"HasTokenKey":{"type":"boolean"},"Id":{},"IsArchived":{"type":"boolean"},"LastModifiedBy":{},"LastModifiedDate":{},"Platform":{},"Version":{"type":"integer"}},"required":["Platform"]},"S4g":{"type":"structure","members":{"ApplicationId":{},"CreationDate":{},"Credential":{},"Enabled":{"type":"boolean"},"HasCredential":{"type":"boolean"},"Id":{},"IsArchived":{"type":"boolean"},"LastModifiedBy":{},"LastModifiedDate":{},"Platform":{},"Version":{"type":"integer"}},"required":["Credential","Platform"]},"S4l":{"type":"structure","members":{"ApplicationId":{},"ConfigurationSet":{},"CreationDate":{},"Enabled":{"type":"boolean"},"FromAddress":{},"HasCredential":{"type":"boolean"},"Id":{},"Identity":{},"IsArchived":{"type":"boolean"},"LastModifiedBy":{},"LastModifiedDate":{},"MessagesPerSecond":{"type":"integer"},"Platform":{},"RoleArn":{},"Version":{"type":"integer"}},"required":["Platform"]},"S4o":{"type":"structure","members":{"Message":{},"RequestID":{}}},"S4r":{"type":"structure","members":{"Address":{},"ApplicationId":{},"Attributes":{"shape":"S4s"},"ChannelType":{},"CohortId":{},"CreationDate":{},"Demographic":{"shape":"S4u"},"EffectiveDate":{},"EndpointStatus":{},"Id":{},"Location":{"shape":"S4v"},"Metrics":{"shape":"S4w"},"OptOut":{},"RequestId":{},"User":{"shape":"S4x"}}},"S4s":{"type":"map","key":{},"value":{"shape":"St"}},"S4u":{"type":"structure","members":{"AppVersion":{},"Locale":{},"Make":{},"Model":{},"ModelVersion":{},"Platform":{},"PlatformVersion":{},"Timezone":{}}},"S4v":{"type":"structure","members":{"City":{},"Country":{},"Latitude":{"type":"double"},"Longitude":{"type":"double"},"PostalCode":{},"Region":{}}},"S4w":{"type":"map","key":{},"value":{"type":"double"}},"S4x":{"type":"structure","members":{"UserAttributes":{"shape":"S4s"},"UserId":{}}},"S50":{"type":"structure","members":{"ApplicationId":{},"DestinationStreamArn":{},"ExternalId":{},"LastModifiedDate":{},"LastUpdatedBy":{},"RoleArn":{}},"required":["ApplicationId","RoleArn","DestinationStreamArn"]},"S53":{"type":"structure","members":{"ApplicationId":{},"CreationDate":{},"Credential":{},"Enabled":{"type":"boolean"},"HasCredential":{"type":"boolean"},"Id":{},"IsArchived":{"type":"boolean"},"LastModifiedBy":{},"LastModifiedDate":{},"Platform":{},"Version":{"type":"integer"}},"required":["Credential","Platform"]},"S5e":{"type":"structure","members":{"ApplicationId":{},"CreationDate":{},"Enabled":{"type":"boolean"},"HasCredential":{"type":"boolean"},"Id":{},"IsArchived":{"type":"boolean"},"LastModifiedBy":{},"LastModifiedDate":{},"Platform":{},"PromotionalMessagesPerSecond":{"type":"integer"},"SenderId":{},"ShortCode":{},"TransactionalMessagesPerSecond":{"type":"integer"},"Version":{"type":"integer"}},"required":["Platform"]},"S5j":{"type":"structure","members":{"Item":{"type":"list","member":{"shape":"S4r"}}},"required":["Item"]},"S5n":{"type":"structure","members":{"ApplicationId":{},"CreationDate":{},"Enabled":{"type":"boolean"},"HasCredential":{"type":"boolean"},"Id":{},"IsArchived":{"type":"boolean"},"LastModifiedBy":{},"LastModifiedDate":{},"Platform":{},"Version":{"type":"integer"}},"required":["Platform"]},"S65":{"type":"structure","members":{"Rows":{"type":"list","member":{"type":"structure","members":{"GroupedBys":{"shape":"S68"},"Values":{"shape":"S68"}},"required":["GroupedBys","Values"]}}},"required":["Rows"]},"S68":{"type":"list","member":{"type":"structure","members":{"Key":{},"Type":{},"Value":{}},"required":["Type","Value","Key"]}},"S6c":{"type":"structure","members":{"ApplicationId":{},"CampaignHook":{"shape":"S14"},"LastModifiedDate":{},"Limits":{"shape":"S16"},"QuietTime":{"shape":"S11"}},"required":["ApplicationId"]},"S6x":{"type":"structure","members":{"Item":{"type":"list","member":{"shape":"S18"}},"NextToken":{}},"required":["Item"]},"S7k":{"type":"structure","members":{"Item":{"type":"list","member":{"shape":"S1k"}},"NextToken":{}},"required":["Item"]},"S7s":{"type":"structure","members":{"Item":{"type":"list","member":{"shape":"S1r"}},"NextToken":{}},"required":["Item"]},"S8o":{"type":"structure","members":{"Item":{"type":"list","member":{"shape":"S3n"}},"NextToken":{}},"required":["Item"]},"S9a":{"type":"structure","members":{"tags":{"shape":"S4","locationName":"tags"}},"required":["tags"]},"Saf":{"type":"map","key":{},"value":{"type":"structure","members":{"BodyOverride":{},"Context":{"shape":"S4"},"RawContent":{},"Substitutions":{"shape":"S4s"},"TitleOverride":{}}}},"Sah":{"type":"structure","members":{"ADMMessage":{"type":"structure","members":{"Action":{},"Body":{},"ConsolidationKey":{},"Data":{"shape":"S4"},"ExpiresAfter":{},"IconReference":{},"ImageIconUrl":{},"ImageUrl":{},"MD5":{},"RawContent":{},"SilentPush":{"type":"boolean"},"SmallImageIconUrl":{},"Sound":{},"Substitutions":{"shape":"S4s"},"Title":{},"Url":{}}},"APNSMessage":{"type":"structure","members":{"APNSPushType":{},"Action":{},"Badge":{"type":"integer"},"Body":{},"Category":{},"CollapseId":{},"Data":{"shape":"S4"},"MediaUrl":{},"PreferredAuthenticationMethod":{},"Priority":{},"RawContent":{},"SilentPush":{"type":"boolean"},"Sound":{},"Substitutions":{"shape":"S4s"},"ThreadId":{},"TimeToLive":{"type":"integer"},"Title":{},"Url":{}}},"BaiduMessage":{"type":"structure","members":{"Action":{},"Body":{},"Data":{"shape":"S4"},"IconReference":{},"ImageIconUrl":{},"ImageUrl":{},"RawContent":{},"SilentPush":{"type":"boolean"},"SmallImageIconUrl":{},"Sound":{},"Substitutions":{"shape":"S4s"},"TimeToLive":{"type":"integer"},"Title":{},"Url":{}}},"DefaultMessage":{"type":"structure","members":{"Body":{},"Substitutions":{"shape":"S4s"}}},"DefaultPushNotificationMessage":{"type":"structure","members":{"Action":{},"Body":{},"Data":{"shape":"S4"},"SilentPush":{"type":"boolean"},"Substitutions":{"shape":"S4s"},"Title":{},"Url":{}}},"EmailMessage":{"type":"structure","members":{"Body":{},"FeedbackForwardingAddress":{},"FromAddress":{},"RawEmail":{"type":"structure","members":{"Data":{"type":"blob"}}},"ReplyToAddresses":{"shape":"St"},"SimpleEmail":{"type":"structure","members":{"HtmlPart":{"shape":"Sar"},"Subject":{"shape":"Sar"},"TextPart":{"shape":"Sar"}}},"Substitutions":{"shape":"S4s"}}},"GCMMessage":{"type":"structure","members":{"Action":{},"Body":{},"CollapseKey":{},"Data":{"shape":"S4"},"IconReference":{},"ImageIconUrl":{},"ImageUrl":{},"Priority":{},"RawContent":{},"RestrictedPackageName":{},"SilentPush":{"type":"boolean"},"SmallImageIconUrl":{},"Sound":{},"Substitutions":{"shape":"S4s"},"TimeToLive":{"type":"integer"},"Title":{},"Url":{}}},"SMSMessage":{"type":"structure","members":{"Body":{},"Keyword":{},"MediaUrl":{},"MessageType":{},"OriginationNumber":{},"SenderId":{},"Substitutions":{"shape":"S4s"}}},"VoiceMessage":{"type":"structure","members":{"Body":{},"LanguageCode":{},"OriginationNumber":{},"Substitutions":{"shape":"S4s"},"VoiceId":{}}}}},"Sar":{"type":"structure","members":{"Charset":{},"Data":{}}},"Sax":{"type":"map","key":{},"value":{"type":"structure","members":{"Address":{},"DeliveryStatus":{},"MessageId":{},"StatusCode":{"type":"integer"},"StatusMessage":{},"UpdatedToken":{}},"required":["DeliveryStatus","StatusCode"]}}}}; +class RecordHandlerProgressCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "RecordHandlerProgress", {}) + .n("CloudFormationClient", "RecordHandlerProgressCommand") + .sc(RecordHandlerProgress) + .build() { +} -/***/ }), +class RegisterPublisherCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "RegisterPublisher", {}) + .n("CloudFormationClient", "RegisterPublisherCommand") + .sc(RegisterPublisher) + .build() { +} -/***/ 1009: -/***/ (function(module) { +class RegisterTypeCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "RegisterType", {}) + .n("CloudFormationClient", "RegisterTypeCommand") + .sc(RegisterType) + .build() { +} -module.exports = {"pagination":{"DescribeCachediSCSIVolumes":{"result_key":"CachediSCSIVolumes"},"DescribeStorediSCSIVolumes":{"result_key":"StorediSCSIVolumes"},"DescribeTapeArchives":{"input_token":"Marker","limit_key":"Limit","output_token":"Marker","result_key":"TapeArchives"},"DescribeTapeRecoveryPoints":{"input_token":"Marker","limit_key":"Limit","output_token":"Marker","result_key":"TapeRecoveryPointInfos"},"DescribeTapes":{"input_token":"Marker","limit_key":"Limit","output_token":"Marker","result_key":"Tapes"},"DescribeVTLDevices":{"input_token":"Marker","limit_key":"Limit","output_token":"Marker","result_key":"VTLDevices"},"ListFileShares":{"input_token":"Marker","limit_key":"Limit","non_aggregate_keys":["Marker"],"output_token":"NextMarker","result_key":"FileShareInfoList"},"ListGateways":{"input_token":"Marker","limit_key":"Limit","output_token":"Marker","result_key":"Gateways"},"ListLocalDisks":{"result_key":"Disks"},"ListTagsForResource":{"input_token":"Marker","limit_key":"Limit","non_aggregate_keys":["ResourceARN"],"output_token":"Marker","result_key":"Tags"},"ListTapes":{"input_token":"Marker","limit_key":"Limit","output_token":"Marker","result_key":"TapeInfos"},"ListVolumeRecoveryPoints":{"result_key":"VolumeRecoveryPointInfos"},"ListVolumes":{"input_token":"Marker","limit_key":"Limit","output_token":"Marker","result_key":"VolumeInfos"}}}; +class RollbackStackCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "RollbackStack", {}) + .n("CloudFormationClient", "RollbackStackCommand") + .sc(RollbackStack) + .build() { +} -/***/ }), +class SetStackPolicyCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "SetStackPolicy", {}) + .n("CloudFormationClient", "SetStackPolicyCommand") + .sc(SetStackPolicy) + .build() { +} -/***/ 1010: -/***/ (function(module) { +class SetTypeConfigurationCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "SetTypeConfiguration", {}) + .n("CloudFormationClient", "SetTypeConfigurationCommand") + .sc(SetTypeConfiguration) + .build() { +} -module.exports = {"version":"2.0","metadata":{"apiVersion":"2013-04-15","endpointPrefix":"support","jsonVersion":"1.1","protocol":"json","serviceFullName":"AWS Support","serviceId":"Support","signatureVersion":"v4","targetPrefix":"AWSSupport_20130415","uid":"support-2013-04-15"},"operations":{"AddAttachmentsToSet":{"input":{"type":"structure","required":["attachments"],"members":{"attachmentSetId":{},"attachments":{"type":"list","member":{"shape":"S4"}}}},"output":{"type":"structure","members":{"attachmentSetId":{},"expiryTime":{}}}},"AddCommunicationToCase":{"input":{"type":"structure","required":["communicationBody"],"members":{"caseId":{},"communicationBody":{},"ccEmailAddresses":{"shape":"Sc"},"attachmentSetId":{}}},"output":{"type":"structure","members":{"result":{"type":"boolean"}}}},"CreateCase":{"input":{"type":"structure","required":["subject","communicationBody"],"members":{"subject":{},"serviceCode":{},"severityCode":{},"categoryCode":{},"communicationBody":{},"ccEmailAddresses":{"shape":"Sc"},"language":{},"issueType":{},"attachmentSetId":{}}},"output":{"type":"structure","members":{"caseId":{}}}},"DescribeAttachment":{"input":{"type":"structure","required":["attachmentId"],"members":{"attachmentId":{}}},"output":{"type":"structure","members":{"attachment":{"shape":"S4"}}}},"DescribeCases":{"input":{"type":"structure","members":{"caseIdList":{"type":"list","member":{}},"displayId":{},"afterTime":{},"beforeTime":{},"includeResolvedCases":{"type":"boolean"},"nextToken":{},"maxResults":{"type":"integer"},"language":{},"includeCommunications":{"type":"boolean"}}},"output":{"type":"structure","members":{"cases":{"type":"list","member":{"type":"structure","members":{"caseId":{},"displayId":{},"subject":{},"status":{},"serviceCode":{},"categoryCode":{},"severityCode":{},"submittedBy":{},"timeCreated":{},"recentCommunications":{"type":"structure","members":{"communications":{"shape":"S17"},"nextToken":{}}},"ccEmailAddresses":{"shape":"Sc"},"language":{}}}},"nextToken":{}}}},"DescribeCommunications":{"input":{"type":"structure","required":["caseId"],"members":{"caseId":{},"beforeTime":{},"afterTime":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"communications":{"shape":"S17"},"nextToken":{}}}},"DescribeServices":{"input":{"type":"structure","members":{"serviceCodeList":{"type":"list","member":{}},"language":{}}},"output":{"type":"structure","members":{"services":{"type":"list","member":{"type":"structure","members":{"code":{},"name":{},"categories":{"type":"list","member":{"type":"structure","members":{"code":{},"name":{}}}}}}}}}},"DescribeSeverityLevels":{"input":{"type":"structure","members":{"language":{}}},"output":{"type":"structure","members":{"severityLevels":{"type":"list","member":{"type":"structure","members":{"code":{},"name":{}}}}}}},"DescribeTrustedAdvisorCheckRefreshStatuses":{"input":{"type":"structure","required":["checkIds"],"members":{"checkIds":{"shape":"S1t"}}},"output":{"type":"structure","required":["statuses"],"members":{"statuses":{"type":"list","member":{"shape":"S1x"}}}}},"DescribeTrustedAdvisorCheckResult":{"input":{"type":"structure","required":["checkId"],"members":{"checkId":{},"language":{}}},"output":{"type":"structure","members":{"result":{"type":"structure","required":["checkId","timestamp","status","resourcesSummary","categorySpecificSummary","flaggedResources"],"members":{"checkId":{},"timestamp":{},"status":{},"resourcesSummary":{"shape":"S22"},"categorySpecificSummary":{"shape":"S23"},"flaggedResources":{"type":"list","member":{"type":"structure","required":["status","resourceId","metadata"],"members":{"status":{},"region":{},"resourceId":{},"isSuppressed":{"type":"boolean"},"metadata":{"shape":"S1t"}}}}}}}}},"DescribeTrustedAdvisorCheckSummaries":{"input":{"type":"structure","required":["checkIds"],"members":{"checkIds":{"shape":"S1t"}}},"output":{"type":"structure","required":["summaries"],"members":{"summaries":{"type":"list","member":{"type":"structure","required":["checkId","timestamp","status","resourcesSummary","categorySpecificSummary"],"members":{"checkId":{},"timestamp":{},"status":{},"hasFlaggedResources":{"type":"boolean"},"resourcesSummary":{"shape":"S22"},"categorySpecificSummary":{"shape":"S23"}}}}}}},"DescribeTrustedAdvisorChecks":{"input":{"type":"structure","required":["language"],"members":{"language":{}}},"output":{"type":"structure","required":["checks"],"members":{"checks":{"type":"list","member":{"type":"structure","required":["id","name","description","category","metadata"],"members":{"id":{},"name":{},"description":{},"category":{},"metadata":{"shape":"S1t"}}}}}}},"RefreshTrustedAdvisorCheck":{"input":{"type":"structure","required":["checkId"],"members":{"checkId":{}}},"output":{"type":"structure","required":["status"],"members":{"status":{"shape":"S1x"}}}},"ResolveCase":{"input":{"type":"structure","members":{"caseId":{}}},"output":{"type":"structure","members":{"initialCaseStatus":{},"finalCaseStatus":{}}}}},"shapes":{"S4":{"type":"structure","members":{"fileName":{},"data":{"type":"blob"}}},"Sc":{"type":"list","member":{}},"S17":{"type":"list","member":{"type":"structure","members":{"caseId":{},"body":{},"submittedBy":{},"timeCreated":{},"attachmentSet":{"type":"list","member":{"type":"structure","members":{"attachmentId":{},"fileName":{}}}}}}},"S1t":{"type":"list","member":{}},"S1x":{"type":"structure","required":["checkId","status","millisUntilNextRefreshable"],"members":{"checkId":{},"status":{},"millisUntilNextRefreshable":{"type":"long"}}},"S22":{"type":"structure","required":["resourcesProcessed","resourcesFlagged","resourcesIgnored","resourcesSuppressed"],"members":{"resourcesProcessed":{"type":"long"},"resourcesFlagged":{"type":"long"},"resourcesIgnored":{"type":"long"},"resourcesSuppressed":{"type":"long"}}},"S23":{"type":"structure","members":{"costOptimizing":{"type":"structure","required":["estimatedMonthlySavings","estimatedPercentMonthlySavings"],"members":{"estimatedMonthlySavings":{"type":"double"},"estimatedPercentMonthlySavings":{"type":"double"}}}}}}}; +class SetTypeDefaultVersionCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "SetTypeDefaultVersion", {}) + .n("CloudFormationClient", "SetTypeDefaultVersionCommand") + .sc(SetTypeDefaultVersion) + .build() { +} -/***/ }), +class SignalResourceCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "SignalResource", {}) + .n("CloudFormationClient", "SignalResourceCommand") + .sc(SignalResource) + .build() { +} -/***/ 1015: -/***/ (function(module, __unusedexports, __webpack_require__) { +class StartResourceScanCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "StartResourceScan", {}) + .n("CloudFormationClient", "StartResourceScanCommand") + .sc(StartResourceScan) + .build() { +} -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +class StopStackSetOperationCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "StopStackSetOperation", {}) + .n("CloudFormationClient", "StopStackSetOperationCommand") + .sc(StopStackSetOperation) + .build() { +} -apiLoader.services['xray'] = {}; -AWS.XRay = Service.defineService('xray', ['2016-04-12']); -Object.defineProperty(apiLoader.services['xray'], '2016-04-12', { - get: function get() { - var model = __webpack_require__(5840); - model.paginators = __webpack_require__(5093).pagination; - return model; - }, - enumerable: true, - configurable: true -}); +class TestTypeCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "TestType", {}) + .n("CloudFormationClient", "TestTypeCommand") + .sc(TestType) + .build() { +} -module.exports = AWS.XRay; +class UpdateGeneratedTemplateCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "UpdateGeneratedTemplate", {}) + .n("CloudFormationClient", "UpdateGeneratedTemplateCommand") + .sc(UpdateGeneratedTemplate) + .build() { +} +class UpdateStackCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "UpdateStack", {}) + .n("CloudFormationClient", "UpdateStackCommand") + .sc(UpdateStack) + .build() { +} -/***/ }), +class UpdateStackInstancesCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "UpdateStackInstances", {}) + .n("CloudFormationClient", "UpdateStackInstancesCommand") + .sc(UpdateStackInstances) + .build() { +} -/***/ 1032: -/***/ (function(module, __unusedexports, __webpack_require__) { +class UpdateStackSetCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "UpdateStackSet", {}) + .n("CloudFormationClient", "UpdateStackSetCommand") + .sc(UpdateStackSet) + .build() { +} -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +class UpdateTerminationProtectionCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "UpdateTerminationProtection", {}) + .n("CloudFormationClient", "UpdateTerminationProtectionCommand") + .sc(UpdateTerminationProtection) + .build() { +} -apiLoader.services['pi'] = {}; -AWS.PI = Service.defineService('pi', ['2018-02-27']); -Object.defineProperty(apiLoader.services['pi'], '2018-02-27', { - get: function get() { - var model = __webpack_require__(2490); - model.paginators = __webpack_require__(6202).pagination; - return model; - }, - enumerable: true, - configurable: true -}); +class ValidateTemplateCommand extends smithyClient.Command + .classBuilder() + .ep(commonParams) + .m(function (Command, cs, config, o) { + return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())]; +}) + .s("CloudFormation", "ValidateTemplate", {}) + .n("CloudFormationClient", "ValidateTemplateCommand") + .sc(ValidateTemplate) + .build() { +} -module.exports = AWS.PI; +const commands = { + ActivateOrganizationsAccessCommand, + ActivateTypeCommand, + BatchDescribeTypeConfigurationsCommand, + CancelUpdateStackCommand, + ContinueUpdateRollbackCommand, + CreateChangeSetCommand, + CreateGeneratedTemplateCommand, + CreateStackCommand, + CreateStackInstancesCommand, + CreateStackRefactorCommand, + CreateStackSetCommand, + DeactivateOrganizationsAccessCommand, + DeactivateTypeCommand, + DeleteChangeSetCommand, + DeleteGeneratedTemplateCommand, + DeleteStackCommand, + DeleteStackInstancesCommand, + DeleteStackSetCommand, + DeregisterTypeCommand, + DescribeAccountLimitsCommand, + DescribeChangeSetCommand, + DescribeChangeSetHooksCommand, + DescribeEventsCommand, + DescribeGeneratedTemplateCommand, + DescribeOrganizationsAccessCommand, + DescribePublisherCommand, + DescribeResourceScanCommand, + DescribeStackDriftDetectionStatusCommand, + DescribeStackEventsCommand, + DescribeStackInstanceCommand, + DescribeStackRefactorCommand, + DescribeStackResourceCommand, + DescribeStackResourceDriftsCommand, + DescribeStackResourcesCommand, + DescribeStacksCommand, + DescribeStackSetCommand, + DescribeStackSetOperationCommand, + DescribeTypeCommand, + DescribeTypeRegistrationCommand, + DetectStackDriftCommand, + DetectStackResourceDriftCommand, + DetectStackSetDriftCommand, + EstimateTemplateCostCommand, + ExecuteChangeSetCommand, + ExecuteStackRefactorCommand, + GetGeneratedTemplateCommand, + GetHookResultCommand, + GetStackPolicyCommand, + GetTemplateCommand, + GetTemplateSummaryCommand, + ImportStacksToStackSetCommand, + ListChangeSetsCommand, + ListExportsCommand, + ListGeneratedTemplatesCommand, + ListHookResultsCommand, + ListImportsCommand, + ListResourceScanRelatedResourcesCommand, + ListResourceScanResourcesCommand, + ListResourceScansCommand, + ListStackInstanceResourceDriftsCommand, + ListStackInstancesCommand, + ListStackRefactorActionsCommand, + ListStackRefactorsCommand, + ListStackResourcesCommand, + ListStacksCommand, + ListStackSetAutoDeploymentTargetsCommand, + ListStackSetOperationResultsCommand, + ListStackSetOperationsCommand, + ListStackSetsCommand, + ListTypeRegistrationsCommand, + ListTypesCommand, + ListTypeVersionsCommand, + PublishTypeCommand, + RecordHandlerProgressCommand, + RegisterPublisherCommand, + RegisterTypeCommand, + RollbackStackCommand, + SetStackPolicyCommand, + SetTypeConfigurationCommand, + SetTypeDefaultVersionCommand, + SignalResourceCommand, + StartResourceScanCommand, + StopStackSetOperationCommand, + TestTypeCommand, + UpdateGeneratedTemplateCommand, + UpdateStackCommand, + UpdateStackInstancesCommand, + UpdateStackSetCommand, + UpdateTerminationProtectionCommand, + ValidateTemplateCommand, +}; +class CloudFormation extends CloudFormationClient { +} +smithyClient.createAggregatedClient(commands, CloudFormation); +const paginateDescribeAccountLimits = core.createPaginator(CloudFormationClient, DescribeAccountLimitsCommand, "NextToken", "NextToken", ""); -/***/ }), +const paginateDescribeChangeSet = core.createPaginator(CloudFormationClient, DescribeChangeSetCommand, "NextToken", "NextToken", ""); -/***/ 1033: -/***/ (function(module) { +const paginateDescribeEvents = core.createPaginator(CloudFormationClient, DescribeEventsCommand, "NextToken", "NextToken", ""); -module.exports = {"version":"2.0","metadata":{"apiVersion":"2016-01-01","endpointPrefix":"dms","jsonVersion":"1.1","protocol":"json","serviceFullName":"AWS Database Migration Service","serviceId":"Database Migration Service","signatureVersion":"v4","targetPrefix":"AmazonDMSv20160101","uid":"dms-2016-01-01"},"operations":{"AddTagsToResource":{"input":{"type":"structure","required":["ResourceArn","Tags"],"members":{"ResourceArn":{},"Tags":{"shape":"S3"}}},"output":{"type":"structure","members":{}}},"ApplyPendingMaintenanceAction":{"input":{"type":"structure","required":["ReplicationInstanceArn","ApplyAction","OptInType"],"members":{"ReplicationInstanceArn":{},"ApplyAction":{},"OptInType":{}}},"output":{"type":"structure","members":{"ResourcePendingMaintenanceActions":{"shape":"S8"}}}},"CancelReplicationTaskAssessmentRun":{"input":{"type":"structure","required":["ReplicationTaskAssessmentRunArn"],"members":{"ReplicationTaskAssessmentRunArn":{}}},"output":{"type":"structure","members":{"ReplicationTaskAssessmentRun":{"shape":"Se"}}}},"CreateEndpoint":{"input":{"type":"structure","required":["EndpointIdentifier","EndpointType","EngineName"],"members":{"EndpointIdentifier":{},"EndpointType":{},"EngineName":{},"Username":{},"Password":{"shape":"Sj"},"ServerName":{},"Port":{"type":"integer"},"DatabaseName":{},"ExtraConnectionAttributes":{},"KmsKeyId":{},"Tags":{"shape":"S3"},"CertificateArn":{},"SslMode":{},"ServiceAccessRoleArn":{},"ExternalTableDefinition":{},"DynamoDbSettings":{"shape":"Sm"},"S3Settings":{"shape":"Sn"},"DmsTransferSettings":{"shape":"Su"},"MongoDbSettings":{"shape":"Sv"},"KinesisSettings":{"shape":"Sz"},"KafkaSettings":{"shape":"S11"},"ElasticsearchSettings":{"shape":"S12"},"NeptuneSettings":{"shape":"S13"},"RedshiftSettings":{"shape":"S14"},"PostgreSQLSettings":{"shape":"S15"},"MySQLSettings":{"shape":"S16"},"OracleSettings":{"shape":"S17"},"SybaseSettings":{"shape":"S18"},"MicrosoftSQLServerSettings":{"shape":"S19"},"IBMDb2Settings":{"shape":"S1a"}}},"output":{"type":"structure","members":{"Endpoint":{"shape":"S1c"}}}},"CreateEventSubscription":{"input":{"type":"structure","required":["SubscriptionName","SnsTopicArn"],"members":{"SubscriptionName":{},"SnsTopicArn":{},"SourceType":{},"EventCategories":{"shape":"S1e"},"SourceIds":{"shape":"S1f"},"Enabled":{"type":"boolean"},"Tags":{"shape":"S3"}}},"output":{"type":"structure","members":{"EventSubscription":{"shape":"S1h"}}}},"CreateReplicationInstance":{"input":{"type":"structure","required":["ReplicationInstanceIdentifier","ReplicationInstanceClass"],"members":{"ReplicationInstanceIdentifier":{},"AllocatedStorage":{"type":"integer"},"ReplicationInstanceClass":{},"VpcSecurityGroupIds":{"shape":"S1k"},"AvailabilityZone":{},"ReplicationSubnetGroupIdentifier":{},"PreferredMaintenanceWindow":{},"MultiAZ":{"type":"boolean"},"EngineVersion":{},"AutoMinorVersionUpgrade":{"type":"boolean"},"Tags":{"shape":"S3"},"KmsKeyId":{},"PubliclyAccessible":{"type":"boolean"},"DnsNameServers":{}}},"output":{"type":"structure","members":{"ReplicationInstance":{"shape":"S1m"}}}},"CreateReplicationSubnetGroup":{"input":{"type":"structure","required":["ReplicationSubnetGroupIdentifier","ReplicationSubnetGroupDescription","SubnetIds"],"members":{"ReplicationSubnetGroupIdentifier":{},"ReplicationSubnetGroupDescription":{},"SubnetIds":{"shape":"S1x"},"Tags":{"shape":"S3"}}},"output":{"type":"structure","members":{"ReplicationSubnetGroup":{"shape":"S1p"}}}},"CreateReplicationTask":{"input":{"type":"structure","required":["ReplicationTaskIdentifier","SourceEndpointArn","TargetEndpointArn","ReplicationInstanceArn","MigrationType","TableMappings"],"members":{"ReplicationTaskIdentifier":{},"SourceEndpointArn":{},"TargetEndpointArn":{},"ReplicationInstanceArn":{},"MigrationType":{},"TableMappings":{},"ReplicationTaskSettings":{},"CdcStartTime":{"type":"timestamp"},"CdcStartPosition":{},"CdcStopPosition":{},"Tags":{"shape":"S3"},"TaskData":{}}},"output":{"type":"structure","members":{"ReplicationTask":{"shape":"S22"}}}},"DeleteCertificate":{"input":{"type":"structure","required":["CertificateArn"],"members":{"CertificateArn":{}}},"output":{"type":"structure","members":{"Certificate":{"shape":"S27"}}}},"DeleteConnection":{"input":{"type":"structure","required":["EndpointArn","ReplicationInstanceArn"],"members":{"EndpointArn":{},"ReplicationInstanceArn":{}}},"output":{"type":"structure","members":{"Connection":{"shape":"S2b"}}}},"DeleteEndpoint":{"input":{"type":"structure","required":["EndpointArn"],"members":{"EndpointArn":{}}},"output":{"type":"structure","members":{"Endpoint":{"shape":"S1c"}}}},"DeleteEventSubscription":{"input":{"type":"structure","required":["SubscriptionName"],"members":{"SubscriptionName":{}}},"output":{"type":"structure","members":{"EventSubscription":{"shape":"S1h"}}}},"DeleteReplicationInstance":{"input":{"type":"structure","required":["ReplicationInstanceArn"],"members":{"ReplicationInstanceArn":{}}},"output":{"type":"structure","members":{"ReplicationInstance":{"shape":"S1m"}}}},"DeleteReplicationSubnetGroup":{"input":{"type":"structure","required":["ReplicationSubnetGroupIdentifier"],"members":{"ReplicationSubnetGroupIdentifier":{}}},"output":{"type":"structure","members":{}}},"DeleteReplicationTask":{"input":{"type":"structure","required":["ReplicationTaskArn"],"members":{"ReplicationTaskArn":{}}},"output":{"type":"structure","members":{"ReplicationTask":{"shape":"S22"}}}},"DeleteReplicationTaskAssessmentRun":{"input":{"type":"structure","required":["ReplicationTaskAssessmentRunArn"],"members":{"ReplicationTaskAssessmentRunArn":{}}},"output":{"type":"structure","members":{"ReplicationTaskAssessmentRun":{"shape":"Se"}}}},"DescribeAccountAttributes":{"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"AccountQuotas":{"type":"list","member":{"type":"structure","members":{"AccountQuotaName":{},"Used":{"type":"long"},"Max":{"type":"long"}}}},"UniqueAccountIdentifier":{}}}},"DescribeApplicableIndividualAssessments":{"input":{"type":"structure","members":{"ReplicationTaskArn":{},"ReplicationInstanceArn":{},"SourceEngineName":{},"TargetEngineName":{},"MigrationType":{},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"type":"structure","members":{"IndividualAssessmentNames":{"type":"list","member":{}},"Marker":{}}}},"DescribeCertificates":{"input":{"type":"structure","members":{"Filters":{"shape":"S2w"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"type":"structure","members":{"Marker":{},"Certificates":{"type":"list","member":{"shape":"S27"}}}}},"DescribeConnections":{"input":{"type":"structure","members":{"Filters":{"shape":"S2w"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"type":"structure","members":{"Marker":{},"Connections":{"type":"list","member":{"shape":"S2b"}}}}},"DescribeEndpointTypes":{"input":{"type":"structure","members":{"Filters":{"shape":"S2w"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"type":"structure","members":{"Marker":{},"SupportedEndpointTypes":{"type":"list","member":{"type":"structure","members":{"EngineName":{},"SupportsCDC":{"type":"boolean"},"EndpointType":{},"ReplicationInstanceEngineMinimumVersion":{},"EngineDisplayName":{}}}}}}},"DescribeEndpoints":{"input":{"type":"structure","members":{"Filters":{"shape":"S2w"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"type":"structure","members":{"Marker":{},"Endpoints":{"type":"list","member":{"shape":"S1c"}}}}},"DescribeEventCategories":{"input":{"type":"structure","members":{"SourceType":{},"Filters":{"shape":"S2w"}}},"output":{"type":"structure","members":{"EventCategoryGroupList":{"type":"list","member":{"type":"structure","members":{"SourceType":{},"EventCategories":{"shape":"S1e"}}}}}}},"DescribeEventSubscriptions":{"input":{"type":"structure","members":{"SubscriptionName":{},"Filters":{"shape":"S2w"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"type":"structure","members":{"Marker":{},"EventSubscriptionsList":{"type":"list","member":{"shape":"S1h"}}}}},"DescribeEvents":{"input":{"type":"structure","members":{"SourceIdentifier":{},"SourceType":{},"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"Duration":{"type":"integer"},"EventCategories":{"shape":"S1e"},"Filters":{"shape":"S2w"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"type":"structure","members":{"Marker":{},"Events":{"type":"list","member":{"type":"structure","members":{"SourceIdentifier":{},"SourceType":{},"Message":{},"EventCategories":{"shape":"S1e"},"Date":{"type":"timestamp"}}}}}}},"DescribeOrderableReplicationInstances":{"input":{"type":"structure","members":{"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"type":"structure","members":{"OrderableReplicationInstances":{"type":"list","member":{"type":"structure","members":{"EngineVersion":{},"ReplicationInstanceClass":{},"StorageType":{},"MinAllocatedStorage":{"type":"integer"},"MaxAllocatedStorage":{"type":"integer"},"DefaultAllocatedStorage":{"type":"integer"},"IncludedAllocatedStorage":{"type":"integer"},"AvailabilityZones":{"type":"list","member":{}},"ReleaseStatus":{}}}},"Marker":{}}}},"DescribePendingMaintenanceActions":{"input":{"type":"structure","members":{"ReplicationInstanceArn":{},"Filters":{"shape":"S2w"},"Marker":{},"MaxRecords":{"type":"integer"}}},"output":{"type":"structure","members":{"PendingMaintenanceActions":{"type":"list","member":{"shape":"S8"}},"Marker":{}}}},"DescribeRefreshSchemasStatus":{"input":{"type":"structure","required":["EndpointArn"],"members":{"EndpointArn":{}}},"output":{"type":"structure","members":{"RefreshSchemasStatus":{"shape":"S3y"}}}},"DescribeReplicationInstanceTaskLogs":{"input":{"type":"structure","required":["ReplicationInstanceArn"],"members":{"ReplicationInstanceArn":{},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"type":"structure","members":{"ReplicationInstanceArn":{},"ReplicationInstanceTaskLogs":{"type":"list","member":{"type":"structure","members":{"ReplicationTaskName":{},"ReplicationTaskArn":{},"ReplicationInstanceTaskLogSize":{"type":"long"}}}},"Marker":{}}}},"DescribeReplicationInstances":{"input":{"type":"structure","members":{"Filters":{"shape":"S2w"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"type":"structure","members":{"Marker":{},"ReplicationInstances":{"type":"list","member":{"shape":"S1m"}}}}},"DescribeReplicationSubnetGroups":{"input":{"type":"structure","members":{"Filters":{"shape":"S2w"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"type":"structure","members":{"Marker":{},"ReplicationSubnetGroups":{"type":"list","member":{"shape":"S1p"}}}}},"DescribeReplicationTaskAssessmentResults":{"input":{"type":"structure","members":{"ReplicationTaskArn":{},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"type":"structure","members":{"Marker":{},"BucketName":{},"ReplicationTaskAssessmentResults":{"type":"list","member":{"type":"structure","members":{"ReplicationTaskIdentifier":{},"ReplicationTaskArn":{},"ReplicationTaskLastAssessmentDate":{"type":"timestamp"},"AssessmentStatus":{},"AssessmentResultsFile":{},"AssessmentResults":{},"S3ObjectUrl":{}}}}}}},"DescribeReplicationTaskAssessmentRuns":{"input":{"type":"structure","members":{"Filters":{"shape":"S2w"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"type":"structure","members":{"Marker":{},"ReplicationTaskAssessmentRuns":{"type":"list","member":{"shape":"Se"}}}}},"DescribeReplicationTaskIndividualAssessments":{"input":{"type":"structure","members":{"Filters":{"shape":"S2w"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"type":"structure","members":{"Marker":{},"ReplicationTaskIndividualAssessments":{"type":"list","member":{"type":"structure","members":{"ReplicationTaskIndividualAssessmentArn":{},"ReplicationTaskAssessmentRunArn":{},"IndividualAssessmentName":{},"Status":{},"ReplicationTaskIndividualAssessmentStartDate":{"type":"timestamp"}}}}}}},"DescribeReplicationTasks":{"input":{"type":"structure","members":{"Filters":{"shape":"S2w"},"MaxRecords":{"type":"integer"},"Marker":{},"WithoutSettings":{"type":"boolean"}}},"output":{"type":"structure","members":{"Marker":{},"ReplicationTasks":{"type":"list","member":{"shape":"S22"}}}}},"DescribeSchemas":{"input":{"type":"structure","required":["EndpointArn"],"members":{"EndpointArn":{},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"type":"structure","members":{"Marker":{},"Schemas":{"type":"list","member":{}}}}},"DescribeTableStatistics":{"input":{"type":"structure","required":["ReplicationTaskArn"],"members":{"ReplicationTaskArn":{},"MaxRecords":{"type":"integer"},"Marker":{},"Filters":{"shape":"S2w"}}},"output":{"type":"structure","members":{"ReplicationTaskArn":{},"TableStatistics":{"type":"list","member":{"type":"structure","members":{"SchemaName":{},"TableName":{},"Inserts":{"type":"long"},"Deletes":{"type":"long"},"Updates":{"type":"long"},"Ddls":{"type":"long"},"FullLoadRows":{"type":"long"},"FullLoadCondtnlChkFailedRows":{"type":"long"},"FullLoadErrorRows":{"type":"long"},"FullLoadStartTime":{"type":"timestamp"},"FullLoadEndTime":{"type":"timestamp"},"FullLoadReloaded":{"type":"boolean"},"LastUpdateTime":{"type":"timestamp"},"TableState":{},"ValidationPendingRecords":{"type":"long"},"ValidationFailedRecords":{"type":"long"},"ValidationSuspendedRecords":{"type":"long"},"ValidationState":{},"ValidationStateDetails":{}}}},"Marker":{}}}},"ImportCertificate":{"input":{"type":"structure","required":["CertificateIdentifier"],"members":{"CertificateIdentifier":{},"CertificatePem":{},"CertificateWallet":{"type":"blob"},"Tags":{"shape":"S3"}}},"output":{"type":"structure","members":{"Certificate":{"shape":"S27"}}}},"ListTagsForResource":{"input":{"type":"structure","required":["ResourceArn"],"members":{"ResourceArn":{}}},"output":{"type":"structure","members":{"TagList":{"shape":"S3"}}}},"ModifyEndpoint":{"input":{"type":"structure","required":["EndpointArn"],"members":{"EndpointArn":{},"EndpointIdentifier":{},"EndpointType":{},"EngineName":{},"Username":{},"Password":{"shape":"Sj"},"ServerName":{},"Port":{"type":"integer"},"DatabaseName":{},"ExtraConnectionAttributes":{},"CertificateArn":{},"SslMode":{},"ServiceAccessRoleArn":{},"ExternalTableDefinition":{},"DynamoDbSettings":{"shape":"Sm"},"S3Settings":{"shape":"Sn"},"DmsTransferSettings":{"shape":"Su"},"MongoDbSettings":{"shape":"Sv"},"KinesisSettings":{"shape":"Sz"},"KafkaSettings":{"shape":"S11"},"ElasticsearchSettings":{"shape":"S12"},"NeptuneSettings":{"shape":"S13"},"RedshiftSettings":{"shape":"S14"},"PostgreSQLSettings":{"shape":"S15"},"MySQLSettings":{"shape":"S16"},"OracleSettings":{"shape":"S17"},"SybaseSettings":{"shape":"S18"},"MicrosoftSQLServerSettings":{"shape":"S19"},"IBMDb2Settings":{"shape":"S1a"}}},"output":{"type":"structure","members":{"Endpoint":{"shape":"S1c"}}}},"ModifyEventSubscription":{"input":{"type":"structure","required":["SubscriptionName"],"members":{"SubscriptionName":{},"SnsTopicArn":{},"SourceType":{},"EventCategories":{"shape":"S1e"},"Enabled":{"type":"boolean"}}},"output":{"type":"structure","members":{"EventSubscription":{"shape":"S1h"}}}},"ModifyReplicationInstance":{"input":{"type":"structure","required":["ReplicationInstanceArn"],"members":{"ReplicationInstanceArn":{},"AllocatedStorage":{"type":"integer"},"ApplyImmediately":{"type":"boolean"},"ReplicationInstanceClass":{},"VpcSecurityGroupIds":{"shape":"S1k"},"PreferredMaintenanceWindow":{},"MultiAZ":{"type":"boolean"},"EngineVersion":{},"AllowMajorVersionUpgrade":{"type":"boolean"},"AutoMinorVersionUpgrade":{"type":"boolean"},"ReplicationInstanceIdentifier":{}}},"output":{"type":"structure","members":{"ReplicationInstance":{"shape":"S1m"}}}},"ModifyReplicationSubnetGroup":{"input":{"type":"structure","required":["ReplicationSubnetGroupIdentifier","SubnetIds"],"members":{"ReplicationSubnetGroupIdentifier":{},"ReplicationSubnetGroupDescription":{},"SubnetIds":{"shape":"S1x"}}},"output":{"type":"structure","members":{"ReplicationSubnetGroup":{"shape":"S1p"}}}},"ModifyReplicationTask":{"input":{"type":"structure","required":["ReplicationTaskArn"],"members":{"ReplicationTaskArn":{},"ReplicationTaskIdentifier":{},"MigrationType":{},"TableMappings":{},"ReplicationTaskSettings":{},"CdcStartTime":{"type":"timestamp"},"CdcStartPosition":{},"CdcStopPosition":{},"TaskData":{}}},"output":{"type":"structure","members":{"ReplicationTask":{"shape":"S22"}}}},"RebootReplicationInstance":{"input":{"type":"structure","required":["ReplicationInstanceArn"],"members":{"ReplicationInstanceArn":{},"ForceFailover":{"type":"boolean"}}},"output":{"type":"structure","members":{"ReplicationInstance":{"shape":"S1m"}}}},"RefreshSchemas":{"input":{"type":"structure","required":["EndpointArn","ReplicationInstanceArn"],"members":{"EndpointArn":{},"ReplicationInstanceArn":{}}},"output":{"type":"structure","members":{"RefreshSchemasStatus":{"shape":"S3y"}}}},"ReloadTables":{"input":{"type":"structure","required":["ReplicationTaskArn","TablesToReload"],"members":{"ReplicationTaskArn":{},"TablesToReload":{"type":"list","member":{"type":"structure","required":["SchemaName","TableName"],"members":{"SchemaName":{},"TableName":{}}}},"ReloadOption":{}}},"output":{"type":"structure","members":{"ReplicationTaskArn":{}}}},"RemoveTagsFromResource":{"input":{"type":"structure","required":["ResourceArn","TagKeys"],"members":{"ResourceArn":{},"TagKeys":{"type":"list","member":{}}}},"output":{"type":"structure","members":{}}},"StartReplicationTask":{"input":{"type":"structure","required":["ReplicationTaskArn","StartReplicationTaskType"],"members":{"ReplicationTaskArn":{},"StartReplicationTaskType":{},"CdcStartTime":{"type":"timestamp"},"CdcStartPosition":{},"CdcStopPosition":{}}},"output":{"type":"structure","members":{"ReplicationTask":{"shape":"S22"}}}},"StartReplicationTaskAssessment":{"input":{"type":"structure","required":["ReplicationTaskArn"],"members":{"ReplicationTaskArn":{}}},"output":{"type":"structure","members":{"ReplicationTask":{"shape":"S22"}}}},"StartReplicationTaskAssessmentRun":{"input":{"type":"structure","required":["ReplicationTaskArn","ServiceAccessRoleArn","ResultLocationBucket","AssessmentRunName"],"members":{"ReplicationTaskArn":{},"ServiceAccessRoleArn":{},"ResultLocationBucket":{},"ResultLocationFolder":{},"ResultEncryptionMode":{},"ResultKmsKeyArn":{},"AssessmentRunName":{},"IncludeOnly":{"type":"list","member":{}},"Exclude":{"type":"list","member":{}}}},"output":{"type":"structure","members":{"ReplicationTaskAssessmentRun":{"shape":"Se"}}}},"StopReplicationTask":{"input":{"type":"structure","required":["ReplicationTaskArn"],"members":{"ReplicationTaskArn":{}}},"output":{"type":"structure","members":{"ReplicationTask":{"shape":"S22"}}}},"TestConnection":{"input":{"type":"structure","required":["ReplicationInstanceArn","EndpointArn"],"members":{"ReplicationInstanceArn":{},"EndpointArn":{}}},"output":{"type":"structure","members":{"Connection":{"shape":"S2b"}}}}},"shapes":{"S3":{"type":"list","member":{"type":"structure","members":{"Key":{},"Value":{}}}},"S8":{"type":"structure","members":{"ResourceIdentifier":{},"PendingMaintenanceActionDetails":{"type":"list","member":{"type":"structure","members":{"Action":{},"AutoAppliedAfterDate":{"type":"timestamp"},"ForcedApplyDate":{"type":"timestamp"},"OptInStatus":{},"CurrentApplyDate":{"type":"timestamp"},"Description":{}}}}}},"Se":{"type":"structure","members":{"ReplicationTaskAssessmentRunArn":{},"ReplicationTaskArn":{},"Status":{},"ReplicationTaskAssessmentRunCreationDate":{"type":"timestamp"},"AssessmentProgress":{"type":"structure","members":{"IndividualAssessmentCount":{"type":"integer"},"IndividualAssessmentCompletedCount":{"type":"integer"}}},"LastFailureMessage":{},"ServiceAccessRoleArn":{},"ResultLocationBucket":{},"ResultLocationFolder":{},"ResultEncryptionMode":{},"ResultKmsKeyArn":{},"AssessmentRunName":{}}},"Sj":{"type":"string","sensitive":true},"Sm":{"type":"structure","required":["ServiceAccessRoleArn"],"members":{"ServiceAccessRoleArn":{}}},"Sn":{"type":"structure","members":{"ServiceAccessRoleArn":{},"ExternalTableDefinition":{},"CsvRowDelimiter":{},"CsvDelimiter":{},"BucketFolder":{},"BucketName":{},"CompressionType":{},"EncryptionMode":{},"ServerSideEncryptionKmsKeyId":{},"DataFormat":{},"EncodingType":{},"DictPageSizeLimit":{"type":"integer"},"RowGroupLength":{"type":"integer"},"DataPageSize":{"type":"integer"},"ParquetVersion":{},"EnableStatistics":{"type":"boolean"},"IncludeOpForFullLoad":{"type":"boolean"},"CdcInsertsOnly":{"type":"boolean"},"TimestampColumnName":{},"ParquetTimestampInMillisecond":{"type":"boolean"},"CdcInsertsAndUpdates":{"type":"boolean"}}},"Su":{"type":"structure","members":{"ServiceAccessRoleArn":{},"BucketName":{}}},"Sv":{"type":"structure","members":{"Username":{},"Password":{"shape":"Sj"},"ServerName":{},"Port":{"type":"integer"},"DatabaseName":{},"AuthType":{},"AuthMechanism":{},"NestingLevel":{},"ExtractDocId":{},"DocsToInvestigate":{},"AuthSource":{},"KmsKeyId":{}}},"Sz":{"type":"structure","members":{"StreamArn":{},"MessageFormat":{},"ServiceAccessRoleArn":{},"IncludeTransactionDetails":{"type":"boolean"},"IncludePartitionValue":{"type":"boolean"},"PartitionIncludeSchemaTable":{"type":"boolean"},"IncludeTableAlterOperations":{"type":"boolean"},"IncludeControlDetails":{"type":"boolean"}}},"S11":{"type":"structure","members":{"Broker":{},"Topic":{},"MessageFormat":{},"IncludeTransactionDetails":{"type":"boolean"},"IncludePartitionValue":{"type":"boolean"},"PartitionIncludeSchemaTable":{"type":"boolean"},"IncludeTableAlterOperations":{"type":"boolean"},"IncludeControlDetails":{"type":"boolean"}}},"S12":{"type":"structure","required":["ServiceAccessRoleArn","EndpointUri"],"members":{"ServiceAccessRoleArn":{},"EndpointUri":{},"FullLoadErrorPercentage":{"type":"integer"},"ErrorRetryDuration":{"type":"integer"}}},"S13":{"type":"structure","required":["S3BucketName","S3BucketFolder"],"members":{"ServiceAccessRoleArn":{},"S3BucketName":{},"S3BucketFolder":{},"ErrorRetryDuration":{"type":"integer"},"MaxFileSize":{"type":"integer"},"MaxRetryCount":{"type":"integer"},"IamAuthEnabled":{"type":"boolean"}}},"S14":{"type":"structure","members":{"AcceptAnyDate":{"type":"boolean"},"AfterConnectScript":{},"BucketFolder":{},"BucketName":{},"ConnectionTimeout":{"type":"integer"},"DatabaseName":{},"DateFormat":{},"EmptyAsNull":{"type":"boolean"},"EncryptionMode":{},"FileTransferUploadStreams":{"type":"integer"},"LoadTimeout":{"type":"integer"},"MaxFileSize":{"type":"integer"},"Password":{"shape":"Sj"},"Port":{"type":"integer"},"RemoveQuotes":{"type":"boolean"},"ReplaceInvalidChars":{},"ReplaceChars":{},"ServerName":{},"ServiceAccessRoleArn":{},"ServerSideEncryptionKmsKeyId":{},"TimeFormat":{},"TrimBlanks":{"type":"boolean"},"TruncateColumns":{"type":"boolean"},"Username":{},"WriteBufferSize":{"type":"integer"}}},"S15":{"type":"structure","members":{"DatabaseName":{},"Password":{"shape":"Sj"},"Port":{"type":"integer"},"ServerName":{},"Username":{}}},"S16":{"type":"structure","members":{"DatabaseName":{},"Password":{"shape":"Sj"},"Port":{"type":"integer"},"ServerName":{},"Username":{}}},"S17":{"type":"structure","members":{"AsmPassword":{"shape":"Sj"},"AsmServer":{},"AsmUser":{},"DatabaseName":{},"Password":{"shape":"Sj"},"Port":{"type":"integer"},"SecurityDbEncryption":{"shape":"Sj"},"SecurityDbEncryptionName":{},"ServerName":{},"Username":{}}},"S18":{"type":"structure","members":{"DatabaseName":{},"Password":{"shape":"Sj"},"Port":{"type":"integer"},"ServerName":{},"Username":{}}},"S19":{"type":"structure","members":{"Port":{"type":"integer"},"DatabaseName":{},"Password":{"shape":"Sj"},"ServerName":{},"Username":{}}},"S1a":{"type":"structure","members":{"DatabaseName":{},"Password":{"shape":"Sj"},"Port":{"type":"integer"},"ServerName":{},"Username":{}}},"S1c":{"type":"structure","members":{"EndpointIdentifier":{},"EndpointType":{},"EngineName":{},"EngineDisplayName":{},"Username":{},"ServerName":{},"Port":{"type":"integer"},"DatabaseName":{},"ExtraConnectionAttributes":{},"Status":{},"KmsKeyId":{},"EndpointArn":{},"CertificateArn":{},"SslMode":{},"ServiceAccessRoleArn":{},"ExternalTableDefinition":{},"ExternalId":{},"DynamoDbSettings":{"shape":"Sm"},"S3Settings":{"shape":"Sn"},"DmsTransferSettings":{"shape":"Su"},"MongoDbSettings":{"shape":"Sv"},"KinesisSettings":{"shape":"Sz"},"KafkaSettings":{"shape":"S11"},"ElasticsearchSettings":{"shape":"S12"},"NeptuneSettings":{"shape":"S13"},"RedshiftSettings":{"shape":"S14"},"PostgreSQLSettings":{"shape":"S15"},"MySQLSettings":{"shape":"S16"},"OracleSettings":{"shape":"S17"},"SybaseSettings":{"shape":"S18"},"MicrosoftSQLServerSettings":{"shape":"S19"},"IBMDb2Settings":{"shape":"S1a"}}},"S1e":{"type":"list","member":{}},"S1f":{"type":"list","member":{}},"S1h":{"type":"structure","members":{"CustomerAwsId":{},"CustSubscriptionId":{},"SnsTopicArn":{},"Status":{},"SubscriptionCreationTime":{},"SourceType":{},"SourceIdsList":{"shape":"S1f"},"EventCategoriesList":{"shape":"S1e"},"Enabled":{"type":"boolean"}}},"S1k":{"type":"list","member":{}},"S1m":{"type":"structure","members":{"ReplicationInstanceIdentifier":{},"ReplicationInstanceClass":{},"ReplicationInstanceStatus":{},"AllocatedStorage":{"type":"integer"},"InstanceCreateTime":{"type":"timestamp"},"VpcSecurityGroups":{"type":"list","member":{"type":"structure","members":{"VpcSecurityGroupId":{},"Status":{}}}},"AvailabilityZone":{},"ReplicationSubnetGroup":{"shape":"S1p"},"PreferredMaintenanceWindow":{},"PendingModifiedValues":{"type":"structure","members":{"ReplicationInstanceClass":{},"AllocatedStorage":{"type":"integer"},"MultiAZ":{"type":"boolean"},"EngineVersion":{}}},"MultiAZ":{"type":"boolean"},"EngineVersion":{},"AutoMinorVersionUpgrade":{"type":"boolean"},"KmsKeyId":{},"ReplicationInstanceArn":{},"ReplicationInstancePublicIpAddress":{"deprecated":true},"ReplicationInstancePrivateIpAddress":{"deprecated":true},"ReplicationInstancePublicIpAddresses":{"type":"list","member":{}},"ReplicationInstancePrivateIpAddresses":{"type":"list","member":{}},"PubliclyAccessible":{"type":"boolean"},"SecondaryAvailabilityZone":{},"FreeUntil":{"type":"timestamp"},"DnsNameServers":{}}},"S1p":{"type":"structure","members":{"ReplicationSubnetGroupIdentifier":{},"ReplicationSubnetGroupDescription":{},"VpcId":{},"SubnetGroupStatus":{},"Subnets":{"type":"list","member":{"type":"structure","members":{"SubnetIdentifier":{},"SubnetAvailabilityZone":{"type":"structure","members":{"Name":{}}},"SubnetStatus":{}}}}}},"S1x":{"type":"list","member":{}},"S22":{"type":"structure","members":{"ReplicationTaskIdentifier":{},"SourceEndpointArn":{},"TargetEndpointArn":{},"ReplicationInstanceArn":{},"MigrationType":{},"TableMappings":{},"ReplicationTaskSettings":{},"Status":{},"LastFailureMessage":{},"StopReason":{},"ReplicationTaskCreationDate":{"type":"timestamp"},"ReplicationTaskStartDate":{"type":"timestamp"},"CdcStartPosition":{},"CdcStopPosition":{},"RecoveryCheckpoint":{},"ReplicationTaskArn":{},"ReplicationTaskStats":{"type":"structure","members":{"FullLoadProgressPercent":{"type":"integer"},"ElapsedTimeMillis":{"type":"long"},"TablesLoaded":{"type":"integer"},"TablesLoading":{"type":"integer"},"TablesQueued":{"type":"integer"},"TablesErrored":{"type":"integer"},"FreshStartDate":{"type":"timestamp"},"StartDate":{"type":"timestamp"},"StopDate":{"type":"timestamp"},"FullLoadStartDate":{"type":"timestamp"},"FullLoadFinishDate":{"type":"timestamp"}}},"TaskData":{}}},"S27":{"type":"structure","members":{"CertificateIdentifier":{},"CertificateCreationDate":{"type":"timestamp"},"CertificatePem":{},"CertificateWallet":{"type":"blob"},"CertificateArn":{},"CertificateOwner":{},"ValidFromDate":{"type":"timestamp"},"ValidToDate":{"type":"timestamp"},"SigningAlgorithm":{},"KeyLength":{"type":"integer"}}},"S2b":{"type":"structure","members":{"ReplicationInstanceArn":{},"EndpointArn":{},"Status":{},"LastFailureMessage":{},"EndpointIdentifier":{},"ReplicationInstanceIdentifier":{}}},"S2w":{"type":"list","member":{"type":"structure","required":["Name","Values"],"members":{"Name":{},"Values":{"type":"list","member":{}}}}},"S3y":{"type":"structure","members":{"EndpointArn":{},"ReplicationInstanceArn":{},"Status":{},"LastRefreshDate":{"type":"timestamp"},"LastFailureMessage":{}}}}}; +const paginateDescribeStackEvents = core.createPaginator(CloudFormationClient, DescribeStackEventsCommand, "NextToken", "NextToken", ""); -/***/ }), +const paginateDescribeStackResourceDrifts = core.createPaginator(CloudFormationClient, DescribeStackResourceDriftsCommand, "NextToken", "NextToken", "MaxResults"); -/***/ 1037: -/***/ (function(module) { +const paginateDescribeStacks = core.createPaginator(CloudFormationClient, DescribeStacksCommand, "NextToken", "NextToken", ""); -module.exports = {"pagination":{"ListAWSServiceAccessForOrganization":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"ListAccounts":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"ListAccountsForParent":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"ListChildren":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"ListCreateAccountStatus":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"ListDelegatedAdministrators":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"DelegatedAdministrators"},"ListDelegatedServicesForAccount":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"DelegatedServices"},"ListHandshakesForAccount":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"ListHandshakesForOrganization":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"ListOrganizationalUnitsForParent":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"ListParents":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"ListPolicies":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"ListPoliciesForTarget":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"ListRoots":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"ListTagsForResource":{"input_token":"NextToken","output_token":"NextToken","result_key":"Tags"},"ListTargetsForPolicy":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"}}}; +const paginateListChangeSets = core.createPaginator(CloudFormationClient, ListChangeSetsCommand, "NextToken", "NextToken", ""); -/***/ }), +const paginateListExports = core.createPaginator(CloudFormationClient, ListExportsCommand, "NextToken", "NextToken", ""); -/***/ 1056: -/***/ (function(module) { +const paginateListGeneratedTemplates = core.createPaginator(CloudFormationClient, ListGeneratedTemplatesCommand, "NextToken", "NextToken", "MaxResults"); -module.exports = {"pagination":{"DescribeApplicableIndividualAssessments":{"input_token":"Marker","output_token":"Marker","limit_key":"MaxRecords"},"DescribeCertificates":{"input_token":"Marker","output_token":"Marker","limit_key":"MaxRecords"},"DescribeConnections":{"input_token":"Marker","output_token":"Marker","limit_key":"MaxRecords"},"DescribeEndpointTypes":{"input_token":"Marker","output_token":"Marker","limit_key":"MaxRecords"},"DescribeEndpoints":{"input_token":"Marker","output_token":"Marker","limit_key":"MaxRecords"},"DescribeEventSubscriptions":{"input_token":"Marker","output_token":"Marker","limit_key":"MaxRecords"},"DescribeEvents":{"input_token":"Marker","output_token":"Marker","limit_key":"MaxRecords"},"DescribeOrderableReplicationInstances":{"input_token":"Marker","output_token":"Marker","limit_key":"MaxRecords"},"DescribePendingMaintenanceActions":{"input_token":"Marker","output_token":"Marker","limit_key":"MaxRecords"},"DescribeReplicationInstanceTaskLogs":{"input_token":"Marker","output_token":"Marker","limit_key":"MaxRecords"},"DescribeReplicationInstances":{"input_token":"Marker","output_token":"Marker","limit_key":"MaxRecords"},"DescribeReplicationSubnetGroups":{"input_token":"Marker","output_token":"Marker","limit_key":"MaxRecords"},"DescribeReplicationTaskAssessmentResults":{"input_token":"Marker","output_token":"Marker","limit_key":"MaxRecords"},"DescribeReplicationTaskAssessmentRuns":{"input_token":"Marker","output_token":"Marker","limit_key":"MaxRecords"},"DescribeReplicationTaskIndividualAssessments":{"input_token":"Marker","output_token":"Marker","limit_key":"MaxRecords"},"DescribeReplicationTasks":{"input_token":"Marker","output_token":"Marker","limit_key":"MaxRecords"},"DescribeSchemas":{"input_token":"Marker","output_token":"Marker","limit_key":"MaxRecords"},"DescribeTableStatistics":{"input_token":"Marker","output_token":"Marker","limit_key":"MaxRecords"}}}; +const paginateListImports = core.createPaginator(CloudFormationClient, ListImportsCommand, "NextToken", "NextToken", ""); -/***/ }), +const paginateListResourceScanRelatedResources = core.createPaginator(CloudFormationClient, ListResourceScanRelatedResourcesCommand, "NextToken", "NextToken", "MaxResults"); -/***/ 1065: -/***/ (function(module) { +const paginateListResourceScanResources = core.createPaginator(CloudFormationClient, ListResourceScanResourcesCommand, "NextToken", "NextToken", "MaxResults"); -module.exports = {"pagination":{"ListHumanLoops":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults","result_key":"HumanLoopSummaries"}}}; +const paginateListResourceScans = core.createPaginator(CloudFormationClient, ListResourceScansCommand, "NextToken", "NextToken", "MaxResults"); -/***/ }), +const paginateListStackInstances = core.createPaginator(CloudFormationClient, ListStackInstancesCommand, "NextToken", "NextToken", "MaxResults"); -/***/ 1068: -/***/ (function(module, __unusedexports, __webpack_require__) { +const paginateListStackRefactorActions = core.createPaginator(CloudFormationClient, ListStackRefactorActionsCommand, "NextToken", "NextToken", "MaxResults"); -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +const paginateListStackRefactors = core.createPaginator(CloudFormationClient, ListStackRefactorsCommand, "NextToken", "NextToken", "MaxResults"); -apiLoader.services['detective'] = {}; -AWS.Detective = Service.defineService('detective', ['2018-10-26']); -Object.defineProperty(apiLoader.services['detective'], '2018-10-26', { - get: function get() { - var model = __webpack_require__(9130); - model.paginators = __webpack_require__(1527).pagination; - return model; - }, - enumerable: true, - configurable: true -}); +const paginateListStackResources = core.createPaginator(CloudFormationClient, ListStackResourcesCommand, "NextToken", "NextToken", ""); -module.exports = AWS.Detective; +const paginateListStackSetOperationResults = core.createPaginator(CloudFormationClient, ListStackSetOperationResultsCommand, "NextToken", "NextToken", "MaxResults"); +const paginateListStackSetOperations = core.createPaginator(CloudFormationClient, ListStackSetOperationsCommand, "NextToken", "NextToken", "MaxResults"); -/***/ }), +const paginateListStackSets = core.createPaginator(CloudFormationClient, ListStackSetsCommand, "NextToken", "NextToken", "MaxResults"); -/***/ 1071: -/***/ (function(module, __unusedexports, __webpack_require__) { +const paginateListStacks = core.createPaginator(CloudFormationClient, ListStacksCommand, "NextToken", "NextToken", ""); -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +const paginateListTypeRegistrations = core.createPaginator(CloudFormationClient, ListTypeRegistrationsCommand, "NextToken", "NextToken", "MaxResults"); -apiLoader.services['rds'] = {}; -AWS.RDS = Service.defineService('rds', ['2013-01-10', '2013-02-12', '2013-09-09', '2014-09-01', '2014-09-01*', '2014-10-31']); -__webpack_require__(7978); -Object.defineProperty(apiLoader.services['rds'], '2013-01-10', { - get: function get() { - var model = __webpack_require__(5017); - model.paginators = __webpack_require__(2904).pagination; - return model; - }, - enumerable: true, - configurable: true -}); -Object.defineProperty(apiLoader.services['rds'], '2013-02-12', { - get: function get() { - var model = __webpack_require__(4237); - model.paginators = __webpack_require__(3756).pagination; - return model; - }, - enumerable: true, - configurable: true -}); -Object.defineProperty(apiLoader.services['rds'], '2013-09-09', { - get: function get() { - var model = __webpack_require__(6928); - model.paginators = __webpack_require__(1318).pagination; - model.waiters = __webpack_require__(5945).waiters; - return model; - }, - enumerable: true, - configurable: true -}); -Object.defineProperty(apiLoader.services['rds'], '2014-09-01', { - get: function get() { - var model = __webpack_require__(1413); - model.paginators = __webpack_require__(2323).pagination; - return model; - }, - enumerable: true, - configurable: true -}); -Object.defineProperty(apiLoader.services['rds'], '2014-10-31', { - get: function get() { - var model = __webpack_require__(5402); - model.paginators = __webpack_require__(4798).pagination; - model.waiters = __webpack_require__(4525).waiters; - return model; - }, - enumerable: true, - configurable: true -}); +const paginateListTypeVersions = core.createPaginator(CloudFormationClient, ListTypeVersionsCommand, "NextToken", "NextToken", "MaxResults"); -module.exports = AWS.RDS; +const paginateListTypes = core.createPaginator(CloudFormationClient, ListTypesCommand, "NextToken", "NextToken", "MaxResults"); +const checkState$9 = async (client, input) => { + let reason; + try { + const result = await client.send(new DescribeChangeSetCommand(input)); + reason = result; + try { + const returnComparator = () => { + return result.Status; + }; + if (returnComparator() === "CREATE_COMPLETE") { + return { state: utilWaiter.WaiterState.SUCCESS, reason }; + } + } + catch (e) { } + try { + const returnComparator = () => { + return result.Status; + }; + if (returnComparator() === "FAILED") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + catch (e) { } + } + catch (exception) { + reason = exception; + if (exception.name && exception.name == "ValidationError") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + return { state: utilWaiter.WaiterState.RETRY, reason }; +}; +const waitForChangeSetCreateComplete = async (params, input) => { + const serviceDefaults = { minDelay: 30, maxDelay: 120 }; + return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9); +}; +const waitUntilChangeSetCreateComplete = async (params, input) => { + const serviceDefaults = { minDelay: 30, maxDelay: 120 }; + const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9); + return utilWaiter.checkExceptions(result); +}; -/***/ }), - -/***/ 1073: -/***/ (function(module) { - -module.exports = {"pagination":{"ListChangedBlocks":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListSnapshotBlocks":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"}}}; - -/***/ }), - -/***/ 1079: -/***/ (function(module) { - -module.exports = {"pagination":{"ListCloudFrontOriginAccessIdentities":{"input_token":"Marker","limit_key":"MaxItems","more_results":"CloudFrontOriginAccessIdentityList.IsTruncated","output_token":"CloudFrontOriginAccessIdentityList.NextMarker","result_key":"CloudFrontOriginAccessIdentityList.Items"},"ListDistributions":{"input_token":"Marker","limit_key":"MaxItems","more_results":"DistributionList.IsTruncated","output_token":"DistributionList.NextMarker","result_key":"DistributionList.Items"},"ListInvalidations":{"input_token":"Marker","limit_key":"MaxItems","more_results":"InvalidationList.IsTruncated","output_token":"InvalidationList.NextMarker","result_key":"InvalidationList.Items"},"ListStreamingDistributions":{"input_token":"Marker","limit_key":"MaxItems","more_results":"StreamingDistributionList.IsTruncated","output_token":"StreamingDistributionList.NextMarker","result_key":"StreamingDistributionList.Items"}}}; - -/***/ }), - -/***/ 1096: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['codestarconnections'] = {}; -AWS.CodeStarconnections = Service.defineService('codestarconnections', ['2019-12-01']); -Object.defineProperty(apiLoader.services['codestarconnections'], '2019-12-01', { - get: function get() { - var model = __webpack_require__(4664); - model.paginators = __webpack_require__(7572).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.CodeStarconnections; - - -/***/ }), - -/***/ 1098: -/***/ (function(module) { - -module.exports = {"pagination":{"ListJobs":{"input_token":"marker","limit_key":"limit","output_token":"Marker","result_key":"JobList"},"ListMultipartUploads":{"input_token":"marker","limit_key":"limit","output_token":"Marker","result_key":"UploadsList"},"ListParts":{"input_token":"marker","limit_key":"limit","output_token":"Marker","result_key":"Parts"},"ListVaults":{"input_token":"marker","limit_key":"limit","output_token":"Marker","result_key":"VaultList"}}}; - -/***/ }), - -/***/ 1115: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"uid":"machinelearning-2014-12-12","apiVersion":"2014-12-12","endpointPrefix":"machinelearning","jsonVersion":"1.1","serviceFullName":"Amazon Machine Learning","serviceId":"Machine Learning","signatureVersion":"v4","targetPrefix":"AmazonML_20141212","protocol":"json"},"operations":{"AddTags":{"input":{"type":"structure","required":["Tags","ResourceId","ResourceType"],"members":{"Tags":{"shape":"S2"},"ResourceId":{},"ResourceType":{}}},"output":{"type":"structure","members":{"ResourceId":{},"ResourceType":{}}}},"CreateBatchPrediction":{"input":{"type":"structure","required":["BatchPredictionId","MLModelId","BatchPredictionDataSourceId","OutputUri"],"members":{"BatchPredictionId":{},"BatchPredictionName":{},"MLModelId":{},"BatchPredictionDataSourceId":{},"OutputUri":{}}},"output":{"type":"structure","members":{"BatchPredictionId":{}}}},"CreateDataSourceFromRDS":{"input":{"type":"structure","required":["DataSourceId","RDSData","RoleARN"],"members":{"DataSourceId":{},"DataSourceName":{},"RDSData":{"type":"structure","required":["DatabaseInformation","SelectSqlQuery","DatabaseCredentials","S3StagingLocation","ResourceRole","ServiceRole","SubnetId","SecurityGroupIds"],"members":{"DatabaseInformation":{"shape":"Sf"},"SelectSqlQuery":{},"DatabaseCredentials":{"type":"structure","required":["Username","Password"],"members":{"Username":{},"Password":{}}},"S3StagingLocation":{},"DataRearrangement":{},"DataSchema":{},"DataSchemaUri":{},"ResourceRole":{},"ServiceRole":{},"SubnetId":{},"SecurityGroupIds":{"type":"list","member":{}}}},"RoleARN":{},"ComputeStatistics":{"type":"boolean"}}},"output":{"type":"structure","members":{"DataSourceId":{}}}},"CreateDataSourceFromRedshift":{"input":{"type":"structure","required":["DataSourceId","DataSpec","RoleARN"],"members":{"DataSourceId":{},"DataSourceName":{},"DataSpec":{"type":"structure","required":["DatabaseInformation","SelectSqlQuery","DatabaseCredentials","S3StagingLocation"],"members":{"DatabaseInformation":{"shape":"Sy"},"SelectSqlQuery":{},"DatabaseCredentials":{"type":"structure","required":["Username","Password"],"members":{"Username":{},"Password":{}}},"S3StagingLocation":{},"DataRearrangement":{},"DataSchema":{},"DataSchemaUri":{}}},"RoleARN":{},"ComputeStatistics":{"type":"boolean"}}},"output":{"type":"structure","members":{"DataSourceId":{}}}},"CreateDataSourceFromS3":{"input":{"type":"structure","required":["DataSourceId","DataSpec"],"members":{"DataSourceId":{},"DataSourceName":{},"DataSpec":{"type":"structure","required":["DataLocationS3"],"members":{"DataLocationS3":{},"DataRearrangement":{},"DataSchema":{},"DataSchemaLocationS3":{}}},"ComputeStatistics":{"type":"boolean"}}},"output":{"type":"structure","members":{"DataSourceId":{}}}},"CreateEvaluation":{"input":{"type":"structure","required":["EvaluationId","MLModelId","EvaluationDataSourceId"],"members":{"EvaluationId":{},"EvaluationName":{},"MLModelId":{},"EvaluationDataSourceId":{}}},"output":{"type":"structure","members":{"EvaluationId":{}}}},"CreateMLModel":{"input":{"type":"structure","required":["MLModelId","MLModelType","TrainingDataSourceId"],"members":{"MLModelId":{},"MLModelName":{},"MLModelType":{},"Parameters":{"shape":"S1d"},"TrainingDataSourceId":{},"Recipe":{},"RecipeUri":{}}},"output":{"type":"structure","members":{"MLModelId":{}}}},"CreateRealtimeEndpoint":{"input":{"type":"structure","required":["MLModelId"],"members":{"MLModelId":{}}},"output":{"type":"structure","members":{"MLModelId":{},"RealtimeEndpointInfo":{"shape":"S1j"}}}},"DeleteBatchPrediction":{"input":{"type":"structure","required":["BatchPredictionId"],"members":{"BatchPredictionId":{}}},"output":{"type":"structure","members":{"BatchPredictionId":{}}}},"DeleteDataSource":{"input":{"type":"structure","required":["DataSourceId"],"members":{"DataSourceId":{}}},"output":{"type":"structure","members":{"DataSourceId":{}}}},"DeleteEvaluation":{"input":{"type":"structure","required":["EvaluationId"],"members":{"EvaluationId":{}}},"output":{"type":"structure","members":{"EvaluationId":{}}}},"DeleteMLModel":{"input":{"type":"structure","required":["MLModelId"],"members":{"MLModelId":{}}},"output":{"type":"structure","members":{"MLModelId":{}}}},"DeleteRealtimeEndpoint":{"input":{"type":"structure","required":["MLModelId"],"members":{"MLModelId":{}}},"output":{"type":"structure","members":{"MLModelId":{},"RealtimeEndpointInfo":{"shape":"S1j"}}}},"DeleteTags":{"input":{"type":"structure","required":["TagKeys","ResourceId","ResourceType"],"members":{"TagKeys":{"type":"list","member":{}},"ResourceId":{},"ResourceType":{}}},"output":{"type":"structure","members":{"ResourceId":{},"ResourceType":{}}}},"DescribeBatchPredictions":{"input":{"type":"structure","members":{"FilterVariable":{},"EQ":{},"GT":{},"LT":{},"GE":{},"LE":{},"NE":{},"Prefix":{},"SortOrder":{},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"Results":{"type":"list","member":{"type":"structure","members":{"BatchPredictionId":{},"MLModelId":{},"BatchPredictionDataSourceId":{},"InputDataLocationS3":{},"CreatedByIamUser":{},"CreatedAt":{"type":"timestamp"},"LastUpdatedAt":{"type":"timestamp"},"Name":{},"Status":{},"OutputUri":{},"Message":{},"ComputeTime":{"type":"long"},"FinishedAt":{"type":"timestamp"},"StartedAt":{"type":"timestamp"},"TotalRecordCount":{"type":"long"},"InvalidRecordCount":{"type":"long"}}}},"NextToken":{}}}},"DescribeDataSources":{"input":{"type":"structure","members":{"FilterVariable":{},"EQ":{},"GT":{},"LT":{},"GE":{},"LE":{},"NE":{},"Prefix":{},"SortOrder":{},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"Results":{"type":"list","member":{"type":"structure","members":{"DataSourceId":{},"DataLocationS3":{},"DataRearrangement":{},"CreatedByIamUser":{},"CreatedAt":{"type":"timestamp"},"LastUpdatedAt":{"type":"timestamp"},"DataSizeInBytes":{"type":"long"},"NumberOfFiles":{"type":"long"},"Name":{},"Status":{},"Message":{},"RedshiftMetadata":{"shape":"S2i"},"RDSMetadata":{"shape":"S2j"},"RoleARN":{},"ComputeStatistics":{"type":"boolean"},"ComputeTime":{"type":"long"},"FinishedAt":{"type":"timestamp"},"StartedAt":{"type":"timestamp"}}}},"NextToken":{}}}},"DescribeEvaluations":{"input":{"type":"structure","members":{"FilterVariable":{},"EQ":{},"GT":{},"LT":{},"GE":{},"LE":{},"NE":{},"Prefix":{},"SortOrder":{},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"Results":{"type":"list","member":{"type":"structure","members":{"EvaluationId":{},"MLModelId":{},"EvaluationDataSourceId":{},"InputDataLocationS3":{},"CreatedByIamUser":{},"CreatedAt":{"type":"timestamp"},"LastUpdatedAt":{"type":"timestamp"},"Name":{},"Status":{},"PerformanceMetrics":{"shape":"S2q"},"Message":{},"ComputeTime":{"type":"long"},"FinishedAt":{"type":"timestamp"},"StartedAt":{"type":"timestamp"}}}},"NextToken":{}}}},"DescribeMLModels":{"input":{"type":"structure","members":{"FilterVariable":{},"EQ":{},"GT":{},"LT":{},"GE":{},"LE":{},"NE":{},"Prefix":{},"SortOrder":{},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"Results":{"type":"list","member":{"type":"structure","members":{"MLModelId":{},"TrainingDataSourceId":{},"CreatedByIamUser":{},"CreatedAt":{"type":"timestamp"},"LastUpdatedAt":{"type":"timestamp"},"Name":{},"Status":{},"SizeInBytes":{"type":"long"},"EndpointInfo":{"shape":"S1j"},"TrainingParameters":{"shape":"S1d"},"InputDataLocationS3":{},"Algorithm":{},"MLModelType":{},"ScoreThreshold":{"type":"float"},"ScoreThresholdLastUpdatedAt":{"type":"timestamp"},"Message":{},"ComputeTime":{"type":"long"},"FinishedAt":{"type":"timestamp"},"StartedAt":{"type":"timestamp"}}}},"NextToken":{}}}},"DescribeTags":{"input":{"type":"structure","required":["ResourceId","ResourceType"],"members":{"ResourceId":{},"ResourceType":{}}},"output":{"type":"structure","members":{"ResourceId":{},"ResourceType":{},"Tags":{"shape":"S2"}}}},"GetBatchPrediction":{"input":{"type":"structure","required":["BatchPredictionId"],"members":{"BatchPredictionId":{}}},"output":{"type":"structure","members":{"BatchPredictionId":{},"MLModelId":{},"BatchPredictionDataSourceId":{},"InputDataLocationS3":{},"CreatedByIamUser":{},"CreatedAt":{"type":"timestamp"},"LastUpdatedAt":{"type":"timestamp"},"Name":{},"Status":{},"OutputUri":{},"LogUri":{},"Message":{},"ComputeTime":{"type":"long"},"FinishedAt":{"type":"timestamp"},"StartedAt":{"type":"timestamp"},"TotalRecordCount":{"type":"long"},"InvalidRecordCount":{"type":"long"}}}},"GetDataSource":{"input":{"type":"structure","required":["DataSourceId"],"members":{"DataSourceId":{},"Verbose":{"type":"boolean"}}},"output":{"type":"structure","members":{"DataSourceId":{},"DataLocationS3":{},"DataRearrangement":{},"CreatedByIamUser":{},"CreatedAt":{"type":"timestamp"},"LastUpdatedAt":{"type":"timestamp"},"DataSizeInBytes":{"type":"long"},"NumberOfFiles":{"type":"long"},"Name":{},"Status":{},"LogUri":{},"Message":{},"RedshiftMetadata":{"shape":"S2i"},"RDSMetadata":{"shape":"S2j"},"RoleARN":{},"ComputeStatistics":{"type":"boolean"},"ComputeTime":{"type":"long"},"FinishedAt":{"type":"timestamp"},"StartedAt":{"type":"timestamp"},"DataSourceSchema":{}}}},"GetEvaluation":{"input":{"type":"structure","required":["EvaluationId"],"members":{"EvaluationId":{}}},"output":{"type":"structure","members":{"EvaluationId":{},"MLModelId":{},"EvaluationDataSourceId":{},"InputDataLocationS3":{},"CreatedByIamUser":{},"CreatedAt":{"type":"timestamp"},"LastUpdatedAt":{"type":"timestamp"},"Name":{},"Status":{},"PerformanceMetrics":{"shape":"S2q"},"LogUri":{},"Message":{},"ComputeTime":{"type":"long"},"FinishedAt":{"type":"timestamp"},"StartedAt":{"type":"timestamp"}}}},"GetMLModel":{"input":{"type":"structure","required":["MLModelId"],"members":{"MLModelId":{},"Verbose":{"type":"boolean"}}},"output":{"type":"structure","members":{"MLModelId":{},"TrainingDataSourceId":{},"CreatedByIamUser":{},"CreatedAt":{"type":"timestamp"},"LastUpdatedAt":{"type":"timestamp"},"Name":{},"Status":{},"SizeInBytes":{"type":"long"},"EndpointInfo":{"shape":"S1j"},"TrainingParameters":{"shape":"S1d"},"InputDataLocationS3":{},"MLModelType":{},"ScoreThreshold":{"type":"float"},"ScoreThresholdLastUpdatedAt":{"type":"timestamp"},"LogUri":{},"Message":{},"ComputeTime":{"type":"long"},"FinishedAt":{"type":"timestamp"},"StartedAt":{"type":"timestamp"},"Recipe":{},"Schema":{}}}},"Predict":{"input":{"type":"structure","required":["MLModelId","Record","PredictEndpoint"],"members":{"MLModelId":{},"Record":{"type":"map","key":{},"value":{}},"PredictEndpoint":{}}},"output":{"type":"structure","members":{"Prediction":{"type":"structure","members":{"predictedLabel":{},"predictedValue":{"type":"float"},"predictedScores":{"type":"map","key":{},"value":{"type":"float"}},"details":{"type":"map","key":{},"value":{}}}}}}},"UpdateBatchPrediction":{"input":{"type":"structure","required":["BatchPredictionId","BatchPredictionName"],"members":{"BatchPredictionId":{},"BatchPredictionName":{}}},"output":{"type":"structure","members":{"BatchPredictionId":{}}}},"UpdateDataSource":{"input":{"type":"structure","required":["DataSourceId","DataSourceName"],"members":{"DataSourceId":{},"DataSourceName":{}}},"output":{"type":"structure","members":{"DataSourceId":{}}}},"UpdateEvaluation":{"input":{"type":"structure","required":["EvaluationId","EvaluationName"],"members":{"EvaluationId":{},"EvaluationName":{}}},"output":{"type":"structure","members":{"EvaluationId":{}}}},"UpdateMLModel":{"input":{"type":"structure","required":["MLModelId"],"members":{"MLModelId":{},"MLModelName":{},"ScoreThreshold":{"type":"float"}}},"output":{"type":"structure","members":{"MLModelId":{}}}}},"shapes":{"S2":{"type":"list","member":{"type":"structure","members":{"Key":{},"Value":{}}}},"Sf":{"type":"structure","required":["InstanceIdentifier","DatabaseName"],"members":{"InstanceIdentifier":{},"DatabaseName":{}}},"Sy":{"type":"structure","required":["DatabaseName","ClusterIdentifier"],"members":{"DatabaseName":{},"ClusterIdentifier":{}}},"S1d":{"type":"map","key":{},"value":{}},"S1j":{"type":"structure","members":{"PeakRequestsPerSecond":{"type":"integer"},"CreatedAt":{"type":"timestamp"},"EndpointUrl":{},"EndpointStatus":{}}},"S2i":{"type":"structure","members":{"RedshiftDatabase":{"shape":"Sy"},"DatabaseUserName":{},"SelectSqlQuery":{}}},"S2j":{"type":"structure","members":{"Database":{"shape":"Sf"},"DatabaseUserName":{},"SelectSqlQuery":{},"ResourceRole":{},"ServiceRole":{},"DataPipelineId":{}}},"S2q":{"type":"structure","members":{"Properties":{"type":"map","key":{},"value":{}}}}},"examples":{}}; - -/***/ }), - -/***/ 1116: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2017-12-19","endpointPrefix":"macie","jsonVersion":"1.1","protocol":"json","serviceFullName":"Amazon Macie","serviceId":"Macie","signatureVersion":"v4","targetPrefix":"MacieService","uid":"macie-2017-12-19"},"operations":{"AssociateMemberAccount":{"input":{"type":"structure","required":["memberAccountId"],"members":{"memberAccountId":{}}}},"AssociateS3Resources":{"input":{"type":"structure","required":["s3Resources"],"members":{"memberAccountId":{},"s3Resources":{"shape":"S4"}}},"output":{"type":"structure","members":{"failedS3Resources":{"shape":"Sc"}}}},"DisassociateMemberAccount":{"input":{"type":"structure","required":["memberAccountId"],"members":{"memberAccountId":{}}}},"DisassociateS3Resources":{"input":{"type":"structure","required":["associatedS3Resources"],"members":{"memberAccountId":{},"associatedS3Resources":{"type":"list","member":{"shape":"Se"}}}},"output":{"type":"structure","members":{"failedS3Resources":{"shape":"Sc"}}}},"ListMemberAccounts":{"input":{"type":"structure","members":{"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"memberAccounts":{"type":"list","member":{"type":"structure","members":{"accountId":{}}}},"nextToken":{}}}},"ListS3Resources":{"input":{"type":"structure","members":{"memberAccountId":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"s3Resources":{"shape":"S4"},"nextToken":{}}}},"UpdateS3Resources":{"input":{"type":"structure","required":["s3ResourcesUpdate"],"members":{"memberAccountId":{},"s3ResourcesUpdate":{"type":"list","member":{"type":"structure","required":["bucketName","classificationTypeUpdate"],"members":{"bucketName":{},"prefix":{},"classificationTypeUpdate":{"type":"structure","members":{"oneTime":{},"continuous":{}}}}}}}},"output":{"type":"structure","members":{"failedS3Resources":{"shape":"Sc"}}}}},"shapes":{"S4":{"type":"list","member":{"type":"structure","required":["bucketName","classificationType"],"members":{"bucketName":{},"prefix":{},"classificationType":{"type":"structure","required":["oneTime","continuous"],"members":{"oneTime":{},"continuous":{}}}}}},"Sc":{"type":"list","member":{"type":"structure","members":{"failedItem":{"shape":"Se"},"errorCode":{},"errorMessage":{}}}},"Se":{"type":"structure","required":["bucketName"],"members":{"bucketName":{},"prefix":{}}}}}; - -/***/ }), - -/***/ 1130: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2016-11-23","endpointPrefix":"states","jsonVersion":"1.0","protocol":"json","serviceAbbreviation":"AWS SFN","serviceFullName":"AWS Step Functions","serviceId":"SFN","signatureVersion":"v4","targetPrefix":"AWSStepFunctions","uid":"states-2016-11-23"},"operations":{"CreateActivity":{"input":{"type":"structure","required":["name"],"members":{"name":{},"tags":{"shape":"S3"}}},"output":{"type":"structure","required":["activityArn","creationDate"],"members":{"activityArn":{},"creationDate":{"type":"timestamp"}}},"idempotent":true},"CreateStateMachine":{"input":{"type":"structure","required":["name","definition","roleArn"],"members":{"name":{},"definition":{"shape":"Sb"},"roleArn":{},"type":{},"loggingConfiguration":{"shape":"Sd"},"tags":{"shape":"S3"}}},"output":{"type":"structure","required":["stateMachineArn","creationDate"],"members":{"stateMachineArn":{},"creationDate":{"type":"timestamp"}}},"idempotent":true},"DeleteActivity":{"input":{"type":"structure","required":["activityArn"],"members":{"activityArn":{}}},"output":{"type":"structure","members":{}}},"DeleteStateMachine":{"input":{"type":"structure","required":["stateMachineArn"],"members":{"stateMachineArn":{}}},"output":{"type":"structure","members":{}}},"DescribeActivity":{"input":{"type":"structure","required":["activityArn"],"members":{"activityArn":{}}},"output":{"type":"structure","required":["activityArn","name","creationDate"],"members":{"activityArn":{},"name":{},"creationDate":{"type":"timestamp"}}}},"DescribeExecution":{"input":{"type":"structure","required":["executionArn"],"members":{"executionArn":{}}},"output":{"type":"structure","required":["executionArn","stateMachineArn","status","startDate","input"],"members":{"executionArn":{},"stateMachineArn":{},"name":{},"status":{},"startDate":{"type":"timestamp"},"stopDate":{"type":"timestamp"},"input":{"shape":"St"},"output":{"shape":"St"}}}},"DescribeStateMachine":{"input":{"type":"structure","required":["stateMachineArn"],"members":{"stateMachineArn":{}}},"output":{"type":"structure","required":["stateMachineArn","name","definition","roleArn","type","creationDate"],"members":{"stateMachineArn":{},"name":{},"status":{},"definition":{"shape":"Sb"},"roleArn":{},"type":{},"creationDate":{"type":"timestamp"},"loggingConfiguration":{"shape":"Sd"}}}},"DescribeStateMachineForExecution":{"input":{"type":"structure","required":["executionArn"],"members":{"executionArn":{}}},"output":{"type":"structure","required":["stateMachineArn","name","definition","roleArn","updateDate"],"members":{"stateMachineArn":{},"name":{},"definition":{"shape":"Sb"},"roleArn":{},"updateDate":{"type":"timestamp"},"loggingConfiguration":{"shape":"Sd"}}}},"GetActivityTask":{"input":{"type":"structure","required":["activityArn"],"members":{"activityArn":{},"workerName":{}}},"output":{"type":"structure","members":{"taskToken":{},"input":{"type":"string","sensitive":true}}}},"GetExecutionHistory":{"input":{"type":"structure","required":["executionArn"],"members":{"executionArn":{},"maxResults":{"type":"integer"},"reverseOrder":{"type":"boolean"},"nextToken":{}}},"output":{"type":"structure","required":["events"],"members":{"events":{"type":"list","member":{"type":"structure","required":["timestamp","type","id"],"members":{"timestamp":{"type":"timestamp"},"type":{},"id":{"type":"long"},"previousEventId":{"type":"long"},"activityFailedEventDetails":{"type":"structure","members":{"error":{"shape":"S1d"},"cause":{"shape":"S1e"}}},"activityScheduleFailedEventDetails":{"type":"structure","members":{"error":{"shape":"S1d"},"cause":{"shape":"S1e"}}},"activityScheduledEventDetails":{"type":"structure","required":["resource"],"members":{"resource":{},"input":{"shape":"St"},"timeoutInSeconds":{"type":"long"},"heartbeatInSeconds":{"type":"long"}}},"activityStartedEventDetails":{"type":"structure","members":{"workerName":{}}},"activitySucceededEventDetails":{"type":"structure","members":{"output":{"shape":"St"}}},"activityTimedOutEventDetails":{"type":"structure","members":{"error":{"shape":"S1d"},"cause":{"shape":"S1e"}}},"taskFailedEventDetails":{"type":"structure","required":["resourceType","resource"],"members":{"resourceType":{},"resource":{},"error":{"shape":"S1d"},"cause":{"shape":"S1e"}}},"taskScheduledEventDetails":{"type":"structure","required":["resourceType","resource","region","parameters"],"members":{"resourceType":{},"resource":{},"region":{},"parameters":{"type":"string","sensitive":true},"timeoutInSeconds":{"type":"long"}}},"taskStartFailedEventDetails":{"type":"structure","required":["resourceType","resource"],"members":{"resourceType":{},"resource":{},"error":{"shape":"S1d"},"cause":{"shape":"S1e"}}},"taskStartedEventDetails":{"type":"structure","required":["resourceType","resource"],"members":{"resourceType":{},"resource":{}}},"taskSubmitFailedEventDetails":{"type":"structure","required":["resourceType","resource"],"members":{"resourceType":{},"resource":{},"error":{"shape":"S1d"},"cause":{"shape":"S1e"}}},"taskSubmittedEventDetails":{"type":"structure","required":["resourceType","resource"],"members":{"resourceType":{},"resource":{},"output":{"shape":"St"}}},"taskSucceededEventDetails":{"type":"structure","required":["resourceType","resource"],"members":{"resourceType":{},"resource":{},"output":{"shape":"St"}}},"taskTimedOutEventDetails":{"type":"structure","required":["resourceType","resource"],"members":{"resourceType":{},"resource":{},"error":{"shape":"S1d"},"cause":{"shape":"S1e"}}},"executionFailedEventDetails":{"type":"structure","members":{"error":{"shape":"S1d"},"cause":{"shape":"S1e"}}},"executionStartedEventDetails":{"type":"structure","members":{"input":{"shape":"St"},"roleArn":{}}},"executionSucceededEventDetails":{"type":"structure","members":{"output":{"shape":"St"}}},"executionAbortedEventDetails":{"type":"structure","members":{"error":{"shape":"S1d"},"cause":{"shape":"S1e"}}},"executionTimedOutEventDetails":{"type":"structure","members":{"error":{"shape":"S1d"},"cause":{"shape":"S1e"}}},"mapStateStartedEventDetails":{"type":"structure","members":{"length":{"type":"integer"}}},"mapIterationStartedEventDetails":{"shape":"S22"},"mapIterationSucceededEventDetails":{"shape":"S22"},"mapIterationFailedEventDetails":{"shape":"S22"},"mapIterationAbortedEventDetails":{"shape":"S22"},"lambdaFunctionFailedEventDetails":{"type":"structure","members":{"error":{"shape":"S1d"},"cause":{"shape":"S1e"}}},"lambdaFunctionScheduleFailedEventDetails":{"type":"structure","members":{"error":{"shape":"S1d"},"cause":{"shape":"S1e"}}},"lambdaFunctionScheduledEventDetails":{"type":"structure","required":["resource"],"members":{"resource":{},"input":{"shape":"St"},"timeoutInSeconds":{"type":"long"}}},"lambdaFunctionStartFailedEventDetails":{"type":"structure","members":{"error":{"shape":"S1d"},"cause":{"shape":"S1e"}}},"lambdaFunctionSucceededEventDetails":{"type":"structure","members":{"output":{"shape":"St"}}},"lambdaFunctionTimedOutEventDetails":{"type":"structure","members":{"error":{"shape":"S1d"},"cause":{"shape":"S1e"}}},"stateEnteredEventDetails":{"type":"structure","required":["name"],"members":{"name":{},"input":{"shape":"St"}}},"stateExitedEventDetails":{"type":"structure","required":["name"],"members":{"name":{},"output":{"shape":"St"}}}}}},"nextToken":{}}}},"ListActivities":{"input":{"type":"structure","members":{"maxResults":{"type":"integer"},"nextToken":{}}},"output":{"type":"structure","required":["activities"],"members":{"activities":{"type":"list","member":{"type":"structure","required":["activityArn","name","creationDate"],"members":{"activityArn":{},"name":{},"creationDate":{"type":"timestamp"}}}},"nextToken":{}}}},"ListExecutions":{"input":{"type":"structure","required":["stateMachineArn"],"members":{"stateMachineArn":{},"statusFilter":{},"maxResults":{"type":"integer"},"nextToken":{}}},"output":{"type":"structure","required":["executions"],"members":{"executions":{"type":"list","member":{"type":"structure","required":["executionArn","stateMachineArn","name","status","startDate"],"members":{"executionArn":{},"stateMachineArn":{},"name":{},"status":{},"startDate":{"type":"timestamp"},"stopDate":{"type":"timestamp"}}}},"nextToken":{}}}},"ListStateMachines":{"input":{"type":"structure","members":{"maxResults":{"type":"integer"},"nextToken":{}}},"output":{"type":"structure","required":["stateMachines"],"members":{"stateMachines":{"type":"list","member":{"type":"structure","required":["stateMachineArn","name","type","creationDate"],"members":{"stateMachineArn":{},"name":{},"type":{},"creationDate":{"type":"timestamp"}}}},"nextToken":{}}}},"ListTagsForResource":{"input":{"type":"structure","required":["resourceArn"],"members":{"resourceArn":{}}},"output":{"type":"structure","members":{"tags":{"shape":"S3"}}}},"SendTaskFailure":{"input":{"type":"structure","required":["taskToken"],"members":{"taskToken":{},"error":{"shape":"S1d"},"cause":{"shape":"S1e"}}},"output":{"type":"structure","members":{}}},"SendTaskHeartbeat":{"input":{"type":"structure","required":["taskToken"],"members":{"taskToken":{}}},"output":{"type":"structure","members":{}}},"SendTaskSuccess":{"input":{"type":"structure","required":["taskToken","output"],"members":{"taskToken":{},"output":{"shape":"St"}}},"output":{"type":"structure","members":{}}},"StartExecution":{"input":{"type":"structure","required":["stateMachineArn"],"members":{"stateMachineArn":{},"name":{},"input":{"shape":"St"}}},"output":{"type":"structure","required":["executionArn","startDate"],"members":{"executionArn":{},"startDate":{"type":"timestamp"}}},"idempotent":true},"StopExecution":{"input":{"type":"structure","required":["executionArn"],"members":{"executionArn":{},"error":{"shape":"S1d"},"cause":{"shape":"S1e"}}},"output":{"type":"structure","required":["stopDate"],"members":{"stopDate":{"type":"timestamp"}}}},"TagResource":{"input":{"type":"structure","required":["resourceArn","tags"],"members":{"resourceArn":{},"tags":{"shape":"S3"}}},"output":{"type":"structure","members":{}}},"UntagResource":{"input":{"type":"structure","required":["resourceArn","tagKeys"],"members":{"resourceArn":{},"tagKeys":{"type":"list","member":{}}}},"output":{"type":"structure","members":{}}},"UpdateStateMachine":{"input":{"type":"structure","required":["stateMachineArn"],"members":{"stateMachineArn":{},"definition":{"shape":"Sb"},"roleArn":{},"loggingConfiguration":{"shape":"Sd"}}},"output":{"type":"structure","required":["updateDate"],"members":{"updateDate":{"type":"timestamp"}}},"idempotent":true}},"shapes":{"S3":{"type":"list","member":{"type":"structure","members":{"key":{},"value":{}}}},"Sb":{"type":"string","sensitive":true},"Sd":{"type":"structure","members":{"level":{},"includeExecutionData":{"type":"boolean"},"destinations":{"type":"list","member":{"type":"structure","members":{"cloudWatchLogsLogGroup":{"type":"structure","members":{"logGroupArn":{}}}}}}}},"St":{"type":"string","sensitive":true},"S1d":{"type":"string","sensitive":true},"S1e":{"type":"string","sensitive":true},"S22":{"type":"structure","members":{"name":{},"index":{"type":"integer"}}}}}; - -/***/ }), - -/***/ 1152: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2018-08-08","endpointPrefix":"globalaccelerator","jsonVersion":"1.1","protocol":"json","serviceFullName":"AWS Global Accelerator","serviceId":"Global Accelerator","signatureVersion":"v4","signingName":"globalaccelerator","targetPrefix":"GlobalAccelerator_V20180706","uid":"globalaccelerator-2018-08-08"},"operations":{"AdvertiseByoipCidr":{"input":{"type":"structure","required":["Cidr"],"members":{"Cidr":{}}},"output":{"type":"structure","members":{"ByoipCidr":{"shape":"S4"}}}},"CreateAccelerator":{"input":{"type":"structure","required":["Name","IdempotencyToken"],"members":{"Name":{},"IpAddressType":{},"IpAddresses":{"shape":"Sb"},"Enabled":{"type":"boolean"},"IdempotencyToken":{"idempotencyToken":true},"Tags":{"shape":"Sf"}}},"output":{"type":"structure","members":{"Accelerator":{"shape":"Sk"}}}},"CreateEndpointGroup":{"input":{"type":"structure","required":["ListenerArn","EndpointGroupRegion","IdempotencyToken"],"members":{"ListenerArn":{},"EndpointGroupRegion":{},"EndpointConfigurations":{"shape":"Sp"},"TrafficDialPercentage":{"type":"float"},"HealthCheckPort":{"type":"integer"},"HealthCheckProtocol":{},"HealthCheckPath":{},"HealthCheckIntervalSeconds":{"type":"integer"},"ThresholdCount":{"type":"integer"},"IdempotencyToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"EndpointGroup":{"shape":"Sy"}}}},"CreateListener":{"input":{"type":"structure","required":["AcceleratorArn","PortRanges","Protocol","IdempotencyToken"],"members":{"AcceleratorArn":{},"PortRanges":{"shape":"S13"},"Protocol":{},"ClientAffinity":{},"IdempotencyToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"Listener":{"shape":"S19"}}}},"DeleteAccelerator":{"input":{"type":"structure","required":["AcceleratorArn"],"members":{"AcceleratorArn":{}}}},"DeleteEndpointGroup":{"input":{"type":"structure","required":["EndpointGroupArn"],"members":{"EndpointGroupArn":{}}}},"DeleteListener":{"input":{"type":"structure","required":["ListenerArn"],"members":{"ListenerArn":{}}}},"DeprovisionByoipCidr":{"input":{"type":"structure","required":["Cidr"],"members":{"Cidr":{}}},"output":{"type":"structure","members":{"ByoipCidr":{"shape":"S4"}}}},"DescribeAccelerator":{"input":{"type":"structure","required":["AcceleratorArn"],"members":{"AcceleratorArn":{}}},"output":{"type":"structure","members":{"Accelerator":{"shape":"Sk"}}}},"DescribeAcceleratorAttributes":{"input":{"type":"structure","required":["AcceleratorArn"],"members":{"AcceleratorArn":{}}},"output":{"type":"structure","members":{"AcceleratorAttributes":{"shape":"S1j"}}}},"DescribeEndpointGroup":{"input":{"type":"structure","required":["EndpointGroupArn"],"members":{"EndpointGroupArn":{}}},"output":{"type":"structure","members":{"EndpointGroup":{"shape":"Sy"}}}},"DescribeListener":{"input":{"type":"structure","required":["ListenerArn"],"members":{"ListenerArn":{}}},"output":{"type":"structure","members":{"Listener":{"shape":"S19"}}}},"ListAccelerators":{"input":{"type":"structure","members":{"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"Accelerators":{"type":"list","member":{"shape":"Sk"}},"NextToken":{}}}},"ListByoipCidrs":{"input":{"type":"structure","members":{"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"ByoipCidrs":{"type":"list","member":{"shape":"S4"}},"NextToken":{}}}},"ListEndpointGroups":{"input":{"type":"structure","required":["ListenerArn"],"members":{"ListenerArn":{},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"EndpointGroups":{"type":"list","member":{"shape":"Sy"}},"NextToken":{}}}},"ListListeners":{"input":{"type":"structure","required":["AcceleratorArn"],"members":{"AcceleratorArn":{},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"Listeners":{"type":"list","member":{"shape":"S19"}},"NextToken":{}}}},"ListTagsForResource":{"input":{"type":"structure","required":["ResourceArn"],"members":{"ResourceArn":{}}},"output":{"type":"structure","members":{"Tags":{"shape":"Sf"}}}},"ProvisionByoipCidr":{"input":{"type":"structure","required":["Cidr","CidrAuthorizationContext"],"members":{"Cidr":{},"CidrAuthorizationContext":{"type":"structure","required":["Message","Signature"],"members":{"Message":{},"Signature":{}}}}},"output":{"type":"structure","members":{"ByoipCidr":{"shape":"S4"}}}},"TagResource":{"input":{"type":"structure","required":["ResourceArn","Tags"],"members":{"ResourceArn":{},"Tags":{"shape":"Sf"}}},"output":{"type":"structure","members":{}}},"UntagResource":{"input":{"type":"structure","required":["ResourceArn","TagKeys"],"members":{"ResourceArn":{},"TagKeys":{"type":"list","member":{}}}},"output":{"type":"structure","members":{}}},"UpdateAccelerator":{"input":{"type":"structure","required":["AcceleratorArn"],"members":{"AcceleratorArn":{},"Name":{},"IpAddressType":{},"Enabled":{"type":"boolean"}}},"output":{"type":"structure","members":{"Accelerator":{"shape":"Sk"}}}},"UpdateAcceleratorAttributes":{"input":{"type":"structure","required":["AcceleratorArn"],"members":{"AcceleratorArn":{},"FlowLogsEnabled":{"type":"boolean"},"FlowLogsS3Bucket":{},"FlowLogsS3Prefix":{}}},"output":{"type":"structure","members":{"AcceleratorAttributes":{"shape":"S1j"}}}},"UpdateEndpointGroup":{"input":{"type":"structure","required":["EndpointGroupArn"],"members":{"EndpointGroupArn":{},"EndpointConfigurations":{"shape":"Sp"},"TrafficDialPercentage":{"type":"float"},"HealthCheckPort":{"type":"integer"},"HealthCheckProtocol":{},"HealthCheckPath":{},"HealthCheckIntervalSeconds":{"type":"integer"},"ThresholdCount":{"type":"integer"}}},"output":{"type":"structure","members":{"EndpointGroup":{"shape":"Sy"}}}},"UpdateListener":{"input":{"type":"structure","required":["ListenerArn"],"members":{"ListenerArn":{},"PortRanges":{"shape":"S13"},"Protocol":{},"ClientAffinity":{}}},"output":{"type":"structure","members":{"Listener":{"shape":"S19"}}}},"WithdrawByoipCidr":{"input":{"type":"structure","required":["Cidr"],"members":{"Cidr":{}}},"output":{"type":"structure","members":{"ByoipCidr":{"shape":"S4"}}}}},"shapes":{"S4":{"type":"structure","members":{"Cidr":{},"State":{},"Events":{"type":"list","member":{"type":"structure","members":{"Message":{},"Timestamp":{"type":"timestamp"}}}}}},"Sb":{"type":"list","member":{}},"Sf":{"type":"list","member":{"type":"structure","required":["Key","Value"],"members":{"Key":{},"Value":{}}}},"Sk":{"type":"structure","members":{"AcceleratorArn":{},"Name":{},"IpAddressType":{},"Enabled":{"type":"boolean"},"IpSets":{"type":"list","member":{"type":"structure","members":{"IpFamily":{},"IpAddresses":{"shape":"Sb"}}}},"DnsName":{},"Status":{},"CreatedTime":{"type":"timestamp"},"LastModifiedTime":{"type":"timestamp"}}},"Sp":{"type":"list","member":{"type":"structure","members":{"EndpointId":{},"Weight":{"type":"integer"},"ClientIPPreservationEnabled":{"type":"boolean"}}}},"Sy":{"type":"structure","members":{"EndpointGroupArn":{},"EndpointGroupRegion":{},"EndpointDescriptions":{"type":"list","member":{"type":"structure","members":{"EndpointId":{},"Weight":{"type":"integer"},"HealthState":{},"HealthReason":{},"ClientIPPreservationEnabled":{"type":"boolean"}}}},"TrafficDialPercentage":{"type":"float"},"HealthCheckPort":{"type":"integer"},"HealthCheckProtocol":{},"HealthCheckPath":{},"HealthCheckIntervalSeconds":{"type":"integer"},"ThresholdCount":{"type":"integer"}}},"S13":{"type":"list","member":{"type":"structure","members":{"FromPort":{"type":"integer"},"ToPort":{"type":"integer"}}}},"S19":{"type":"structure","members":{"ListenerArn":{},"PortRanges":{"shape":"S13"},"Protocol":{},"ClientAffinity":{}}},"S1j":{"type":"structure","members":{"FlowLogsEnabled":{"type":"boolean"},"FlowLogsS3Bucket":{},"FlowLogsS3Prefix":{}}}}}; - -/***/ }), - -/***/ 1154: -/***/ (function(module) { - -module.exports = {"version":2,"waiters":{"DeploymentSuccessful":{"delay":15,"operation":"GetDeployment","maxAttempts":120,"acceptors":[{"expected":"Succeeded","matcher":"path","state":"success","argument":"deploymentInfo.status"},{"expected":"Failed","matcher":"path","state":"failure","argument":"deploymentInfo.status"},{"expected":"Stopped","matcher":"path","state":"failure","argument":"deploymentInfo.status"}]}}}; - -/***/ }), - -/***/ 1163: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2011-12-05","endpointPrefix":"dynamodb","jsonVersion":"1.0","protocol":"json","serviceAbbreviation":"DynamoDB","serviceFullName":"Amazon DynamoDB","serviceId":"DynamoDB","signatureVersion":"v4","targetPrefix":"DynamoDB_20111205","uid":"dynamodb-2011-12-05"},"operations":{"BatchGetItem":{"input":{"type":"structure","required":["RequestItems"],"members":{"RequestItems":{"shape":"S2"}}},"output":{"type":"structure","members":{"Responses":{"type":"map","key":{},"value":{"type":"structure","members":{"Items":{"shape":"Sk"},"ConsumedCapacityUnits":{"type":"double"}}}},"UnprocessedKeys":{"shape":"S2"}}}},"BatchWriteItem":{"input":{"type":"structure","required":["RequestItems"],"members":{"RequestItems":{"shape":"So"}}},"output":{"type":"structure","members":{"Responses":{"type":"map","key":{},"value":{"type":"structure","members":{"ConsumedCapacityUnits":{"type":"double"}}}},"UnprocessedItems":{"shape":"So"}}}},"CreateTable":{"input":{"type":"structure","required":["TableName","KeySchema","ProvisionedThroughput"],"members":{"TableName":{},"KeySchema":{"shape":"Sy"},"ProvisionedThroughput":{"shape":"S12"}}},"output":{"type":"structure","members":{"TableDescription":{"shape":"S15"}}}},"DeleteItem":{"input":{"type":"structure","required":["TableName","Key"],"members":{"TableName":{},"Key":{"shape":"S6"},"Expected":{"shape":"S1b"},"ReturnValues":{}}},"output":{"type":"structure","members":{"Attributes":{"shape":"Sl"},"ConsumedCapacityUnits":{"type":"double"}}}},"DeleteTable":{"input":{"type":"structure","required":["TableName"],"members":{"TableName":{}}},"output":{"type":"structure","members":{"TableDescription":{"shape":"S15"}}}},"DescribeTable":{"input":{"type":"structure","required":["TableName"],"members":{"TableName":{}}},"output":{"type":"structure","members":{"Table":{"shape":"S15"}}}},"GetItem":{"input":{"type":"structure","required":["TableName","Key"],"members":{"TableName":{},"Key":{"shape":"S6"},"AttributesToGet":{"shape":"Se"},"ConsistentRead":{"type":"boolean"}}},"output":{"type":"structure","members":{"Item":{"shape":"Sl"},"ConsumedCapacityUnits":{"type":"double"}}}},"ListTables":{"input":{"type":"structure","members":{"ExclusiveStartTableName":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"TableNames":{"type":"list","member":{}},"LastEvaluatedTableName":{}}}},"PutItem":{"input":{"type":"structure","required":["TableName","Item"],"members":{"TableName":{},"Item":{"shape":"Ss"},"Expected":{"shape":"S1b"},"ReturnValues":{}}},"output":{"type":"structure","members":{"Attributes":{"shape":"Sl"},"ConsumedCapacityUnits":{"type":"double"}}}},"Query":{"input":{"type":"structure","required":["TableName","HashKeyValue"],"members":{"TableName":{},"AttributesToGet":{"shape":"Se"},"Limit":{"type":"integer"},"ConsistentRead":{"type":"boolean"},"Count":{"type":"boolean"},"HashKeyValue":{"shape":"S7"},"RangeKeyCondition":{"shape":"S1u"},"ScanIndexForward":{"type":"boolean"},"ExclusiveStartKey":{"shape":"S6"}}},"output":{"type":"structure","members":{"Items":{"shape":"Sk"},"Count":{"type":"integer"},"LastEvaluatedKey":{"shape":"S6"},"ConsumedCapacityUnits":{"type":"double"}}}},"Scan":{"input":{"type":"structure","required":["TableName"],"members":{"TableName":{},"AttributesToGet":{"shape":"Se"},"Limit":{"type":"integer"},"Count":{"type":"boolean"},"ScanFilter":{"type":"map","key":{},"value":{"shape":"S1u"}},"ExclusiveStartKey":{"shape":"S6"}}},"output":{"type":"structure","members":{"Items":{"shape":"Sk"},"Count":{"type":"integer"},"ScannedCount":{"type":"integer"},"LastEvaluatedKey":{"shape":"S6"},"ConsumedCapacityUnits":{"type":"double"}}}},"UpdateItem":{"input":{"type":"structure","required":["TableName","Key","AttributeUpdates"],"members":{"TableName":{},"Key":{"shape":"S6"},"AttributeUpdates":{"type":"map","key":{},"value":{"type":"structure","members":{"Value":{"shape":"S7"},"Action":{}}}},"Expected":{"shape":"S1b"},"ReturnValues":{}}},"output":{"type":"structure","members":{"Attributes":{"shape":"Sl"},"ConsumedCapacityUnits":{"type":"double"}}}},"UpdateTable":{"input":{"type":"structure","required":["TableName","ProvisionedThroughput"],"members":{"TableName":{},"ProvisionedThroughput":{"shape":"S12"}}},"output":{"type":"structure","members":{"TableDescription":{"shape":"S15"}}}}},"shapes":{"S2":{"type":"map","key":{},"value":{"type":"structure","required":["Keys"],"members":{"Keys":{"type":"list","member":{"shape":"S6"}},"AttributesToGet":{"shape":"Se"},"ConsistentRead":{"type":"boolean"}}}},"S6":{"type":"structure","required":["HashKeyElement"],"members":{"HashKeyElement":{"shape":"S7"},"RangeKeyElement":{"shape":"S7"}}},"S7":{"type":"structure","members":{"S":{},"N":{},"B":{"type":"blob"},"SS":{"type":"list","member":{}},"NS":{"type":"list","member":{}},"BS":{"type":"list","member":{"type":"blob"}}}},"Se":{"type":"list","member":{}},"Sk":{"type":"list","member":{"shape":"Sl"}},"Sl":{"type":"map","key":{},"value":{"shape":"S7"}},"So":{"type":"map","key":{},"value":{"type":"list","member":{"type":"structure","members":{"PutRequest":{"type":"structure","required":["Item"],"members":{"Item":{"shape":"Ss"}}},"DeleteRequest":{"type":"structure","required":["Key"],"members":{"Key":{"shape":"S6"}}}}}}},"Ss":{"type":"map","key":{},"value":{"shape":"S7"}},"Sy":{"type":"structure","required":["HashKeyElement"],"members":{"HashKeyElement":{"shape":"Sz"},"RangeKeyElement":{"shape":"Sz"}}},"Sz":{"type":"structure","required":["AttributeName","AttributeType"],"members":{"AttributeName":{},"AttributeType":{}}},"S12":{"type":"structure","required":["ReadCapacityUnits","WriteCapacityUnits"],"members":{"ReadCapacityUnits":{"type":"long"},"WriteCapacityUnits":{"type":"long"}}},"S15":{"type":"structure","members":{"TableName":{},"KeySchema":{"shape":"Sy"},"TableStatus":{},"CreationDateTime":{"type":"timestamp"},"ProvisionedThroughput":{"type":"structure","members":{"LastIncreaseDateTime":{"type":"timestamp"},"LastDecreaseDateTime":{"type":"timestamp"},"NumberOfDecreasesToday":{"type":"long"},"ReadCapacityUnits":{"type":"long"},"WriteCapacityUnits":{"type":"long"}}},"TableSizeBytes":{"type":"long"},"ItemCount":{"type":"long"}}},"S1b":{"type":"map","key":{},"value":{"type":"structure","members":{"Value":{"shape":"S7"},"Exists":{"type":"boolean"}}}},"S1u":{"type":"structure","required":["ComparisonOperator"],"members":{"AttributeValueList":{"type":"list","member":{"shape":"S7"}},"ComparisonOperator":{}}}}}; - -/***/ }), - -/***/ 1168: -/***/ (function(module) { - -module.exports = {"pagination":{"DescribeApplicationVersions":{"result_key":"ApplicationVersions"},"DescribeApplications":{"result_key":"Applications"},"DescribeConfigurationOptions":{"result_key":"Options"},"DescribeEnvironmentManagedActionHistory":{"input_token":"NextToken","limit_key":"MaxItems","output_token":"NextToken","result_key":"ManagedActionHistoryItems"},"DescribeEnvironments":{"result_key":"Environments"},"DescribeEvents":{"input_token":"NextToken","limit_key":"MaxRecords","output_token":"NextToken","result_key":"Events"},"ListAvailableSolutionStacks":{"result_key":"SolutionStacks"},"ListPlatformBranches":{"input_token":"NextToken","limit_key":"MaxRecords","output_token":"NextToken"},"ListPlatformVersions":{"input_token":"NextToken","limit_key":"MaxRecords","output_token":"NextToken","result_key":"PlatformSummaryList"}}}; - -/***/ }), - -/***/ 1175: -/***/ (function(module, __unusedexports, __webpack_require__) { - -var util = __webpack_require__(395).util; -var toBuffer = util.buffer.toBuffer; - -// All prelude components are unsigned, 32-bit integers -var PRELUDE_MEMBER_LENGTH = 4; -// The prelude consists of two components -var PRELUDE_LENGTH = PRELUDE_MEMBER_LENGTH * 2; -// Checksums are always CRC32 hashes. -var CHECKSUM_LENGTH = 4; -// Messages must include a full prelude, a prelude checksum, and a message checksum -var MINIMUM_MESSAGE_LENGTH = PRELUDE_LENGTH + CHECKSUM_LENGTH * 2; - -/** - * @api private - * - * @param {Buffer} message - */ -function splitMessage(message) { - if (!util.Buffer.isBuffer(message)) message = toBuffer(message); - - if (message.length < MINIMUM_MESSAGE_LENGTH) { - throw new Error('Provided message too short to accommodate event stream message overhead'); +const checkState$8 = async (client, input) => { + let reason; + try { + const result = await client.send(new DescribeStacksCommand(input)); + reason = result; + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + let allStringEq_5 = returnComparator().length > 0; + for (const element_4 of returnComparator()) { + allStringEq_5 = allStringEq_5 && element_4 == "CREATE_COMPLETE"; + } + if (allStringEq_5) { + return { state: utilWaiter.WaiterState.SUCCESS, reason }; + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + let allStringEq_5 = returnComparator().length > 0; + for (const element_4 of returnComparator()) { + allStringEq_5 = allStringEq_5 && element_4 == "UPDATE_COMPLETE"; + } + if (allStringEq_5) { + return { state: utilWaiter.WaiterState.SUCCESS, reason }; + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + let allStringEq_5 = returnComparator().length > 0; + for (const element_4 of returnComparator()) { + allStringEq_5 = allStringEq_5 && element_4 == "UPDATE_IN_PROGRESS"; + } + if (allStringEq_5) { + return { state: utilWaiter.WaiterState.SUCCESS, reason }; + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + let allStringEq_5 = returnComparator().length > 0; + for (const element_4 of returnComparator()) { + allStringEq_5 = allStringEq_5 && element_4 == "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS"; + } + if (allStringEq_5) { + return { state: utilWaiter.WaiterState.SUCCESS, reason }; + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + let allStringEq_5 = returnComparator().length > 0; + for (const element_4 of returnComparator()) { + allStringEq_5 = allStringEq_5 && element_4 == "UPDATE_FAILED"; + } + if (allStringEq_5) { + return { state: utilWaiter.WaiterState.SUCCESS, reason }; + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + let allStringEq_5 = returnComparator().length > 0; + for (const element_4 of returnComparator()) { + allStringEq_5 = allStringEq_5 && element_4 == "UPDATE_ROLLBACK_IN_PROGRESS"; + } + if (allStringEq_5) { + return { state: utilWaiter.WaiterState.SUCCESS, reason }; + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + let allStringEq_5 = returnComparator().length > 0; + for (const element_4 of returnComparator()) { + allStringEq_5 = allStringEq_5 && element_4 == "UPDATE_ROLLBACK_FAILED"; + } + if (allStringEq_5) { + return { state: utilWaiter.WaiterState.SUCCESS, reason }; + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + let allStringEq_5 = returnComparator().length > 0; + for (const element_4 of returnComparator()) { + allStringEq_5 = allStringEq_5 && element_4 == "UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS"; + } + if (allStringEq_5) { + return { state: utilWaiter.WaiterState.SUCCESS, reason }; + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + let allStringEq_5 = returnComparator().length > 0; + for (const element_4 of returnComparator()) { + allStringEq_5 = allStringEq_5 && element_4 == "UPDATE_ROLLBACK_COMPLETE"; + } + if (allStringEq_5) { + return { state: utilWaiter.WaiterState.SUCCESS, reason }; + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + for (const anyStringEq_4 of returnComparator()) { + if (anyStringEq_4 == "CREATE_FAILED") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + for (const anyStringEq_4 of returnComparator()) { + if (anyStringEq_4 == "DELETE_COMPLETE") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + for (const anyStringEq_4 of returnComparator()) { + if (anyStringEq_4 == "DELETE_FAILED") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + for (const anyStringEq_4 of returnComparator()) { + if (anyStringEq_4 == "ROLLBACK_FAILED") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + for (const anyStringEq_4 of returnComparator()) { + if (anyStringEq_4 == "ROLLBACK_COMPLETE") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + } + catch (e) { } } - - if (message.length !== message.readUInt32BE(0)) { - throw new Error('Reported message length does not match received message length'); + catch (exception) { + reason = exception; + if (exception.name && exception.name == "ValidationError") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } } + return { state: utilWaiter.WaiterState.RETRY, reason }; +}; +const waitForStackCreateComplete = async (params, input) => { + const serviceDefaults = { minDelay: 30, maxDelay: 120 }; + return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8); +}; +const waitUntilStackCreateComplete = async (params, input) => { + const serviceDefaults = { minDelay: 30, maxDelay: 120 }; + const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8); + return utilWaiter.checkExceptions(result); +}; - var expectedPreludeChecksum = message.readUInt32BE(PRELUDE_LENGTH); - - if ( - expectedPreludeChecksum !== util.crypto.crc32( - message.slice(0, PRELUDE_LENGTH) - ) - ) { - throw new Error( - 'The prelude checksum specified in the message (' + - expectedPreludeChecksum + - ') does not match the calculated CRC32 checksum.' - ); +const checkState$7 = async (client, input) => { + let reason; + try { + const result = await client.send(new DescribeStacksCommand(input)); + reason = result; + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + let allStringEq_5 = returnComparator().length > 0; + for (const element_4 of returnComparator()) { + allStringEq_5 = allStringEq_5 && element_4 == "DELETE_COMPLETE"; + } + if (allStringEq_5) { + return { state: utilWaiter.WaiterState.SUCCESS, reason }; + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + for (const anyStringEq_4 of returnComparator()) { + if (anyStringEq_4 == "DELETE_FAILED") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + for (const anyStringEq_4 of returnComparator()) { + if (anyStringEq_4 == "CREATE_FAILED") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + for (const anyStringEq_4 of returnComparator()) { + if (anyStringEq_4 == "ROLLBACK_FAILED") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + for (const anyStringEq_4 of returnComparator()) { + if (anyStringEq_4 == "UPDATE_ROLLBACK_IN_PROGRESS") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + for (const anyStringEq_4 of returnComparator()) { + if (anyStringEq_4 == "UPDATE_ROLLBACK_FAILED") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + for (const anyStringEq_4 of returnComparator()) { + if (anyStringEq_4 == "UPDATE_ROLLBACK_COMPLETE") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + for (const anyStringEq_4 of returnComparator()) { + if (anyStringEq_4 == "UPDATE_COMPLETE") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + } + catch (e) { } } - - var expectedMessageChecksum = message.readUInt32BE(message.length - CHECKSUM_LENGTH); - - if ( - expectedMessageChecksum !== util.crypto.crc32( - message.slice(0, message.length - CHECKSUM_LENGTH) - ) - ) { - throw new Error( - 'The message checksum did not match the expected value of ' + - expectedMessageChecksum - ); + catch (exception) { + reason = exception; + if (exception.name && exception.name == "ValidationError") { + return { state: utilWaiter.WaiterState.SUCCESS, reason }; + } } + return { state: utilWaiter.WaiterState.RETRY, reason }; +}; +const waitForStackDeleteComplete = async (params, input) => { + const serviceDefaults = { minDelay: 30, maxDelay: 120 }; + return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7); +}; +const waitUntilStackDeleteComplete = async (params, input) => { + const serviceDefaults = { minDelay: 30, maxDelay: 120 }; + const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7); + return utilWaiter.checkExceptions(result); +}; - var headersStart = PRELUDE_LENGTH + CHECKSUM_LENGTH; - var headersEnd = headersStart + message.readUInt32BE(PRELUDE_MEMBER_LENGTH); - - return { - headers: message.slice(headersStart, headersEnd), - body: message.slice(headersEnd, message.length - CHECKSUM_LENGTH), - }; -} +const checkState$6 = async (client, input) => { + let reason; + try { + const result = await client.send(new DescribeStacksCommand(input)); + reason = result; + return { state: utilWaiter.WaiterState.SUCCESS, reason }; + } + catch (exception) { + reason = exception; + if (exception.name && exception.name == "ValidationError") { + return { state: utilWaiter.WaiterState.RETRY, reason }; + } + } + return { state: utilWaiter.WaiterState.RETRY, reason }; +}; +const waitForStackExists = async (params, input) => { + const serviceDefaults = { minDelay: 5, maxDelay: 120 }; + return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6); +}; +const waitUntilStackExists = async (params, input) => { + const serviceDefaults = { minDelay: 5, maxDelay: 120 }; + const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6); + return utilWaiter.checkExceptions(result); +}; -/** - * @api private - */ -module.exports = { - splitMessage: splitMessage +const checkState$5 = async (client, input) => { + let reason; + try { + const result = await client.send(new DescribeStacksCommand(input)); + reason = result; + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + let allStringEq_5 = returnComparator().length > 0; + for (const element_4 of returnComparator()) { + allStringEq_5 = allStringEq_5 && element_4 == "IMPORT_COMPLETE"; + } + if (allStringEq_5) { + return { state: utilWaiter.WaiterState.SUCCESS, reason }; + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + for (const anyStringEq_4 of returnComparator()) { + if (anyStringEq_4 == "ROLLBACK_COMPLETE") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + for (const anyStringEq_4 of returnComparator()) { + if (anyStringEq_4 == "ROLLBACK_FAILED") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + for (const anyStringEq_4 of returnComparator()) { + if (anyStringEq_4 == "IMPORT_ROLLBACK_IN_PROGRESS") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + for (const anyStringEq_4 of returnComparator()) { + if (anyStringEq_4 == "IMPORT_ROLLBACK_FAILED") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + for (const anyStringEq_4 of returnComparator()) { + if (anyStringEq_4 == "IMPORT_ROLLBACK_COMPLETE") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + } + catch (e) { } + } + catch (exception) { + reason = exception; + if (exception.name && exception.name == "ValidationError") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + return { state: utilWaiter.WaiterState.RETRY, reason }; +}; +const waitForStackImportComplete = async (params, input) => { + const serviceDefaults = { minDelay: 30, maxDelay: 120 }; + return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5); +}; +const waitUntilStackImportComplete = async (params, input) => { + const serviceDefaults = { minDelay: 30, maxDelay: 120 }; + const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5); + return utilWaiter.checkExceptions(result); }; +const checkState$4 = async (client, input) => { + let reason; + try { + const result = await client.send(new DescribeStackRefactorCommand(input)); + reason = result; + try { + const returnComparator = () => { + return result.Status; + }; + if (returnComparator() === "CREATE_COMPLETE") { + return { state: utilWaiter.WaiterState.SUCCESS, reason }; + } + } + catch (e) { } + try { + const returnComparator = () => { + return result.Status; + }; + if (returnComparator() === "CREATE_FAILED") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + catch (e) { } + } + catch (exception) { + reason = exception; + if (exception.name && exception.name == "ValidationError") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + return { state: utilWaiter.WaiterState.RETRY, reason }; +}; +const waitForStackRefactorCreateComplete = async (params, input) => { + const serviceDefaults = { minDelay: 5, maxDelay: 120 }; + return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4); +}; +const waitUntilStackRefactorCreateComplete = async (params, input) => { + const serviceDefaults = { minDelay: 5, maxDelay: 120 }; + const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4); + return utilWaiter.checkExceptions(result); +}; -/***/ }), +const checkState$3 = async (client, input) => { + let reason; + try { + const result = await client.send(new DescribeStackRefactorCommand(input)); + reason = result; + try { + const returnComparator = () => { + return result.ExecutionStatus; + }; + if (returnComparator() === "EXECUTE_COMPLETE") { + return { state: utilWaiter.WaiterState.SUCCESS, reason }; + } + } + catch (e) { } + try { + const returnComparator = () => { + return result.ExecutionStatus; + }; + if (returnComparator() === "EXECUTE_FAILED") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + catch (e) { } + try { + const returnComparator = () => { + return result.ExecutionStatus; + }; + if (returnComparator() === "ROLLBACK_COMPLETE") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + catch (e) { } + } + catch (exception) { + reason = exception; + if (exception.name && exception.name == "ValidationError") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + return { state: utilWaiter.WaiterState.RETRY, reason }; +}; +const waitForStackRefactorExecuteComplete = async (params, input) => { + const serviceDefaults = { minDelay: 15, maxDelay: 120 }; + return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3); +}; +const waitUntilStackRefactorExecuteComplete = async (params, input) => { + const serviceDefaults = { minDelay: 15, maxDelay: 120 }; + const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3); + return utilWaiter.checkExceptions(result); +}; -/***/ 1176: -/***/ (function(module) { +const checkState$2 = async (client, input) => { + let reason; + try { + const result = await client.send(new DescribeStacksCommand(input)); + reason = result; + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + let allStringEq_5 = returnComparator().length > 0; + for (const element_4 of returnComparator()) { + allStringEq_5 = allStringEq_5 && element_4 == "UPDATE_ROLLBACK_COMPLETE"; + } + if (allStringEq_5) { + return { state: utilWaiter.WaiterState.SUCCESS, reason }; + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + for (const anyStringEq_4 of returnComparator()) { + if (anyStringEq_4 == "UPDATE_FAILED") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + for (const anyStringEq_4 of returnComparator()) { + if (anyStringEq_4 == "UPDATE_ROLLBACK_FAILED") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + for (const anyStringEq_4 of returnComparator()) { + if (anyStringEq_4 == "DELETE_FAILED") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + } + catch (e) { } + } + catch (exception) { + reason = exception; + if (exception.name && exception.name == "ValidationError") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + return { state: utilWaiter.WaiterState.RETRY, reason }; +}; +const waitForStackRollbackComplete = async (params, input) => { + const serviceDefaults = { minDelay: 30, maxDelay: 120 }; + return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2); +}; +const waitUntilStackRollbackComplete = async (params, input) => { + const serviceDefaults = { minDelay: 30, maxDelay: 120 }; + const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2); + return utilWaiter.checkExceptions(result); +}; -module.exports = {"metadata":{"apiVersion":"2019-12-02","endpointPrefix":"schemas","signingName":"schemas","serviceFullName":"Schemas","serviceId":"schemas","protocol":"rest-json","jsonVersion":"1.1","uid":"schemas-2019-12-02","signatureVersion":"v4"},"operations":{"CreateDiscoverer":{"http":{"requestUri":"/v1/discoverers","responseCode":201},"input":{"type":"structure","members":{"Description":{},"SourceArn":{},"Tags":{"shape":"S4","locationName":"tags"}},"required":["SourceArn"]},"output":{"type":"structure","members":{"Description":{},"DiscovererArn":{},"DiscovererId":{},"SourceArn":{},"State":{},"Tags":{"shape":"S4","locationName":"tags"}}}},"CreateRegistry":{"http":{"requestUri":"/v1/registries/name/{registryName}","responseCode":201},"input":{"type":"structure","members":{"Description":{},"RegistryName":{"location":"uri","locationName":"registryName"},"Tags":{"shape":"S4","locationName":"tags"}},"required":["RegistryName"]},"output":{"type":"structure","members":{"Description":{},"RegistryArn":{},"RegistryName":{},"Tags":{"shape":"S4","locationName":"tags"}}}},"CreateSchema":{"http":{"requestUri":"/v1/registries/name/{registryName}/schemas/name/{schemaName}","responseCode":201},"input":{"type":"structure","members":{"Content":{},"Description":{},"RegistryName":{"location":"uri","locationName":"registryName"},"SchemaName":{"location":"uri","locationName":"schemaName"},"Tags":{"shape":"S4","locationName":"tags"},"Type":{}},"required":["RegistryName","SchemaName","Type","Content"]},"output":{"type":"structure","members":{"Description":{},"LastModified":{"shape":"Se"},"SchemaArn":{},"SchemaName":{},"SchemaVersion":{},"Tags":{"shape":"S4","locationName":"tags"},"Type":{},"VersionCreatedDate":{"shape":"Se"}}}},"DeleteDiscoverer":{"http":{"method":"DELETE","requestUri":"/v1/discoverers/id/{discovererId}","responseCode":204},"input":{"type":"structure","members":{"DiscovererId":{"location":"uri","locationName":"discovererId"}},"required":["DiscovererId"]}},"DeleteRegistry":{"http":{"method":"DELETE","requestUri":"/v1/registries/name/{registryName}","responseCode":204},"input":{"type":"structure","members":{"RegistryName":{"location":"uri","locationName":"registryName"}},"required":["RegistryName"]}},"DeleteResourcePolicy":{"http":{"method":"DELETE","requestUri":"/v1/policy","responseCode":204},"input":{"type":"structure","members":{"RegistryName":{"location":"querystring","locationName":"registryName"}}}},"DeleteSchema":{"http":{"method":"DELETE","requestUri":"/v1/registries/name/{registryName}/schemas/name/{schemaName}","responseCode":204},"input":{"type":"structure","members":{"RegistryName":{"location":"uri","locationName":"registryName"},"SchemaName":{"location":"uri","locationName":"schemaName"}},"required":["RegistryName","SchemaName"]}},"DeleteSchemaVersion":{"http":{"method":"DELETE","requestUri":"/v1/registries/name/{registryName}/schemas/name/{schemaName}/version/{schemaVersion}","responseCode":204},"input":{"type":"structure","members":{"RegistryName":{"location":"uri","locationName":"registryName"},"SchemaName":{"location":"uri","locationName":"schemaName"},"SchemaVersion":{"location":"uri","locationName":"schemaVersion"}},"required":["SchemaVersion","RegistryName","SchemaName"]}},"DescribeCodeBinding":{"http":{"method":"GET","requestUri":"/v1/registries/name/{registryName}/schemas/name/{schemaName}/language/{language}","responseCode":200},"input":{"type":"structure","members":{"Language":{"location":"uri","locationName":"language"},"RegistryName":{"location":"uri","locationName":"registryName"},"SchemaName":{"location":"uri","locationName":"schemaName"},"SchemaVersion":{"location":"querystring","locationName":"schemaVersion"}},"required":["RegistryName","SchemaName","Language"]},"output":{"type":"structure","members":{"CreationDate":{"shape":"Se"},"LastModified":{"shape":"Se"},"SchemaVersion":{},"Status":{}}}},"DescribeDiscoverer":{"http":{"method":"GET","requestUri":"/v1/discoverers/id/{discovererId}","responseCode":200},"input":{"type":"structure","members":{"DiscovererId":{"location":"uri","locationName":"discovererId"}},"required":["DiscovererId"]},"output":{"type":"structure","members":{"Description":{},"DiscovererArn":{},"DiscovererId":{},"SourceArn":{},"State":{},"Tags":{"shape":"S4","locationName":"tags"}}}},"DescribeRegistry":{"http":{"method":"GET","requestUri":"/v1/registries/name/{registryName}","responseCode":200},"input":{"type":"structure","members":{"RegistryName":{"location":"uri","locationName":"registryName"}},"required":["RegistryName"]},"output":{"type":"structure","members":{"Description":{},"RegistryArn":{},"RegistryName":{},"Tags":{"shape":"S4","locationName":"tags"}}}},"DescribeSchema":{"http":{"method":"GET","requestUri":"/v1/registries/name/{registryName}/schemas/name/{schemaName}","responseCode":200},"input":{"type":"structure","members":{"RegistryName":{"location":"uri","locationName":"registryName"},"SchemaName":{"location":"uri","locationName":"schemaName"},"SchemaVersion":{"location":"querystring","locationName":"schemaVersion"}},"required":["RegistryName","SchemaName"]},"output":{"type":"structure","members":{"Content":{},"Description":{},"LastModified":{"shape":"Se"},"SchemaArn":{},"SchemaName":{},"SchemaVersion":{},"Tags":{"shape":"S4","locationName":"tags"},"Type":{},"VersionCreatedDate":{"shape":"Se"}}}},"GetCodeBindingSource":{"http":{"method":"GET","requestUri":"/v1/registries/name/{registryName}/schemas/name/{schemaName}/language/{language}/source","responseCode":200},"input":{"type":"structure","members":{"Language":{"location":"uri","locationName":"language"},"RegistryName":{"location":"uri","locationName":"registryName"},"SchemaName":{"location":"uri","locationName":"schemaName"},"SchemaVersion":{"location":"querystring","locationName":"schemaVersion"}},"required":["RegistryName","SchemaName","Language"]},"output":{"type":"structure","members":{"Body":{"type":"blob"}},"payload":"Body"}},"GetDiscoveredSchema":{"http":{"requestUri":"/v1/discover","responseCode":200},"input":{"type":"structure","members":{"Events":{"type":"list","member":{}},"Type":{}},"required":["Type","Events"]},"output":{"type":"structure","members":{"Content":{}}}},"GetResourcePolicy":{"http":{"method":"GET","requestUri":"/v1/policy","responseCode":200},"input":{"type":"structure","members":{"RegistryName":{"location":"querystring","locationName":"registryName"}}},"output":{"type":"structure","members":{"Policy":{"jsonvalue":true},"RevisionId":{}}}},"ListDiscoverers":{"http":{"method":"GET","requestUri":"/v1/discoverers","responseCode":200},"input":{"type":"structure","members":{"DiscovererIdPrefix":{"location":"querystring","locationName":"discovererIdPrefix"},"Limit":{"location":"querystring","locationName":"limit","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"},"SourceArnPrefix":{"location":"querystring","locationName":"sourceArnPrefix"}}},"output":{"type":"structure","members":{"Discoverers":{"type":"list","member":{"type":"structure","members":{"DiscovererArn":{},"DiscovererId":{},"SourceArn":{},"State":{},"Tags":{"shape":"S4","locationName":"tags"}}}},"NextToken":{}}}},"ListRegistries":{"http":{"method":"GET","requestUri":"/v1/registries","responseCode":200},"input":{"type":"structure","members":{"Limit":{"location":"querystring","locationName":"limit","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"},"RegistryNamePrefix":{"location":"querystring","locationName":"registryNamePrefix"},"Scope":{"location":"querystring","locationName":"scope"}}},"output":{"type":"structure","members":{"NextToken":{},"Registries":{"type":"list","member":{"type":"structure","members":{"RegistryArn":{},"RegistryName":{},"Tags":{"shape":"S4","locationName":"tags"}}}}}}},"ListSchemaVersions":{"http":{"method":"GET","requestUri":"/v1/registries/name/{registryName}/schemas/name/{schemaName}/versions","responseCode":200},"input":{"type":"structure","members":{"Limit":{"location":"querystring","locationName":"limit","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"},"RegistryName":{"location":"uri","locationName":"registryName"},"SchemaName":{"location":"uri","locationName":"schemaName"}},"required":["RegistryName","SchemaName"]},"output":{"type":"structure","members":{"NextToken":{},"SchemaVersions":{"type":"list","member":{"type":"structure","members":{"SchemaArn":{},"SchemaName":{},"SchemaVersion":{}}}}}}},"ListSchemas":{"http":{"method":"GET","requestUri":"/v1/registries/name/{registryName}/schemas","responseCode":200},"input":{"type":"structure","members":{"Limit":{"location":"querystring","locationName":"limit","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"},"RegistryName":{"location":"uri","locationName":"registryName"},"SchemaNamePrefix":{"location":"querystring","locationName":"schemaNamePrefix"}},"required":["RegistryName"]},"output":{"type":"structure","members":{"NextToken":{},"Schemas":{"type":"list","member":{"type":"structure","members":{"LastModified":{"shape":"Se"},"SchemaArn":{},"SchemaName":{},"Tags":{"shape":"S4","locationName":"tags"},"VersionCount":{"type":"long"}}}}}}},"ListTagsForResource":{"http":{"method":"GET","requestUri":"/tags/{resource-arn}","responseCode":200},"input":{"type":"structure","members":{"ResourceArn":{"location":"uri","locationName":"resource-arn"}},"required":["ResourceArn"]},"output":{"type":"structure","members":{"Tags":{"shape":"S4","locationName":"tags"}}}},"PutCodeBinding":{"http":{"requestUri":"/v1/registries/name/{registryName}/schemas/name/{schemaName}/language/{language}","responseCode":202},"input":{"type":"structure","members":{"Language":{"location":"uri","locationName":"language"},"RegistryName":{"location":"uri","locationName":"registryName"},"SchemaName":{"location":"uri","locationName":"schemaName"},"SchemaVersion":{"location":"querystring","locationName":"schemaVersion"}},"required":["RegistryName","SchemaName","Language"]},"output":{"type":"structure","members":{"CreationDate":{"shape":"Se"},"LastModified":{"shape":"Se"},"SchemaVersion":{},"Status":{}}}},"PutResourcePolicy":{"http":{"method":"PUT","requestUri":"/v1/policy","responseCode":200},"input":{"type":"structure","members":{"Policy":{"jsonvalue":true},"RegistryName":{"location":"querystring","locationName":"registryName"},"RevisionId":{}},"required":["Policy"]},"output":{"type":"structure","members":{"Policy":{"jsonvalue":true},"RevisionId":{}}}},"SearchSchemas":{"http":{"method":"GET","requestUri":"/v1/registries/name/{registryName}/schemas/search","responseCode":200},"input":{"type":"structure","members":{"Keywords":{"location":"querystring","locationName":"keywords"},"Limit":{"location":"querystring","locationName":"limit","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"},"RegistryName":{"location":"uri","locationName":"registryName"}},"required":["RegistryName","Keywords"]},"output":{"type":"structure","members":{"NextToken":{},"Schemas":{"type":"list","member":{"type":"structure","members":{"RegistryName":{},"SchemaArn":{},"SchemaName":{},"SchemaVersions":{"type":"list","member":{"type":"structure","members":{"CreatedDate":{"shape":"Se"},"SchemaVersion":{}}}}}}}}}},"StartDiscoverer":{"http":{"requestUri":"/v1/discoverers/id/{discovererId}/start","responseCode":200},"input":{"type":"structure","members":{"DiscovererId":{"location":"uri","locationName":"discovererId"}},"required":["DiscovererId"]},"output":{"type":"structure","members":{"DiscovererId":{},"State":{}}}},"StopDiscoverer":{"http":{"requestUri":"/v1/discoverers/id/{discovererId}/stop","responseCode":200},"input":{"type":"structure","members":{"DiscovererId":{"location":"uri","locationName":"discovererId"}},"required":["DiscovererId"]},"output":{"type":"structure","members":{"DiscovererId":{},"State":{}}}},"TagResource":{"http":{"requestUri":"/tags/{resource-arn}","responseCode":204},"input":{"type":"structure","members":{"ResourceArn":{"location":"uri","locationName":"resource-arn"},"Tags":{"shape":"S4","locationName":"tags"}},"required":["ResourceArn","Tags"]}},"UntagResource":{"http":{"method":"DELETE","requestUri":"/tags/{resource-arn}","responseCode":204},"input":{"type":"structure","members":{"ResourceArn":{"location":"uri","locationName":"resource-arn"},"TagKeys":{"location":"querystring","locationName":"tagKeys","type":"list","member":{}}},"required":["TagKeys","ResourceArn"]}},"UpdateDiscoverer":{"http":{"method":"PUT","requestUri":"/v1/discoverers/id/{discovererId}","responseCode":200},"input":{"type":"structure","members":{"Description":{},"DiscovererId":{"location":"uri","locationName":"discovererId"}},"required":["DiscovererId"]},"output":{"type":"structure","members":{"Description":{},"DiscovererArn":{},"DiscovererId":{},"SourceArn":{},"State":{},"Tags":{"shape":"S4","locationName":"tags"}}}},"UpdateRegistry":{"http":{"method":"PUT","requestUri":"/v1/registries/name/{registryName}","responseCode":200},"input":{"type":"structure","members":{"Description":{},"RegistryName":{"location":"uri","locationName":"registryName"}},"required":["RegistryName"]},"output":{"type":"structure","members":{"Description":{},"RegistryArn":{},"RegistryName":{},"Tags":{"shape":"S4","locationName":"tags"}}}},"UpdateSchema":{"http":{"method":"PUT","requestUri":"/v1/registries/name/{registryName}/schemas/name/{schemaName}","responseCode":200},"input":{"type":"structure","members":{"ClientTokenId":{"idempotencyToken":true},"Content":{},"Description":{},"RegistryName":{"location":"uri","locationName":"registryName"},"SchemaName":{"location":"uri","locationName":"schemaName"},"Type":{}},"required":["RegistryName","SchemaName"]},"output":{"type":"structure","members":{"Description":{},"LastModified":{"shape":"Se"},"SchemaArn":{},"SchemaName":{},"SchemaVersion":{},"Tags":{"shape":"S4","locationName":"tags"},"Type":{},"VersionCreatedDate":{"shape":"Se"}}}}},"shapes":{"S4":{"type":"map","key":{},"value":{}},"Se":{"type":"timestamp","timestampFormat":"iso8601"}}}; +const checkState$1 = async (client, input) => { + let reason; + try { + const result = await client.send(new DescribeStacksCommand(input)); + reason = result; + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + let allStringEq_5 = returnComparator().length > 0; + for (const element_4 of returnComparator()) { + allStringEq_5 = allStringEq_5 && element_4 == "UPDATE_COMPLETE"; + } + if (allStringEq_5) { + return { state: utilWaiter.WaiterState.SUCCESS, reason }; + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + for (const anyStringEq_4 of returnComparator()) { + if (anyStringEq_4 == "UPDATE_FAILED") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + for (const anyStringEq_4 of returnComparator()) { + if (anyStringEq_4 == "UPDATE_ROLLBACK_FAILED") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + } + catch (e) { } + try { + const returnComparator = () => { + const flat_1 = [].concat(...result.Stacks); + const projection_3 = flat_1.map((element_2) => { + return element_2.StackStatus; + }); + return projection_3; + }; + for (const anyStringEq_4 of returnComparator()) { + if (anyStringEq_4 == "UPDATE_ROLLBACK_COMPLETE") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + } + catch (e) { } + } + catch (exception) { + reason = exception; + if (exception.name && exception.name == "ValidationError") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + return { state: utilWaiter.WaiterState.RETRY, reason }; +}; +const waitForStackUpdateComplete = async (params, input) => { + const serviceDefaults = { minDelay: 30, maxDelay: 120 }; + return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1); +}; +const waitUntilStackUpdateComplete = async (params, input) => { + const serviceDefaults = { minDelay: 30, maxDelay: 120 }; + const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1); + return utilWaiter.checkExceptions(result); +}; -/***/ }), +const checkState = async (client, input) => { + let reason; + try { + const result = await client.send(new DescribeTypeRegistrationCommand(input)); + reason = result; + try { + const returnComparator = () => { + return result.ProgressStatus; + }; + if (returnComparator() === "COMPLETE") { + return { state: utilWaiter.WaiterState.SUCCESS, reason }; + } + } + catch (e) { } + try { + const returnComparator = () => { + return result.ProgressStatus; + }; + if (returnComparator() === "FAILED") { + return { state: utilWaiter.WaiterState.FAILURE, reason }; + } + } + catch (e) { } + } + catch (exception) { + reason = exception; + } + return { state: utilWaiter.WaiterState.RETRY, reason }; +}; +const waitForTypeRegistrationComplete = async (params, input) => { + const serviceDefaults = { minDelay: 30, maxDelay: 120 }; + return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState); +}; +const waitUntilTypeRegistrationComplete = async (params, input) => { + const serviceDefaults = { minDelay: 30, maxDelay: 120 }; + const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState); + return utilWaiter.checkExceptions(result); +}; -/***/ 1186: -/***/ (function(module, __unusedexports, __webpack_require__) { +const AccountFilterType = { + DIFFERENCE: "DIFFERENCE", + INTERSECTION: "INTERSECTION", + NONE: "NONE", + UNION: "UNION", +}; +const AccountGateStatus = { + FAILED: "FAILED", + SKIPPED: "SKIPPED", + SUCCEEDED: "SUCCEEDED", +}; +const ThirdPartyType = { + HOOK: "HOOK", + MODULE: "MODULE", + RESOURCE: "RESOURCE", +}; +const VersionBump = { + MAJOR: "MAJOR", + MINOR: "MINOR", +}; +const AfterValueFrom = { + TEMPLATE: "TEMPLATE", +}; +const AnnotationSeverityLevel = { + CRITICAL: "CRITICAL", + HIGH: "HIGH", + INFORMATIONAL: "INFORMATIONAL", + LOW: "LOW", + MEDIUM: "MEDIUM", +}; +const AnnotationStatus = { + FAILED: "FAILED", + PASSED: "PASSED", + SKIPPED: "SKIPPED", +}; +const AttributeChangeType = { + Add: "Add", + Modify: "Modify", + Remove: "Remove", + SyncWithActual: "SyncWithActual", +}; +const BeaconStackOperationStatus = { + FAILED: "FAILED", + IN_PROGRESS: "IN_PROGRESS", + SUCCEEDED: "SUCCEEDED", +}; +const BeforeValueFrom = { + ACTUAL_STATE: "ACTUAL_STATE", + PREVIOUS_DEPLOYMENT_STATE: "PREVIOUS_DEPLOYMENT_STATE", +}; +const CallAs = { + DELEGATED_ADMIN: "DELEGATED_ADMIN", + SELF: "SELF", +}; +const Capability = { + CAPABILITY_AUTO_EXPAND: "CAPABILITY_AUTO_EXPAND", + CAPABILITY_IAM: "CAPABILITY_IAM", + CAPABILITY_NAMED_IAM: "CAPABILITY_NAMED_IAM", +}; +const Category = { + ACTIVATED: "ACTIVATED", + AWS_TYPES: "AWS_TYPES", + REGISTERED: "REGISTERED", + THIRD_PARTY: "THIRD_PARTY", +}; +const ChangeAction = { + Add: "Add", + Dynamic: "Dynamic", + Import: "Import", + Modify: "Modify", + Remove: "Remove", + SyncWithActual: "SyncWithActual", +}; +const ChangeSource = { + Automatic: "Automatic", + DirectModification: "DirectModification", + NoModification: "NoModification", + ParameterReference: "ParameterReference", + ResourceAttribute: "ResourceAttribute", + ResourceReference: "ResourceReference", +}; +const EvaluationType = { + Dynamic: "Dynamic", + Static: "Static", +}; +const ResourceAttribute = { + CreationPolicy: "CreationPolicy", + DeletionPolicy: "DeletionPolicy", + Metadata: "Metadata", + Properties: "Properties", + Tags: "Tags", + UpdatePolicy: "UpdatePolicy", + UpdateReplacePolicy: "UpdateReplacePolicy", +}; +const RequiresRecreation = { + Always: "Always", + Conditionally: "Conditionally", + Never: "Never", +}; +const PolicyAction = { + Delete: "Delete", + ReplaceAndDelete: "ReplaceAndDelete", + ReplaceAndRetain: "ReplaceAndRetain", + ReplaceAndSnapshot: "ReplaceAndSnapshot", + Retain: "Retain", + Snapshot: "Snapshot", +}; +const Replacement = { + Conditional: "Conditional", + False: "False", + True: "True", +}; +const DriftIgnoredReason = { + MANAGED_BY_AWS: "MANAGED_BY_AWS", + WRITE_ONLY_PROPERTY: "WRITE_ONLY_PROPERTY", +}; +const StackResourceDriftStatus = { + DELETED: "DELETED", + IN_SYNC: "IN_SYNC", + MODIFIED: "MODIFIED", + NOT_CHECKED: "NOT_CHECKED", + UNKNOWN: "UNKNOWN", + UNSUPPORTED: "UNSUPPORTED", +}; +const ChangeType = { + Resource: "Resource", +}; +const HookFailureMode = { + FAIL: "FAIL", + WARN: "WARN", +}; +const HookInvocationPoint = { + PRE_PROVISION: "PRE_PROVISION", +}; +const HookTargetType = { + RESOURCE: "RESOURCE", +}; +const ChangeSetHooksStatus = { + PLANNED: "PLANNED", + PLANNING: "PLANNING", + UNAVAILABLE: "UNAVAILABLE", +}; +const ChangeSetStatus = { + CREATE_COMPLETE: "CREATE_COMPLETE", + CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS", + CREATE_PENDING: "CREATE_PENDING", + DELETE_COMPLETE: "DELETE_COMPLETE", + DELETE_FAILED: "DELETE_FAILED", + DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS", + DELETE_PENDING: "DELETE_PENDING", + FAILED: "FAILED", +}; +const ExecutionStatus = { + AVAILABLE: "AVAILABLE", + EXECUTE_COMPLETE: "EXECUTE_COMPLETE", + EXECUTE_FAILED: "EXECUTE_FAILED", + EXECUTE_IN_PROGRESS: "EXECUTE_IN_PROGRESS", + OBSOLETE: "OBSOLETE", + UNAVAILABLE: "UNAVAILABLE", +}; +const ChangeSetType = { + CREATE: "CREATE", + IMPORT: "IMPORT", + UPDATE: "UPDATE", +}; +const DeploymentMode = { + REVERT_DRIFT: "REVERT_DRIFT", +}; +const OnStackFailure = { + DELETE: "DELETE", + DO_NOTHING: "DO_NOTHING", + ROLLBACK: "ROLLBACK", +}; +const GeneratedTemplateDeletionPolicy = { + DELETE: "DELETE", + RETAIN: "RETAIN", +}; +const GeneratedTemplateUpdateReplacePolicy = { + DELETE: "DELETE", + RETAIN: "RETAIN", +}; +const OnFailure = { + DELETE: "DELETE", + DO_NOTHING: "DO_NOTHING", + ROLLBACK: "ROLLBACK", +}; +const ConcurrencyMode = { + SOFT_FAILURE_TOLERANCE: "SOFT_FAILURE_TOLERANCE", + STRICT_FAILURE_TOLERANCE: "STRICT_FAILURE_TOLERANCE", +}; +const RegionConcurrencyType = { + PARALLEL: "PARALLEL", + SEQUENTIAL: "SEQUENTIAL", +}; +const PermissionModels = { + SELF_MANAGED: "SELF_MANAGED", + SERVICE_MANAGED: "SERVICE_MANAGED", +}; +const DeletionMode = { + FORCE_DELETE_STACK: "FORCE_DELETE_STACK", + STANDARD: "STANDARD", +}; +const RegistryType = { + HOOK: "HOOK", + MODULE: "MODULE", + RESOURCE: "RESOURCE", +}; +const StackDriftStatus = { + DRIFTED: "DRIFTED", + IN_SYNC: "IN_SYNC", + NOT_CHECKED: "NOT_CHECKED", + UNKNOWN: "UNKNOWN", +}; +const DetailedStatus = { + CONFIGURATION_COMPLETE: "CONFIGURATION_COMPLETE", + VALIDATION_FAILED: "VALIDATION_FAILED", +}; +const EventType = { + HOOK_INVOCATION_ERROR: "HOOK_INVOCATION_ERROR", + PROGRESS_EVENT: "PROGRESS_EVENT", + PROVISIONING_ERROR: "PROVISIONING_ERROR", + STACK_EVENT: "STACK_EVENT", + VALIDATION_ERROR: "VALIDATION_ERROR", +}; +const HookStatus = { + HOOK_COMPLETE_FAILED: "HOOK_COMPLETE_FAILED", + HOOK_COMPLETE_SUCCEEDED: "HOOK_COMPLETE_SUCCEEDED", + HOOK_FAILED: "HOOK_FAILED", + HOOK_IN_PROGRESS: "HOOK_IN_PROGRESS", +}; +const OperationType = { + CONTINUE_ROLLBACK: "CONTINUE_ROLLBACK", + CREATE_CHANGESET: "CREATE_CHANGESET", + CREATE_STACK: "CREATE_STACK", + DELETE_STACK: "DELETE_STACK", + ROLLBACK: "ROLLBACK", + UPDATE_STACK: "UPDATE_STACK", +}; +const ResourceStatus = { + CREATE_COMPLETE: "CREATE_COMPLETE", + CREATE_FAILED: "CREATE_FAILED", + CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS", + DELETE_COMPLETE: "DELETE_COMPLETE", + DELETE_FAILED: "DELETE_FAILED", + DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS", + DELETE_SKIPPED: "DELETE_SKIPPED", + EXPORT_COMPLETE: "EXPORT_COMPLETE", + EXPORT_FAILED: "EXPORT_FAILED", + EXPORT_IN_PROGRESS: "EXPORT_IN_PROGRESS", + EXPORT_ROLLBACK_COMPLETE: "EXPORT_ROLLBACK_COMPLETE", + EXPORT_ROLLBACK_FAILED: "EXPORT_ROLLBACK_FAILED", + EXPORT_ROLLBACK_IN_PROGRESS: "EXPORT_ROLLBACK_IN_PROGRESS", + IMPORT_COMPLETE: "IMPORT_COMPLETE", + IMPORT_FAILED: "IMPORT_FAILED", + IMPORT_IN_PROGRESS: "IMPORT_IN_PROGRESS", + IMPORT_ROLLBACK_COMPLETE: "IMPORT_ROLLBACK_COMPLETE", + IMPORT_ROLLBACK_FAILED: "IMPORT_ROLLBACK_FAILED", + IMPORT_ROLLBACK_IN_PROGRESS: "IMPORT_ROLLBACK_IN_PROGRESS", + ROLLBACK_COMPLETE: "ROLLBACK_COMPLETE", + ROLLBACK_FAILED: "ROLLBACK_FAILED", + ROLLBACK_IN_PROGRESS: "ROLLBACK_IN_PROGRESS", + UPDATE_COMPLETE: "UPDATE_COMPLETE", + UPDATE_FAILED: "UPDATE_FAILED", + UPDATE_IN_PROGRESS: "UPDATE_IN_PROGRESS", + UPDATE_ROLLBACK_COMPLETE: "UPDATE_ROLLBACK_COMPLETE", + UPDATE_ROLLBACK_FAILED: "UPDATE_ROLLBACK_FAILED", + UPDATE_ROLLBACK_IN_PROGRESS: "UPDATE_ROLLBACK_IN_PROGRESS", +}; +const ValidationStatus = { + FAILED: "FAILED", + SKIPPED: "SKIPPED", +}; +const GeneratedTemplateResourceStatus = { + COMPLETE: "COMPLETE", + FAILED: "FAILED", + IN_PROGRESS: "IN_PROGRESS", + PENDING: "PENDING", +}; +const WarningType = { + EXCLUDED_PROPERTIES: "EXCLUDED_PROPERTIES", + EXCLUDED_RESOURCES: "EXCLUDED_RESOURCES", + MUTUALLY_EXCLUSIVE_PROPERTIES: "MUTUALLY_EXCLUSIVE_PROPERTIES", + MUTUALLY_EXCLUSIVE_TYPES: "MUTUALLY_EXCLUSIVE_TYPES", + UNSUPPORTED_PROPERTIES: "UNSUPPORTED_PROPERTIES", +}; +const GeneratedTemplateStatus = { + COMPLETE: "COMPLETE", + CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS", + CREATE_PENDING: "CREATE_PENDING", + DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS", + DELETE_PENDING: "DELETE_PENDING", + FAILED: "FAILED", + UPDATE_IN_PROGRESS: "UPDATE_IN_PROGRESS", + UPDATE_PENDING: "UPDATE_PENDING", +}; +const OrganizationStatus = { + DISABLED: "DISABLED", + DISABLED_PERMANENTLY: "DISABLED_PERMANENTLY", + ENABLED: "ENABLED", +}; +const IdentityProvider = { + AWS_Marketplace: "AWS_Marketplace", + Bitbucket: "Bitbucket", + GitHub: "GitHub", +}; +const PublisherStatus = { + UNVERIFIED: "UNVERIFIED", + VERIFIED: "VERIFIED", +}; +const ResourceScanStatus = { + COMPLETE: "COMPLETE", + EXPIRED: "EXPIRED", + FAILED: "FAILED", + IN_PROGRESS: "IN_PROGRESS", +}; +const StackDriftDetectionStatus = { + DETECTION_COMPLETE: "DETECTION_COMPLETE", + DETECTION_FAILED: "DETECTION_FAILED", + DETECTION_IN_PROGRESS: "DETECTION_IN_PROGRESS", +}; +const StackInstanceDetailedStatus = { + CANCELLED: "CANCELLED", + FAILED: "FAILED", + FAILED_IMPORT: "FAILED_IMPORT", + INOPERABLE: "INOPERABLE", + PENDING: "PENDING", + RUNNING: "RUNNING", + SKIPPED_SUSPENDED_ACCOUNT: "SKIPPED_SUSPENDED_ACCOUNT", + SUCCEEDED: "SUCCEEDED", +}; +const StackInstanceStatus = { + CURRENT: "CURRENT", + INOPERABLE: "INOPERABLE", + OUTDATED: "OUTDATED", +}; +const StackRefactorExecutionStatus = { + AVAILABLE: "AVAILABLE", + EXECUTE_COMPLETE: "EXECUTE_COMPLETE", + EXECUTE_FAILED: "EXECUTE_FAILED", + EXECUTE_IN_PROGRESS: "EXECUTE_IN_PROGRESS", + OBSOLETE: "OBSOLETE", + ROLLBACK_COMPLETE: "ROLLBACK_COMPLETE", + ROLLBACK_FAILED: "ROLLBACK_FAILED", + ROLLBACK_IN_PROGRESS: "ROLLBACK_IN_PROGRESS", + UNAVAILABLE: "UNAVAILABLE", +}; +const StackRefactorStatus = { + CREATE_COMPLETE: "CREATE_COMPLETE", + CREATE_FAILED: "CREATE_FAILED", + CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS", + DELETE_COMPLETE: "DELETE_COMPLETE", + DELETE_FAILED: "DELETE_FAILED", + DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS", +}; +const DifferenceType = { + ADD: "ADD", + NOT_EQUAL: "NOT_EQUAL", + REMOVE: "REMOVE", +}; +const StackStatus = { + CREATE_COMPLETE: "CREATE_COMPLETE", + CREATE_FAILED: "CREATE_FAILED", + CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS", + DELETE_COMPLETE: "DELETE_COMPLETE", + DELETE_FAILED: "DELETE_FAILED", + DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS", + IMPORT_COMPLETE: "IMPORT_COMPLETE", + IMPORT_IN_PROGRESS: "IMPORT_IN_PROGRESS", + IMPORT_ROLLBACK_COMPLETE: "IMPORT_ROLLBACK_COMPLETE", + IMPORT_ROLLBACK_FAILED: "IMPORT_ROLLBACK_FAILED", + IMPORT_ROLLBACK_IN_PROGRESS: "IMPORT_ROLLBACK_IN_PROGRESS", + REVIEW_IN_PROGRESS: "REVIEW_IN_PROGRESS", + ROLLBACK_COMPLETE: "ROLLBACK_COMPLETE", + ROLLBACK_FAILED: "ROLLBACK_FAILED", + ROLLBACK_IN_PROGRESS: "ROLLBACK_IN_PROGRESS", + UPDATE_COMPLETE: "UPDATE_COMPLETE", + UPDATE_COMPLETE_CLEANUP_IN_PROGRESS: "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS", + UPDATE_FAILED: "UPDATE_FAILED", + UPDATE_IN_PROGRESS: "UPDATE_IN_PROGRESS", + UPDATE_ROLLBACK_COMPLETE: "UPDATE_ROLLBACK_COMPLETE", + UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS: "UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS", + UPDATE_ROLLBACK_FAILED: "UPDATE_ROLLBACK_FAILED", + UPDATE_ROLLBACK_IN_PROGRESS: "UPDATE_ROLLBACK_IN_PROGRESS", +}; +const StackSetDriftDetectionStatus = { + COMPLETED: "COMPLETED", + FAILED: "FAILED", + IN_PROGRESS: "IN_PROGRESS", + PARTIAL_SUCCESS: "PARTIAL_SUCCESS", + STOPPED: "STOPPED", +}; +const StackSetDriftStatus = { + DRIFTED: "DRIFTED", + IN_SYNC: "IN_SYNC", + NOT_CHECKED: "NOT_CHECKED", +}; +const StackSetStatus = { + ACTIVE: "ACTIVE", + DELETED: "DELETED", +}; +const StackSetOperationAction = { + CREATE: "CREATE", + DELETE: "DELETE", + DETECT_DRIFT: "DETECT_DRIFT", + UPDATE: "UPDATE", +}; +const StackSetOperationStatus = { + FAILED: "FAILED", + QUEUED: "QUEUED", + RUNNING: "RUNNING", + STOPPED: "STOPPED", + STOPPING: "STOPPING", + SUCCEEDED: "SUCCEEDED", +}; +const DeprecatedStatus = { + DEPRECATED: "DEPRECATED", + LIVE: "LIVE", +}; +const ProvisioningType = { + FULLY_MUTABLE: "FULLY_MUTABLE", + IMMUTABLE: "IMMUTABLE", + NON_PROVISIONABLE: "NON_PROVISIONABLE", +}; +const TypeTestsStatus = { + FAILED: "FAILED", + IN_PROGRESS: "IN_PROGRESS", + NOT_TESTED: "NOT_TESTED", + PASSED: "PASSED", +}; +const Visibility = { + PRIVATE: "PRIVATE", + PUBLIC: "PUBLIC", +}; +const RegistrationStatus = { + COMPLETE: "COMPLETE", + FAILED: "FAILED", + IN_PROGRESS: "IN_PROGRESS", +}; +const TemplateFormat = { + JSON: "JSON", + YAML: "YAML", +}; +const HookTargetAction = { + CREATE: "CREATE", + DELETE: "DELETE", + IMPORT: "IMPORT", + UPDATE: "UPDATE", +}; +const TemplateStage = { + Original: "Original", + Processed: "Processed", +}; +const ListHookResultsTargetType = { + CHANGE_SET: "CHANGE_SET", + CLOUD_CONTROL: "CLOUD_CONTROL", + RESOURCE: "RESOURCE", + STACK: "STACK", +}; +const ScanType = { + FULL: "FULL", + PARTIAL: "PARTIAL", +}; +const StackInstanceFilterName = { + DETAILED_STATUS: "DETAILED_STATUS", + DRIFT_STATUS: "DRIFT_STATUS", + LAST_OPERATION_ID: "LAST_OPERATION_ID", +}; +const StackRefactorActionType = { + CREATE: "CREATE", + MOVE: "MOVE", +}; +const StackRefactorDetection = { + AUTO: "AUTO", + MANUAL: "MANUAL", +}; +const StackRefactorActionEntity = { + RESOURCE: "RESOURCE", + STACK: "STACK", +}; +const OperationResultFilterName = { + OPERATION_RESULT_STATUS: "OPERATION_RESULT_STATUS", +}; +const StackSetOperationResultStatus = { + CANCELLED: "CANCELLED", + FAILED: "FAILED", + PENDING: "PENDING", + RUNNING: "RUNNING", + SUCCEEDED: "SUCCEEDED", +}; +const OperationStatus = { + FAILED: "FAILED", + IN_PROGRESS: "IN_PROGRESS", + PENDING: "PENDING", + SUCCESS: "SUCCESS", +}; +const HandlerErrorCode = { + AccessDenied: "AccessDenied", + AlreadyExists: "AlreadyExists", + GeneralServiceException: "GeneralServiceException", + HandlerInternalFailure: "HandlerInternalFailure", + InternalFailure: "InternalFailure", + InvalidCredentials: "InvalidCredentials", + InvalidRequest: "InvalidRequest", + InvalidTypeConfiguration: "InvalidTypeConfiguration", + NetworkFailure: "NetworkFailure", + NonCompliant: "NonCompliant", + NotFound: "NotFound", + NotUpdatable: "NotUpdatable", + ResourceConflict: "ResourceConflict", + ServiceInternalError: "ServiceInternalError", + ServiceLimitExceeded: "ServiceLimitExceeded", + ServiceTimeout: "NotStabilized", + Throttling: "Throttling", + Unknown: "Unknown", + UnsupportedTarget: "UnsupportedTarget", +}; +const ResourceSignalStatus = { + FAILURE: "FAILURE", + SUCCESS: "SUCCESS", +}; -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +Object.defineProperty(exports, "$Command", ({ + enumerable: true, + get: function () { return smithyClient.Command; } +})); +Object.defineProperty(exports, "__Client", ({ + enumerable: true, + get: function () { return smithyClient.Client; } +})); +exports.AccountFilterType = AccountFilterType; +exports.AccountGateStatus = AccountGateStatus; +exports.ActivateOrganizationsAccessCommand = ActivateOrganizationsAccessCommand; +exports.ActivateTypeCommand = ActivateTypeCommand; +exports.AfterValueFrom = AfterValueFrom; +exports.AlreadyExistsException = AlreadyExistsException$1; +exports.AnnotationSeverityLevel = AnnotationSeverityLevel; +exports.AnnotationStatus = AnnotationStatus; +exports.AttributeChangeType = AttributeChangeType; +exports.BatchDescribeTypeConfigurationsCommand = BatchDescribeTypeConfigurationsCommand; +exports.BeaconStackOperationStatus = BeaconStackOperationStatus; +exports.BeforeValueFrom = BeforeValueFrom; +exports.CFNRegistryException = CFNRegistryException$1; +exports.CallAs = CallAs; +exports.CancelUpdateStackCommand = CancelUpdateStackCommand; +exports.Capability = Capability; +exports.Category = Category; +exports.ChangeAction = ChangeAction; +exports.ChangeSetHooksStatus = ChangeSetHooksStatus; +exports.ChangeSetNotFoundException = ChangeSetNotFoundException$1; +exports.ChangeSetStatus = ChangeSetStatus; +exports.ChangeSetType = ChangeSetType; +exports.ChangeSource = ChangeSource; +exports.ChangeType = ChangeType; +exports.CloudFormation = CloudFormation; +exports.CloudFormationClient = CloudFormationClient; +exports.CloudFormationServiceException = CloudFormationServiceException$1; +exports.ConcurrencyMode = ConcurrencyMode; +exports.ConcurrentResourcesLimitExceededException = ConcurrentResourcesLimitExceededException$1; +exports.ContinueUpdateRollbackCommand = ContinueUpdateRollbackCommand; +exports.CreateChangeSetCommand = CreateChangeSetCommand; +exports.CreateGeneratedTemplateCommand = CreateGeneratedTemplateCommand; +exports.CreateStackCommand = CreateStackCommand; +exports.CreateStackInstancesCommand = CreateStackInstancesCommand; +exports.CreateStackRefactorCommand = CreateStackRefactorCommand; +exports.CreateStackSetCommand = CreateStackSetCommand; +exports.CreatedButModifiedException = CreatedButModifiedException$1; +exports.DeactivateOrganizationsAccessCommand = DeactivateOrganizationsAccessCommand; +exports.DeactivateTypeCommand = DeactivateTypeCommand; +exports.DeleteChangeSetCommand = DeleteChangeSetCommand; +exports.DeleteGeneratedTemplateCommand = DeleteGeneratedTemplateCommand; +exports.DeleteStackCommand = DeleteStackCommand; +exports.DeleteStackInstancesCommand = DeleteStackInstancesCommand; +exports.DeleteStackSetCommand = DeleteStackSetCommand; +exports.DeletionMode = DeletionMode; +exports.DeploymentMode = DeploymentMode; +exports.DeprecatedStatus = DeprecatedStatus; +exports.DeregisterTypeCommand = DeregisterTypeCommand; +exports.DescribeAccountLimitsCommand = DescribeAccountLimitsCommand; +exports.DescribeChangeSetCommand = DescribeChangeSetCommand; +exports.DescribeChangeSetHooksCommand = DescribeChangeSetHooksCommand; +exports.DescribeEventsCommand = DescribeEventsCommand; +exports.DescribeGeneratedTemplateCommand = DescribeGeneratedTemplateCommand; +exports.DescribeOrganizationsAccessCommand = DescribeOrganizationsAccessCommand; +exports.DescribePublisherCommand = DescribePublisherCommand; +exports.DescribeResourceScanCommand = DescribeResourceScanCommand; +exports.DescribeStackDriftDetectionStatusCommand = DescribeStackDriftDetectionStatusCommand; +exports.DescribeStackEventsCommand = DescribeStackEventsCommand; +exports.DescribeStackInstanceCommand = DescribeStackInstanceCommand; +exports.DescribeStackRefactorCommand = DescribeStackRefactorCommand; +exports.DescribeStackResourceCommand = DescribeStackResourceCommand; +exports.DescribeStackResourceDriftsCommand = DescribeStackResourceDriftsCommand; +exports.DescribeStackResourcesCommand = DescribeStackResourcesCommand; +exports.DescribeStackSetCommand = DescribeStackSetCommand; +exports.DescribeStackSetOperationCommand = DescribeStackSetOperationCommand; +exports.DescribeStacksCommand = DescribeStacksCommand; +exports.DescribeTypeCommand = DescribeTypeCommand; +exports.DescribeTypeRegistrationCommand = DescribeTypeRegistrationCommand; +exports.DetailedStatus = DetailedStatus; +exports.DetectStackDriftCommand = DetectStackDriftCommand; +exports.DetectStackResourceDriftCommand = DetectStackResourceDriftCommand; +exports.DetectStackSetDriftCommand = DetectStackSetDriftCommand; +exports.DifferenceType = DifferenceType; +exports.DriftIgnoredReason = DriftIgnoredReason; +exports.EstimateTemplateCostCommand = EstimateTemplateCostCommand; +exports.EvaluationType = EvaluationType; +exports.EventType = EventType; +exports.ExecuteChangeSetCommand = ExecuteChangeSetCommand; +exports.ExecuteStackRefactorCommand = ExecuteStackRefactorCommand; +exports.ExecutionStatus = ExecutionStatus; +exports.GeneratedTemplateDeletionPolicy = GeneratedTemplateDeletionPolicy; +exports.GeneratedTemplateNotFoundException = GeneratedTemplateNotFoundException$1; +exports.GeneratedTemplateResourceStatus = GeneratedTemplateResourceStatus; +exports.GeneratedTemplateStatus = GeneratedTemplateStatus; +exports.GeneratedTemplateUpdateReplacePolicy = GeneratedTemplateUpdateReplacePolicy; +exports.GetGeneratedTemplateCommand = GetGeneratedTemplateCommand; +exports.GetHookResultCommand = GetHookResultCommand; +exports.GetStackPolicyCommand = GetStackPolicyCommand; +exports.GetTemplateCommand = GetTemplateCommand; +exports.GetTemplateSummaryCommand = GetTemplateSummaryCommand; +exports.HandlerErrorCode = HandlerErrorCode; +exports.HookFailureMode = HookFailureMode; +exports.HookInvocationPoint = HookInvocationPoint; +exports.HookResultNotFoundException = HookResultNotFoundException$1; +exports.HookStatus = HookStatus; +exports.HookTargetAction = HookTargetAction; +exports.HookTargetType = HookTargetType; +exports.IdentityProvider = IdentityProvider; +exports.ImportStacksToStackSetCommand = ImportStacksToStackSetCommand; +exports.InsufficientCapabilitiesException = InsufficientCapabilitiesException$1; +exports.InvalidChangeSetStatusException = InvalidChangeSetStatusException$1; +exports.InvalidOperationException = InvalidOperationException$1; +exports.InvalidStateTransitionException = InvalidStateTransitionException$1; +exports.LimitExceededException = LimitExceededException$1; +exports.ListChangeSetsCommand = ListChangeSetsCommand; +exports.ListExportsCommand = ListExportsCommand; +exports.ListGeneratedTemplatesCommand = ListGeneratedTemplatesCommand; +exports.ListHookResultsCommand = ListHookResultsCommand; +exports.ListHookResultsTargetType = ListHookResultsTargetType; +exports.ListImportsCommand = ListImportsCommand; +exports.ListResourceScanRelatedResourcesCommand = ListResourceScanRelatedResourcesCommand; +exports.ListResourceScanResourcesCommand = ListResourceScanResourcesCommand; +exports.ListResourceScansCommand = ListResourceScansCommand; +exports.ListStackInstanceResourceDriftsCommand = ListStackInstanceResourceDriftsCommand; +exports.ListStackInstancesCommand = ListStackInstancesCommand; +exports.ListStackRefactorActionsCommand = ListStackRefactorActionsCommand; +exports.ListStackRefactorsCommand = ListStackRefactorsCommand; +exports.ListStackResourcesCommand = ListStackResourcesCommand; +exports.ListStackSetAutoDeploymentTargetsCommand = ListStackSetAutoDeploymentTargetsCommand; +exports.ListStackSetOperationResultsCommand = ListStackSetOperationResultsCommand; +exports.ListStackSetOperationsCommand = ListStackSetOperationsCommand; +exports.ListStackSetsCommand = ListStackSetsCommand; +exports.ListStacksCommand = ListStacksCommand; +exports.ListTypeRegistrationsCommand = ListTypeRegistrationsCommand; +exports.ListTypeVersionsCommand = ListTypeVersionsCommand; +exports.ListTypesCommand = ListTypesCommand; +exports.NameAlreadyExistsException = NameAlreadyExistsException$1; +exports.OnFailure = OnFailure; +exports.OnStackFailure = OnStackFailure; +exports.OperationIdAlreadyExistsException = OperationIdAlreadyExistsException$1; +exports.OperationInProgressException = OperationInProgressException$1; +exports.OperationNotFoundException = OperationNotFoundException$1; +exports.OperationResultFilterName = OperationResultFilterName; +exports.OperationStatus = OperationStatus; +exports.OperationStatusCheckFailedException = OperationStatusCheckFailedException$1; +exports.OperationType = OperationType; +exports.OrganizationStatus = OrganizationStatus; +exports.PermissionModels = PermissionModels; +exports.PolicyAction = PolicyAction; +exports.ProvisioningType = ProvisioningType; +exports.PublishTypeCommand = PublishTypeCommand; +exports.PublisherStatus = PublisherStatus; +exports.RecordHandlerProgressCommand = RecordHandlerProgressCommand; +exports.RegionConcurrencyType = RegionConcurrencyType; +exports.RegisterPublisherCommand = RegisterPublisherCommand; +exports.RegisterTypeCommand = RegisterTypeCommand; +exports.RegistrationStatus = RegistrationStatus; +exports.RegistryType = RegistryType; +exports.Replacement = Replacement; +exports.RequiresRecreation = RequiresRecreation; +exports.ResourceAttribute = ResourceAttribute; +exports.ResourceScanInProgressException = ResourceScanInProgressException$1; +exports.ResourceScanLimitExceededException = ResourceScanLimitExceededException$1; +exports.ResourceScanNotFoundException = ResourceScanNotFoundException$1; +exports.ResourceScanStatus = ResourceScanStatus; +exports.ResourceSignalStatus = ResourceSignalStatus; +exports.ResourceStatus = ResourceStatus; +exports.RollbackStackCommand = RollbackStackCommand; +exports.ScanType = ScanType; +exports.SetStackPolicyCommand = SetStackPolicyCommand; +exports.SetTypeConfigurationCommand = SetTypeConfigurationCommand; +exports.SetTypeDefaultVersionCommand = SetTypeDefaultVersionCommand; +exports.SignalResourceCommand = SignalResourceCommand; +exports.StackDriftDetectionStatus = StackDriftDetectionStatus; +exports.StackDriftStatus = StackDriftStatus; +exports.StackInstanceDetailedStatus = StackInstanceDetailedStatus; +exports.StackInstanceFilterName = StackInstanceFilterName; +exports.StackInstanceNotFoundException = StackInstanceNotFoundException$1; +exports.StackInstanceStatus = StackInstanceStatus; +exports.StackNotFoundException = StackNotFoundException$1; +exports.StackRefactorActionEntity = StackRefactorActionEntity; +exports.StackRefactorActionType = StackRefactorActionType; +exports.StackRefactorDetection = StackRefactorDetection; +exports.StackRefactorExecutionStatus = StackRefactorExecutionStatus; +exports.StackRefactorNotFoundException = StackRefactorNotFoundException$1; +exports.StackRefactorStatus = StackRefactorStatus; +exports.StackResourceDriftStatus = StackResourceDriftStatus; +exports.StackSetDriftDetectionStatus = StackSetDriftDetectionStatus; +exports.StackSetDriftStatus = StackSetDriftStatus; +exports.StackSetNotEmptyException = StackSetNotEmptyException$1; +exports.StackSetNotFoundException = StackSetNotFoundException$1; +exports.StackSetOperationAction = StackSetOperationAction; +exports.StackSetOperationResultStatus = StackSetOperationResultStatus; +exports.StackSetOperationStatus = StackSetOperationStatus; +exports.StackSetStatus = StackSetStatus; +exports.StackStatus = StackStatus; +exports.StaleRequestException = StaleRequestException$1; +exports.StartResourceScanCommand = StartResourceScanCommand; +exports.StopStackSetOperationCommand = StopStackSetOperationCommand; +exports.TemplateFormat = TemplateFormat; +exports.TemplateStage = TemplateStage; +exports.TestTypeCommand = TestTypeCommand; +exports.ThirdPartyType = ThirdPartyType; +exports.TokenAlreadyExistsException = TokenAlreadyExistsException$1; +exports.TypeConfigurationNotFoundException = TypeConfigurationNotFoundException$1; +exports.TypeNotFoundException = TypeNotFoundException$1; +exports.TypeTestsStatus = TypeTestsStatus; +exports.UpdateGeneratedTemplateCommand = UpdateGeneratedTemplateCommand; +exports.UpdateStackCommand = UpdateStackCommand; +exports.UpdateStackInstancesCommand = UpdateStackInstancesCommand; +exports.UpdateStackSetCommand = UpdateStackSetCommand; +exports.UpdateTerminationProtectionCommand = UpdateTerminationProtectionCommand; +exports.ValidateTemplateCommand = ValidateTemplateCommand; +exports.ValidationStatus = ValidationStatus; +exports.VersionBump = VersionBump; +exports.Visibility = Visibility; +exports.WarningType = WarningType; +exports.paginateDescribeAccountLimits = paginateDescribeAccountLimits; +exports.paginateDescribeChangeSet = paginateDescribeChangeSet; +exports.paginateDescribeEvents = paginateDescribeEvents; +exports.paginateDescribeStackEvents = paginateDescribeStackEvents; +exports.paginateDescribeStackResourceDrifts = paginateDescribeStackResourceDrifts; +exports.paginateDescribeStacks = paginateDescribeStacks; +exports.paginateListChangeSets = paginateListChangeSets; +exports.paginateListExports = paginateListExports; +exports.paginateListGeneratedTemplates = paginateListGeneratedTemplates; +exports.paginateListImports = paginateListImports; +exports.paginateListResourceScanRelatedResources = paginateListResourceScanRelatedResources; +exports.paginateListResourceScanResources = paginateListResourceScanResources; +exports.paginateListResourceScans = paginateListResourceScans; +exports.paginateListStackInstances = paginateListStackInstances; +exports.paginateListStackRefactorActions = paginateListStackRefactorActions; +exports.paginateListStackRefactors = paginateListStackRefactors; +exports.paginateListStackResources = paginateListStackResources; +exports.paginateListStackSetOperationResults = paginateListStackSetOperationResults; +exports.paginateListStackSetOperations = paginateListStackSetOperations; +exports.paginateListStackSets = paginateListStackSets; +exports.paginateListStacks = paginateListStacks; +exports.paginateListTypeRegistrations = paginateListTypeRegistrations; +exports.paginateListTypeVersions = paginateListTypeVersions; +exports.paginateListTypes = paginateListTypes; +exports.waitForChangeSetCreateComplete = waitForChangeSetCreateComplete; +exports.waitForStackCreateComplete = waitForStackCreateComplete; +exports.waitForStackDeleteComplete = waitForStackDeleteComplete; +exports.waitForStackExists = waitForStackExists; +exports.waitForStackImportComplete = waitForStackImportComplete; +exports.waitForStackRefactorCreateComplete = waitForStackRefactorCreateComplete; +exports.waitForStackRefactorExecuteComplete = waitForStackRefactorExecuteComplete; +exports.waitForStackRollbackComplete = waitForStackRollbackComplete; +exports.waitForStackUpdateComplete = waitForStackUpdateComplete; +exports.waitForTypeRegistrationComplete = waitForTypeRegistrationComplete; +exports.waitUntilChangeSetCreateComplete = waitUntilChangeSetCreateComplete; +exports.waitUntilStackCreateComplete = waitUntilStackCreateComplete; +exports.waitUntilStackDeleteComplete = waitUntilStackDeleteComplete; +exports.waitUntilStackExists = waitUntilStackExists; +exports.waitUntilStackImportComplete = waitUntilStackImportComplete; +exports.waitUntilStackRefactorCreateComplete = waitUntilStackRefactorCreateComplete; +exports.waitUntilStackRefactorExecuteComplete = waitUntilStackRefactorExecuteComplete; +exports.waitUntilStackRollbackComplete = waitUntilStackRollbackComplete; +exports.waitUntilStackUpdateComplete = waitUntilStackUpdateComplete; +exports.waitUntilTypeRegistrationComplete = waitUntilTypeRegistrationComplete; + + +/***/ }), + +/***/ 7079: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -apiLoader.services['cognitosync'] = {}; -AWS.CognitoSync = Service.defineService('cognitosync', ['2014-06-30']); -Object.defineProperty(apiLoader.services['cognitosync'], '2014-06-30', { - get: function get() { - var model = __webpack_require__(7422); - return model; - }, - enumerable: true, - configurable: true -}); +"use strict"; -module.exports = AWS.CognitoSync; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getRuntimeConfig = void 0; +const tslib_1 = __nccwpck_require__(1860); +const package_json_1 = tslib_1.__importDefault(__nccwpck_require__(9027)); +const core_1 = __nccwpck_require__(8704); +const credential_provider_node_1 = __nccwpck_require__(5861); +const util_user_agent_node_1 = __nccwpck_require__(1656); +const config_resolver_1 = __nccwpck_require__(9316); +const hash_node_1 = __nccwpck_require__(2711); +const middleware_retry_1 = __nccwpck_require__(9618); +const node_config_provider_1 = __nccwpck_require__(5704); +const node_http_handler_1 = __nccwpck_require__(1279); +const util_body_length_node_1 = __nccwpck_require__(3638); +const util_retry_1 = __nccwpck_require__(5518); +const runtimeConfig_shared_1 = __nccwpck_require__(6036); +const smithy_client_1 = __nccwpck_require__(1411); +const util_defaults_mode_node_1 = __nccwpck_require__(5435); +const smithy_client_2 = __nccwpck_require__(1411); +const getRuntimeConfig = (config) => { + (0, smithy_client_2.emitWarningIfUnsupportedVersion)(process.version); + const defaultsMode = (0, util_defaults_mode_node_1.resolveDefaultsModeConfig)(config); + const defaultConfigProvider = () => defaultsMode().then(smithy_client_1.loadConfigsForDefaultMode); + const clientSharedValues = (0, runtimeConfig_shared_1.getRuntimeConfig)(config); + (0, core_1.emitWarningIfUnsupportedVersion)(process.version); + const loaderConfig = { + profile: config?.profile, + logger: clientSharedValues.logger, + }; + return { + ...clientSharedValues, + ...config, + runtime: "node", + defaultsMode, + authSchemePreference: config?.authSchemePreference ?? (0, node_config_provider_1.loadConfig)(core_1.NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig), + bodyLengthChecker: config?.bodyLengthChecker ?? util_body_length_node_1.calculateBodyLength, + credentialDefaultProvider: config?.credentialDefaultProvider ?? credential_provider_node_1.defaultProvider, + defaultUserAgentProvider: config?.defaultUserAgentProvider ?? + (0, util_user_agent_node_1.createDefaultUserAgentProvider)({ serviceId: clientSharedValues.serviceId, clientVersion: package_json_1.default.version }), + maxAttempts: config?.maxAttempts ?? (0, node_config_provider_1.loadConfig)(middleware_retry_1.NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config), + region: config?.region ?? + (0, node_config_provider_1.loadConfig)(config_resolver_1.NODE_REGION_CONFIG_OPTIONS, { ...config_resolver_1.NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }), + requestHandler: node_http_handler_1.NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider), + retryMode: config?.retryMode ?? + (0, node_config_provider_1.loadConfig)({ + ...middleware_retry_1.NODE_RETRY_MODE_CONFIG_OPTIONS, + default: async () => (await defaultConfigProvider()).retryMode || util_retry_1.DEFAULT_RETRY_MODE, + }, config), + sha256: config?.sha256 ?? hash_node_1.Hash.bind(null, "sha256"), + streamCollector: config?.streamCollector ?? node_http_handler_1.streamCollector, + useDualstackEndpoint: config?.useDualstackEndpoint ?? (0, node_config_provider_1.loadConfig)(config_resolver_1.NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig), + useFipsEndpoint: config?.useFipsEndpoint ?? (0, node_config_provider_1.loadConfig)(config_resolver_1.NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig), + userAgentAppId: config?.userAgentAppId ?? (0, node_config_provider_1.loadConfig)(util_user_agent_node_1.NODE_APP_ID_CONFIG_OPTIONS, loaderConfig), + }; +}; +exports.getRuntimeConfig = getRuntimeConfig; /***/ }), -/***/ 1187: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +/***/ 6036: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -apiLoader.services['pinpointsmsvoice'] = {}; -AWS.PinpointSMSVoice = Service.defineService('pinpointsmsvoice', ['2018-09-05']); -Object.defineProperty(apiLoader.services['pinpointsmsvoice'], '2018-09-05', { - get: function get() { - var model = __webpack_require__(2241); - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.PinpointSMSVoice; - - -/***/ }), +"use strict"; -/***/ 1191: -/***/ (function(module) { +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getRuntimeConfig = void 0; +const core_1 = __nccwpck_require__(8704); +const protocols_1 = __nccwpck_require__(7288); +const smithy_client_1 = __nccwpck_require__(1411); +const url_parser_1 = __nccwpck_require__(4494); +const util_base64_1 = __nccwpck_require__(8385); +const util_utf8_1 = __nccwpck_require__(1577); +const httpAuthSchemeProvider_1 = __nccwpck_require__(398); +const endpointResolver_1 = __nccwpck_require__(2840); +const getRuntimeConfig = (config) => { + return { + apiVersion: "2010-05-15", + base64Decoder: config?.base64Decoder ?? util_base64_1.fromBase64, + base64Encoder: config?.base64Encoder ?? util_base64_1.toBase64, + disableHostPrefix: config?.disableHostPrefix ?? false, + endpointProvider: config?.endpointProvider ?? endpointResolver_1.defaultEndpointResolver, + extensions: config?.extensions ?? [], + httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? httpAuthSchemeProvider_1.defaultCloudFormationHttpAuthSchemeProvider, + httpAuthSchemes: config?.httpAuthSchemes ?? [ + { + schemeId: "aws.auth#sigv4", + identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"), + signer: new core_1.AwsSdkSigV4Signer(), + }, + ], + logger: config?.logger ?? new smithy_client_1.NoOpLogger(), + protocol: config?.protocol ?? + new protocols_1.AwsQueryProtocol({ + defaultNamespace: "com.amazonaws.cloudformation", + xmlNamespace: "http://cloudformation.amazonaws.com/doc/2010-05-15/", + version: "2010-05-15", + }), + serviceId: config?.serviceId ?? "CloudFormation", + urlParser: config?.urlParser ?? url_parser_1.parseUrl, + utf8Decoder: config?.utf8Decoder ?? util_utf8_1.fromUtf8, + utf8Encoder: config?.utf8Encoder ?? util_utf8_1.toUtf8, + }; +}; +exports.getRuntimeConfig = getRuntimeConfig; -module.exports = require("querystring"); /***/ }), -/***/ 1200: -/***/ (function(module) { +/***/ 8704: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -module.exports = {"version":"2.0","metadata":{"apiVersion":"2015-05-28","endpointPrefix":"data.iot","protocol":"rest-json","serviceFullName":"AWS IoT Data Plane","serviceId":"IoT Data Plane","signatureVersion":"v4","signingName":"iotdata","uid":"iot-data-2015-05-28"},"operations":{"DeleteThingShadow":{"http":{"method":"DELETE","requestUri":"/things/{thingName}/shadow"},"input":{"type":"structure","required":["thingName"],"members":{"thingName":{"location":"uri","locationName":"thingName"},"shadowName":{"location":"querystring","locationName":"name"}}},"output":{"type":"structure","required":["payload"],"members":{"payload":{"type":"blob"}},"payload":"payload"}},"GetThingShadow":{"http":{"method":"GET","requestUri":"/things/{thingName}/shadow"},"input":{"type":"structure","required":["thingName"],"members":{"thingName":{"location":"uri","locationName":"thingName"},"shadowName":{"location":"querystring","locationName":"name"}}},"output":{"type":"structure","members":{"payload":{"type":"blob"}},"payload":"payload"}},"ListNamedShadowsForThing":{"http":{"method":"GET","requestUri":"/api/things/shadow/ListNamedShadowsForThing/{thingName}"},"input":{"type":"structure","required":["thingName"],"members":{"thingName":{"location":"uri","locationName":"thingName"},"nextToken":{"location":"querystring","locationName":"nextToken"},"pageSize":{"location":"querystring","locationName":"pageSize","type":"integer"}}},"output":{"type":"structure","members":{"results":{"type":"list","member":{}},"nextToken":{},"timestamp":{"type":"long"}}}},"Publish":{"http":{"requestUri":"/topics/{topic}"},"input":{"type":"structure","required":["topic"],"members":{"topic":{"location":"uri","locationName":"topic"},"qos":{"location":"querystring","locationName":"qos","type":"integer"},"payload":{"type":"blob"}},"payload":"payload"}},"UpdateThingShadow":{"http":{"requestUri":"/things/{thingName}/shadow"},"input":{"type":"structure","required":["thingName","payload"],"members":{"thingName":{"location":"uri","locationName":"thingName"},"shadowName":{"location":"querystring","locationName":"name"},"payload":{"type":"blob"}},"payload":"payload"},"output":{"type":"structure","members":{"payload":{"type":"blob"}},"payload":"payload"}}},"shapes":{}}; - -/***/ }), - -/***/ 1201: -/***/ (function(module) { +"use strict"; -module.exports = {"version":"2.0","metadata":{"apiVersion":"2016-11-28","endpointPrefix":"lightsail","jsonVersion":"1.1","protocol":"json","serviceFullName":"Amazon Lightsail","serviceId":"Lightsail","signatureVersion":"v4","targetPrefix":"Lightsail_20161128","uid":"lightsail-2016-11-28"},"operations":{"AllocateStaticIp":{"input":{"type":"structure","required":["staticIpName"],"members":{"staticIpName":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"AttachCertificateToDistribution":{"input":{"type":"structure","required":["distributionName","certificateName"],"members":{"distributionName":{},"certificateName":{}}},"output":{"type":"structure","members":{"operation":{"shape":"S5"}}}},"AttachDisk":{"input":{"type":"structure","required":["diskName","instanceName","diskPath"],"members":{"diskName":{},"instanceName":{},"diskPath":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"AttachInstancesToLoadBalancer":{"input":{"type":"structure","required":["loadBalancerName","instanceNames"],"members":{"loadBalancerName":{},"instanceNames":{"shape":"Sk"}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"AttachLoadBalancerTlsCertificate":{"input":{"type":"structure","required":["loadBalancerName","certificateName"],"members":{"loadBalancerName":{},"certificateName":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"AttachStaticIp":{"input":{"type":"structure","required":["staticIpName","instanceName"],"members":{"staticIpName":{},"instanceName":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"CloseInstancePublicPorts":{"input":{"type":"structure","required":["portInfo","instanceName"],"members":{"portInfo":{"shape":"Sr"},"instanceName":{}}},"output":{"type":"structure","members":{"operation":{"shape":"S5"}}}},"CopySnapshot":{"input":{"type":"structure","required":["targetSnapshotName","sourceRegion"],"members":{"sourceSnapshotName":{},"sourceResourceName":{},"restoreDate":{},"useLatestRestorableAutoSnapshot":{"type":"boolean"},"targetSnapshotName":{},"sourceRegion":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"CreateCertificate":{"input":{"type":"structure","required":["certificateName","domainName"],"members":{"certificateName":{},"domainName":{},"subjectAlternativeNames":{"shape":"S11"},"tags":{"shape":"S12"}}},"output":{"type":"structure","members":{"certificate":{"shape":"S17"},"operations":{"shape":"S4"}}}},"CreateCloudFormationStack":{"input":{"type":"structure","required":["instances"],"members":{"instances":{"type":"list","member":{"type":"structure","required":["sourceName","instanceType","portInfoSource","availabilityZone"],"members":{"sourceName":{},"instanceType":{},"portInfoSource":{},"userData":{},"availabilityZone":{}}}}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"CreateContactMethod":{"input":{"type":"structure","required":["protocol","contactEndpoint"],"members":{"protocol":{},"contactEndpoint":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"CreateDisk":{"input":{"type":"structure","required":["diskName","availabilityZone","sizeInGb"],"members":{"diskName":{},"availabilityZone":{},"sizeInGb":{"type":"integer"},"tags":{"shape":"S12"},"addOns":{"shape":"S1y"}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"CreateDiskFromSnapshot":{"input":{"type":"structure","required":["diskName","availabilityZone","sizeInGb"],"members":{"diskName":{},"diskSnapshotName":{},"availabilityZone":{},"sizeInGb":{"type":"integer"},"tags":{"shape":"S12"},"addOns":{"shape":"S1y"},"sourceDiskName":{},"restoreDate":{},"useLatestRestorableAutoSnapshot":{"type":"boolean"}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"CreateDiskSnapshot":{"input":{"type":"structure","required":["diskSnapshotName"],"members":{"diskName":{},"diskSnapshotName":{},"instanceName":{},"tags":{"shape":"S12"}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"CreateDistribution":{"input":{"type":"structure","required":["distributionName","origin","defaultCacheBehavior","bundleId"],"members":{"distributionName":{},"origin":{"shape":"S29"},"defaultCacheBehavior":{"shape":"S2b"},"cacheBehaviorSettings":{"shape":"S2d"},"cacheBehaviors":{"shape":"S2l"},"bundleId":{},"tags":{"shape":"S12"}}},"output":{"type":"structure","members":{"distribution":{"shape":"S2o"},"operation":{"shape":"S5"}}}},"CreateDomain":{"input":{"type":"structure","required":["domainName"],"members":{"domainName":{},"tags":{"shape":"S12"}}},"output":{"type":"structure","members":{"operation":{"shape":"S5"}}}},"CreateDomainEntry":{"input":{"type":"structure","required":["domainName","domainEntry"],"members":{"domainName":{},"domainEntry":{"shape":"S2t"}}},"output":{"type":"structure","members":{"operation":{"shape":"S5"}}}},"CreateInstanceSnapshot":{"input":{"type":"structure","required":["instanceSnapshotName","instanceName"],"members":{"instanceSnapshotName":{},"instanceName":{},"tags":{"shape":"S12"}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"CreateInstances":{"input":{"type":"structure","required":["instanceNames","availabilityZone","blueprintId","bundleId"],"members":{"instanceNames":{"shape":"Su"},"availabilityZone":{},"customImageName":{"deprecated":true},"blueprintId":{},"bundleId":{},"userData":{},"keyPairName":{},"tags":{"shape":"S12"},"addOns":{"shape":"S1y"}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"CreateInstancesFromSnapshot":{"input":{"type":"structure","required":["instanceNames","availabilityZone","bundleId"],"members":{"instanceNames":{"shape":"Su"},"attachedDiskMapping":{"type":"map","key":{},"value":{"type":"list","member":{"type":"structure","members":{"originalDiskPath":{},"newDiskName":{}}}}},"availabilityZone":{},"instanceSnapshotName":{},"bundleId":{},"userData":{},"keyPairName":{},"tags":{"shape":"S12"},"addOns":{"shape":"S1y"},"sourceInstanceName":{},"restoreDate":{},"useLatestRestorableAutoSnapshot":{"type":"boolean"}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"CreateKeyPair":{"input":{"type":"structure","required":["keyPairName"],"members":{"keyPairName":{},"tags":{"shape":"S12"}}},"output":{"type":"structure","members":{"keyPair":{"shape":"S39"},"publicKeyBase64":{},"privateKeyBase64":{},"operation":{"shape":"S5"}}}},"CreateLoadBalancer":{"input":{"type":"structure","required":["loadBalancerName","instancePort"],"members":{"loadBalancerName":{},"instancePort":{"type":"integer"},"healthCheckPath":{},"certificateName":{},"certificateDomainName":{},"certificateAlternativeNames":{"shape":"S3c"},"tags":{"shape":"S12"}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"CreateLoadBalancerTlsCertificate":{"input":{"type":"structure","required":["loadBalancerName","certificateName","certificateDomainName"],"members":{"loadBalancerName":{},"certificateName":{},"certificateDomainName":{},"certificateAlternativeNames":{"shape":"S3c"},"tags":{"shape":"S12"}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"CreateRelationalDatabase":{"input":{"type":"structure","required":["relationalDatabaseName","relationalDatabaseBlueprintId","relationalDatabaseBundleId","masterDatabaseName","masterUsername"],"members":{"relationalDatabaseName":{},"availabilityZone":{},"relationalDatabaseBlueprintId":{},"relationalDatabaseBundleId":{},"masterDatabaseName":{},"masterUsername":{},"masterUserPassword":{"shape":"S3h"},"preferredBackupWindow":{},"preferredMaintenanceWindow":{},"publiclyAccessible":{"type":"boolean"},"tags":{"shape":"S12"}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"CreateRelationalDatabaseFromSnapshot":{"input":{"type":"structure","required":["relationalDatabaseName"],"members":{"relationalDatabaseName":{},"availabilityZone":{},"publiclyAccessible":{"type":"boolean"},"relationalDatabaseSnapshotName":{},"relationalDatabaseBundleId":{},"sourceRelationalDatabaseName":{},"restoreTime":{"type":"timestamp"},"useLatestRestorableTime":{"type":"boolean"},"tags":{"shape":"S12"}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"CreateRelationalDatabaseSnapshot":{"input":{"type":"structure","required":["relationalDatabaseName","relationalDatabaseSnapshotName"],"members":{"relationalDatabaseName":{},"relationalDatabaseSnapshotName":{},"tags":{"shape":"S12"}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"DeleteAlarm":{"input":{"type":"structure","required":["alarmName"],"members":{"alarmName":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"DeleteAutoSnapshot":{"input":{"type":"structure","required":["resourceName","date"],"members":{"resourceName":{},"date":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"DeleteCertificate":{"input":{"type":"structure","required":["certificateName"],"members":{"certificateName":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"DeleteContactMethod":{"input":{"type":"structure","required":["protocol"],"members":{"protocol":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"DeleteDisk":{"input":{"type":"structure","required":["diskName"],"members":{"diskName":{},"forceDeleteAddOns":{"type":"boolean"}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"DeleteDiskSnapshot":{"input":{"type":"structure","required":["diskSnapshotName"],"members":{"diskSnapshotName":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"DeleteDistribution":{"input":{"type":"structure","members":{"distributionName":{}}},"output":{"type":"structure","members":{"operation":{"shape":"S5"}}}},"DeleteDomain":{"input":{"type":"structure","required":["domainName"],"members":{"domainName":{}}},"output":{"type":"structure","members":{"operation":{"shape":"S5"}}}},"DeleteDomainEntry":{"input":{"type":"structure","required":["domainName","domainEntry"],"members":{"domainName":{},"domainEntry":{"shape":"S2t"}}},"output":{"type":"structure","members":{"operation":{"shape":"S5"}}}},"DeleteInstance":{"input":{"type":"structure","required":["instanceName"],"members":{"instanceName":{},"forceDeleteAddOns":{"type":"boolean"}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"DeleteInstanceSnapshot":{"input":{"type":"structure","required":["instanceSnapshotName"],"members":{"instanceSnapshotName":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"DeleteKeyPair":{"input":{"type":"structure","required":["keyPairName"],"members":{"keyPairName":{}}},"output":{"type":"structure","members":{"operation":{"shape":"S5"}}}},"DeleteKnownHostKeys":{"input":{"type":"structure","required":["instanceName"],"members":{"instanceName":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"DeleteLoadBalancer":{"input":{"type":"structure","required":["loadBalancerName"],"members":{"loadBalancerName":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"DeleteLoadBalancerTlsCertificate":{"input":{"type":"structure","required":["loadBalancerName","certificateName"],"members":{"loadBalancerName":{},"certificateName":{},"force":{"type":"boolean"}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"DeleteRelationalDatabase":{"input":{"type":"structure","required":["relationalDatabaseName"],"members":{"relationalDatabaseName":{},"skipFinalSnapshot":{"type":"boolean"},"finalRelationalDatabaseSnapshotName":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"DeleteRelationalDatabaseSnapshot":{"input":{"type":"structure","required":["relationalDatabaseSnapshotName"],"members":{"relationalDatabaseSnapshotName":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"DetachCertificateFromDistribution":{"input":{"type":"structure","required":["distributionName"],"members":{"distributionName":{}}},"output":{"type":"structure","members":{"operation":{"shape":"S5"}}}},"DetachDisk":{"input":{"type":"structure","required":["diskName"],"members":{"diskName":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"DetachInstancesFromLoadBalancer":{"input":{"type":"structure","required":["loadBalancerName","instanceNames"],"members":{"loadBalancerName":{},"instanceNames":{"shape":"Sk"}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"DetachStaticIp":{"input":{"type":"structure","required":["staticIpName"],"members":{"staticIpName":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"DisableAddOn":{"input":{"type":"structure","required":["addOnType","resourceName"],"members":{"addOnType":{},"resourceName":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"DownloadDefaultKeyPair":{"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"publicKeyBase64":{},"privateKeyBase64":{}}}},"EnableAddOn":{"input":{"type":"structure","required":["resourceName","addOnRequest"],"members":{"resourceName":{},"addOnRequest":{"shape":"S1z"}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"ExportSnapshot":{"input":{"type":"structure","required":["sourceSnapshotName"],"members":{"sourceSnapshotName":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"GetActiveNames":{"input":{"type":"structure","members":{"pageToken":{}}},"output":{"type":"structure","members":{"activeNames":{"shape":"Su"},"nextPageToken":{}}}},"GetAlarms":{"input":{"type":"structure","members":{"alarmName":{},"pageToken":{},"monitoredResourceName":{}}},"output":{"type":"structure","members":{"alarms":{"type":"list","member":{"type":"structure","members":{"name":{},"arn":{},"createdAt":{"type":"timestamp"},"location":{"shape":"S9"},"resourceType":{},"supportCode":{},"monitoredResourceInfo":{"type":"structure","members":{"arn":{},"name":{},"resourceType":{}}},"comparisonOperator":{},"evaluationPeriods":{"type":"integer"},"period":{"type":"integer"},"threshold":{"type":"double"},"datapointsToAlarm":{"type":"integer"},"treatMissingData":{},"statistic":{},"metricName":{},"state":{},"unit":{},"contactProtocols":{"shape":"S5i"},"notificationTriggers":{"shape":"S5j"},"notificationEnabled":{"type":"boolean"}}}},"nextPageToken":{}}}},"GetAutoSnapshots":{"input":{"type":"structure","required":["resourceName"],"members":{"resourceName":{}}},"output":{"type":"structure","members":{"resourceName":{},"resourceType":{},"autoSnapshots":{"type":"list","member":{"type":"structure","members":{"date":{},"createdAt":{"type":"timestamp"},"status":{},"fromAttachedDisks":{"type":"list","member":{"type":"structure","members":{"path":{},"sizeInGb":{"type":"integer"}}}}}}}}}},"GetBlueprints":{"input":{"type":"structure","members":{"includeInactive":{"type":"boolean"},"pageToken":{}}},"output":{"type":"structure","members":{"blueprints":{"type":"list","member":{"type":"structure","members":{"blueprintId":{},"name":{},"group":{},"type":{},"description":{},"isActive":{"type":"boolean"},"minPower":{"type":"integer"},"version":{},"versionCode":{},"productUrl":{},"licenseUrl":{},"platform":{}}}},"nextPageToken":{}}}},"GetBundles":{"input":{"type":"structure","members":{"includeInactive":{"type":"boolean"},"pageToken":{}}},"output":{"type":"structure","members":{"bundles":{"type":"list","member":{"type":"structure","members":{"price":{"type":"float"},"cpuCount":{"type":"integer"},"diskSizeInGb":{"type":"integer"},"bundleId":{},"instanceType":{},"isActive":{"type":"boolean"},"name":{},"power":{"type":"integer"},"ramSizeInGb":{"type":"float"},"transferPerMonthInGb":{"type":"integer"},"supportedPlatforms":{"type":"list","member":{}}}}},"nextPageToken":{}}}},"GetCertificates":{"input":{"type":"structure","members":{"certificateStatuses":{"type":"list","member":{}},"includeCertificateDetails":{"type":"boolean"},"certificateName":{}}},"output":{"type":"structure","members":{"certificates":{"type":"list","member":{"shape":"S17"}}}}},"GetCloudFormationStackRecords":{"input":{"type":"structure","members":{"pageToken":{}}},"output":{"type":"structure","members":{"cloudFormationStackRecords":{"type":"list","member":{"type":"structure","members":{"name":{},"arn":{},"createdAt":{"type":"timestamp"},"location":{"shape":"S9"},"resourceType":{},"state":{},"sourceInfo":{"type":"list","member":{"type":"structure","members":{"resourceType":{},"name":{},"arn":{}}}},"destinationInfo":{"shape":"S6g"}}}},"nextPageToken":{}}}},"GetContactMethods":{"input":{"type":"structure","members":{"protocols":{"shape":"S5i"}}},"output":{"type":"structure","members":{"contactMethods":{"type":"list","member":{"type":"structure","members":{"contactEndpoint":{},"status":{},"protocol":{},"name":{},"arn":{},"createdAt":{"type":"timestamp"},"location":{"shape":"S9"},"resourceType":{},"supportCode":{}}}}}}},"GetDisk":{"input":{"type":"structure","required":["diskName"],"members":{"diskName":{}}},"output":{"type":"structure","members":{"disk":{"shape":"S6o"}}}},"GetDiskSnapshot":{"input":{"type":"structure","required":["diskSnapshotName"],"members":{"diskSnapshotName":{}}},"output":{"type":"structure","members":{"diskSnapshot":{"shape":"S6u"}}}},"GetDiskSnapshots":{"input":{"type":"structure","members":{"pageToken":{}}},"output":{"type":"structure","members":{"diskSnapshots":{"type":"list","member":{"shape":"S6u"}},"nextPageToken":{}}}},"GetDisks":{"input":{"type":"structure","members":{"pageToken":{}}},"output":{"type":"structure","members":{"disks":{"shape":"S71"},"nextPageToken":{}}}},"GetDistributionBundles":{"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"bundles":{"type":"list","member":{"type":"structure","members":{"bundleId":{},"name":{},"price":{"type":"float"},"transferPerMonthInGb":{"type":"integer"},"isActive":{"type":"boolean"}}}}}}},"GetDistributionLatestCacheReset":{"input":{"type":"structure","members":{"distributionName":{}}},"output":{"type":"structure","members":{"status":{},"createTime":{"type":"timestamp"}}}},"GetDistributionMetricData":{"input":{"type":"structure","required":["distributionName","metricName","startTime","endTime","period","unit","statistics"],"members":{"distributionName":{},"metricName":{},"startTime":{"type":"timestamp"},"endTime":{"type":"timestamp"},"period":{"type":"integer"},"unit":{},"statistics":{"shape":"S7b"}}},"output":{"type":"structure","members":{"metricName":{},"metricData":{"shape":"S7d"}}}},"GetDistributions":{"input":{"type":"structure","members":{"distributionName":{},"pageToken":{}}},"output":{"type":"structure","members":{"distributions":{"type":"list","member":{"shape":"S2o"}},"nextPageToken":{}}}},"GetDomain":{"input":{"type":"structure","required":["domainName"],"members":{"domainName":{}}},"output":{"type":"structure","members":{"domain":{"shape":"S7k"}}}},"GetDomains":{"input":{"type":"structure","members":{"pageToken":{}}},"output":{"type":"structure","members":{"domains":{"type":"list","member":{"shape":"S7k"}},"nextPageToken":{}}}},"GetExportSnapshotRecords":{"input":{"type":"structure","members":{"pageToken":{}}},"output":{"type":"structure","members":{"exportSnapshotRecords":{"type":"list","member":{"type":"structure","members":{"name":{},"arn":{},"createdAt":{"type":"timestamp"},"location":{"shape":"S9"},"resourceType":{},"state":{},"sourceInfo":{"type":"structure","members":{"resourceType":{},"createdAt":{"type":"timestamp"},"name":{},"arn":{},"fromResourceName":{},"fromResourceArn":{},"instanceSnapshotInfo":{"type":"structure","members":{"fromBundleId":{},"fromBlueprintId":{},"fromDiskInfo":{"type":"list","member":{"type":"structure","members":{"name":{},"path":{},"sizeInGb":{"type":"integer"},"isSystemDisk":{"type":"boolean"}}}}}},"diskSnapshotInfo":{"type":"structure","members":{"sizeInGb":{"type":"integer"}}}}},"destinationInfo":{"shape":"S6g"}}}},"nextPageToken":{}}}},"GetInstance":{"input":{"type":"structure","required":["instanceName"],"members":{"instanceName":{}}},"output":{"type":"structure","members":{"instance":{"shape":"S81"}}}},"GetInstanceAccessDetails":{"input":{"type":"structure","required":["instanceName"],"members":{"instanceName":{},"protocol":{}}},"output":{"type":"structure","members":{"accessDetails":{"type":"structure","members":{"certKey":{},"expiresAt":{"type":"timestamp"},"ipAddress":{},"password":{},"passwordData":{"type":"structure","members":{"ciphertext":{},"keyPairName":{}}},"privateKey":{},"protocol":{},"instanceName":{},"username":{},"hostKeys":{"type":"list","member":{"type":"structure","members":{"algorithm":{},"publicKey":{},"witnessedAt":{"type":"timestamp"},"fingerprintSHA1":{},"fingerprintSHA256":{},"notValidBefore":{"type":"timestamp"},"notValidAfter":{"type":"timestamp"}}}}}}}}},"GetInstanceMetricData":{"input":{"type":"structure","required":["instanceName","metricName","period","startTime","endTime","unit","statistics"],"members":{"instanceName":{},"metricName":{},"period":{"type":"integer"},"startTime":{"type":"timestamp"},"endTime":{"type":"timestamp"},"unit":{},"statistics":{"shape":"S7b"}}},"output":{"type":"structure","members":{"metricName":{},"metricData":{"shape":"S7d"}}}},"GetInstancePortStates":{"input":{"type":"structure","required":["instanceName"],"members":{"instanceName":{}}},"output":{"type":"structure","members":{"portStates":{"type":"list","member":{"type":"structure","members":{"fromPort":{"type":"integer"},"toPort":{"type":"integer"},"protocol":{},"state":{},"cidrs":{"shape":"Su"},"cidrListAliases":{"shape":"Su"}}}}}}},"GetInstanceSnapshot":{"input":{"type":"structure","required":["instanceSnapshotName"],"members":{"instanceSnapshotName":{}}},"output":{"type":"structure","members":{"instanceSnapshot":{"shape":"S8t"}}}},"GetInstanceSnapshots":{"input":{"type":"structure","members":{"pageToken":{}}},"output":{"type":"structure","members":{"instanceSnapshots":{"type":"list","member":{"shape":"S8t"}},"nextPageToken":{}}}},"GetInstanceState":{"input":{"type":"structure","required":["instanceName"],"members":{"instanceName":{}}},"output":{"type":"structure","members":{"state":{"shape":"S8b"}}}},"GetInstances":{"input":{"type":"structure","members":{"pageToken":{}}},"output":{"type":"structure","members":{"instances":{"type":"list","member":{"shape":"S81"}},"nextPageToken":{}}}},"GetKeyPair":{"input":{"type":"structure","required":["keyPairName"],"members":{"keyPairName":{}}},"output":{"type":"structure","members":{"keyPair":{"shape":"S39"}}}},"GetKeyPairs":{"input":{"type":"structure","members":{"pageToken":{}}},"output":{"type":"structure","members":{"keyPairs":{"type":"list","member":{"shape":"S39"}},"nextPageToken":{}}}},"GetLoadBalancer":{"input":{"type":"structure","required":["loadBalancerName"],"members":{"loadBalancerName":{}}},"output":{"type":"structure","members":{"loadBalancer":{"shape":"S9a"}}}},"GetLoadBalancerMetricData":{"input":{"type":"structure","required":["loadBalancerName","metricName","period","startTime","endTime","unit","statistics"],"members":{"loadBalancerName":{},"metricName":{},"period":{"type":"integer"},"startTime":{"type":"timestamp"},"endTime":{"type":"timestamp"},"unit":{},"statistics":{"shape":"S7b"}}},"output":{"type":"structure","members":{"metricName":{},"metricData":{"shape":"S7d"}}}},"GetLoadBalancerTlsCertificates":{"input":{"type":"structure","required":["loadBalancerName"],"members":{"loadBalancerName":{}}},"output":{"type":"structure","members":{"tlsCertificates":{"type":"list","member":{"type":"structure","members":{"name":{},"arn":{},"supportCode":{},"createdAt":{"type":"timestamp"},"location":{"shape":"S9"},"resourceType":{},"tags":{"shape":"S12"},"loadBalancerName":{},"isAttached":{"type":"boolean"},"status":{},"domainName":{},"domainValidationRecords":{"type":"list","member":{"type":"structure","members":{"name":{},"type":{},"value":{},"validationStatus":{},"domainName":{}}}},"failureReason":{},"issuedAt":{"type":"timestamp"},"issuer":{},"keyAlgorithm":{},"notAfter":{"type":"timestamp"},"notBefore":{"type":"timestamp"},"renewalSummary":{"type":"structure","members":{"renewalStatus":{},"domainValidationOptions":{"type":"list","member":{"type":"structure","members":{"domainName":{},"validationStatus":{}}}}}},"revocationReason":{},"revokedAt":{"type":"timestamp"},"serial":{},"signatureAlgorithm":{},"subject":{},"subjectAlternativeNames":{"shape":"Su"}}}}}}},"GetLoadBalancers":{"input":{"type":"structure","members":{"pageToken":{}}},"output":{"type":"structure","members":{"loadBalancers":{"type":"list","member":{"shape":"S9a"}},"nextPageToken":{}}}},"GetOperation":{"input":{"type":"structure","required":["operationId"],"members":{"operationId":{}}},"output":{"type":"structure","members":{"operation":{"shape":"S5"}}}},"GetOperations":{"input":{"type":"structure","members":{"pageToken":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"},"nextPageToken":{}}}},"GetOperationsForResource":{"input":{"type":"structure","required":["resourceName"],"members":{"resourceName":{},"pageToken":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"},"nextPageCount":{"deprecated":true},"nextPageToken":{}}}},"GetRegions":{"input":{"type":"structure","members":{"includeAvailabilityZones":{"type":"boolean"},"includeRelationalDatabaseAvailabilityZones":{"type":"boolean"}}},"output":{"type":"structure","members":{"regions":{"type":"list","member":{"type":"structure","members":{"continentCode":{},"description":{},"displayName":{},"name":{},"availabilityZones":{"shape":"Sag"},"relationalDatabaseAvailabilityZones":{"shape":"Sag"}}}}}}},"GetRelationalDatabase":{"input":{"type":"structure","required":["relationalDatabaseName"],"members":{"relationalDatabaseName":{}}},"output":{"type":"structure","members":{"relationalDatabase":{"shape":"Sak"}}}},"GetRelationalDatabaseBlueprints":{"input":{"type":"structure","members":{"pageToken":{}}},"output":{"type":"structure","members":{"blueprints":{"type":"list","member":{"type":"structure","members":{"blueprintId":{},"engine":{},"engineVersion":{},"engineDescription":{},"engineVersionDescription":{},"isEngineDefault":{"type":"boolean"}}}},"nextPageToken":{}}}},"GetRelationalDatabaseBundles":{"input":{"type":"structure","members":{"pageToken":{}}},"output":{"type":"structure","members":{"bundles":{"type":"list","member":{"type":"structure","members":{"bundleId":{},"name":{},"price":{"type":"float"},"ramSizeInGb":{"type":"float"},"diskSizeInGb":{"type":"integer"},"transferPerMonthInGb":{"type":"integer"},"cpuCount":{"type":"integer"},"isEncrypted":{"type":"boolean"},"isActive":{"type":"boolean"}}}},"nextPageToken":{}}}},"GetRelationalDatabaseEvents":{"input":{"type":"structure","required":["relationalDatabaseName"],"members":{"relationalDatabaseName":{},"durationInMinutes":{"type":"integer"},"pageToken":{}}},"output":{"type":"structure","members":{"relationalDatabaseEvents":{"type":"list","member":{"type":"structure","members":{"resource":{},"createdAt":{"type":"timestamp"},"message":{},"eventCategories":{"shape":"Su"}}}},"nextPageToken":{}}}},"GetRelationalDatabaseLogEvents":{"input":{"type":"structure","required":["relationalDatabaseName","logStreamName"],"members":{"relationalDatabaseName":{},"logStreamName":{},"startTime":{"type":"timestamp"},"endTime":{"type":"timestamp"},"startFromHead":{"type":"boolean"},"pageToken":{}}},"output":{"type":"structure","members":{"resourceLogEvents":{"type":"list","member":{"type":"structure","members":{"createdAt":{"type":"timestamp"},"message":{}}}},"nextBackwardToken":{},"nextForwardToken":{}}}},"GetRelationalDatabaseLogStreams":{"input":{"type":"structure","required":["relationalDatabaseName"],"members":{"relationalDatabaseName":{}}},"output":{"type":"structure","members":{"logStreams":{"shape":"Su"}}}},"GetRelationalDatabaseMasterUserPassword":{"input":{"type":"structure","required":["relationalDatabaseName"],"members":{"relationalDatabaseName":{},"passwordVersion":{}}},"output":{"type":"structure","members":{"masterUserPassword":{"shape":"S3h"},"createdAt":{"type":"timestamp"}}}},"GetRelationalDatabaseMetricData":{"input":{"type":"structure","required":["relationalDatabaseName","metricName","period","startTime","endTime","unit","statistics"],"members":{"relationalDatabaseName":{},"metricName":{},"period":{"type":"integer"},"startTime":{"type":"timestamp"},"endTime":{"type":"timestamp"},"unit":{},"statistics":{"shape":"S7b"}}},"output":{"type":"structure","members":{"metricName":{},"metricData":{"shape":"S7d"}}}},"GetRelationalDatabaseParameters":{"input":{"type":"structure","required":["relationalDatabaseName"],"members":{"relationalDatabaseName":{},"pageToken":{}}},"output":{"type":"structure","members":{"parameters":{"shape":"Sbh"},"nextPageToken":{}}}},"GetRelationalDatabaseSnapshot":{"input":{"type":"structure","required":["relationalDatabaseSnapshotName"],"members":{"relationalDatabaseSnapshotName":{}}},"output":{"type":"structure","members":{"relationalDatabaseSnapshot":{"shape":"Sbl"}}}},"GetRelationalDatabaseSnapshots":{"input":{"type":"structure","members":{"pageToken":{}}},"output":{"type":"structure","members":{"relationalDatabaseSnapshots":{"type":"list","member":{"shape":"Sbl"}},"nextPageToken":{}}}},"GetRelationalDatabases":{"input":{"type":"structure","members":{"pageToken":{}}},"output":{"type":"structure","members":{"relationalDatabases":{"type":"list","member":{"shape":"Sak"}},"nextPageToken":{}}}},"GetStaticIp":{"input":{"type":"structure","required":["staticIpName"],"members":{"staticIpName":{}}},"output":{"type":"structure","members":{"staticIp":{"shape":"Sbu"}}}},"GetStaticIps":{"input":{"type":"structure","members":{"pageToken":{}}},"output":{"type":"structure","members":{"staticIps":{"type":"list","member":{"shape":"Sbu"}},"nextPageToken":{}}}},"ImportKeyPair":{"input":{"type":"structure","required":["keyPairName","publicKeyBase64"],"members":{"keyPairName":{},"publicKeyBase64":{}}},"output":{"type":"structure","members":{"operation":{"shape":"S5"}}}},"IsVpcPeered":{"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"isPeered":{"type":"boolean"}}}},"OpenInstancePublicPorts":{"input":{"type":"structure","required":["portInfo","instanceName"],"members":{"portInfo":{"shape":"Sr"},"instanceName":{}}},"output":{"type":"structure","members":{"operation":{"shape":"S5"}}}},"PeerVpc":{"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"operation":{"shape":"S5"}}}},"PutAlarm":{"input":{"type":"structure","required":["alarmName","metricName","monitoredResourceName","comparisonOperator","threshold","evaluationPeriods"],"members":{"alarmName":{},"metricName":{},"monitoredResourceName":{},"comparisonOperator":{},"threshold":{"type":"double"},"evaluationPeriods":{"type":"integer"},"datapointsToAlarm":{"type":"integer"},"treatMissingData":{},"contactProtocols":{"shape":"S5i"},"notificationTriggers":{"shape":"S5j"},"notificationEnabled":{"type":"boolean"}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"PutInstancePublicPorts":{"input":{"type":"structure","required":["portInfos","instanceName"],"members":{"portInfos":{"type":"list","member":{"shape":"Sr"}},"instanceName":{}}},"output":{"type":"structure","members":{"operation":{"shape":"S5"}}}},"RebootInstance":{"input":{"type":"structure","required":["instanceName"],"members":{"instanceName":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"RebootRelationalDatabase":{"input":{"type":"structure","required":["relationalDatabaseName"],"members":{"relationalDatabaseName":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"ReleaseStaticIp":{"input":{"type":"structure","required":["staticIpName"],"members":{"staticIpName":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"ResetDistributionCache":{"input":{"type":"structure","members":{"distributionName":{}}},"output":{"type":"structure","members":{"status":{},"createTime":{"type":"timestamp"},"operation":{"shape":"S5"}}}},"SendContactMethodVerification":{"input":{"type":"structure","required":["protocol"],"members":{"protocol":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"StartInstance":{"input":{"type":"structure","required":["instanceName"],"members":{"instanceName":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"StartRelationalDatabase":{"input":{"type":"structure","required":["relationalDatabaseName"],"members":{"relationalDatabaseName":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"StopInstance":{"input":{"type":"structure","required":["instanceName"],"members":{"instanceName":{},"force":{"type":"boolean"}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"StopRelationalDatabase":{"input":{"type":"structure","required":["relationalDatabaseName"],"members":{"relationalDatabaseName":{},"relationalDatabaseSnapshotName":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"TagResource":{"input":{"type":"structure","required":["resourceName","tags"],"members":{"resourceName":{},"resourceArn":{},"tags":{"shape":"S12"}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"TestAlarm":{"input":{"type":"structure","required":["alarmName","state"],"members":{"alarmName":{},"state":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"UnpeerVpc":{"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"operation":{"shape":"S5"}}}},"UntagResource":{"input":{"type":"structure","required":["resourceName","tagKeys"],"members":{"resourceName":{},"resourceArn":{},"tagKeys":{"type":"list","member":{}}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"UpdateDistribution":{"input":{"type":"structure","required":["distributionName"],"members":{"distributionName":{},"origin":{"shape":"S29"},"defaultCacheBehavior":{"shape":"S2b"},"cacheBehaviorSettings":{"shape":"S2d"},"cacheBehaviors":{"shape":"S2l"},"isEnabled":{"type":"boolean"}}},"output":{"type":"structure","members":{"operation":{"shape":"S5"}}}},"UpdateDistributionBundle":{"input":{"type":"structure","members":{"distributionName":{},"bundleId":{}}},"output":{"type":"structure","members":{"operation":{"shape":"S5"}}}},"UpdateDomainEntry":{"input":{"type":"structure","required":["domainName","domainEntry"],"members":{"domainName":{},"domainEntry":{"shape":"S2t"}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"UpdateLoadBalancerAttribute":{"input":{"type":"structure","required":["loadBalancerName","attributeName","attributeValue"],"members":{"loadBalancerName":{},"attributeName":{},"attributeValue":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"UpdateRelationalDatabase":{"input":{"type":"structure","required":["relationalDatabaseName"],"members":{"relationalDatabaseName":{},"masterUserPassword":{"shape":"S3h"},"rotateMasterUserPassword":{"type":"boolean"},"preferredBackupWindow":{},"preferredMaintenanceWindow":{},"enableBackupRetention":{"type":"boolean"},"disableBackupRetention":{"type":"boolean"},"publiclyAccessible":{"type":"boolean"},"applyImmediately":{"type":"boolean"},"caCertificateIdentifier":{}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}},"UpdateRelationalDatabaseParameters":{"input":{"type":"structure","required":["relationalDatabaseName","parameters"],"members":{"relationalDatabaseName":{},"parameters":{"shape":"Sbh"}}},"output":{"type":"structure","members":{"operations":{"shape":"S4"}}}}},"shapes":{"S4":{"type":"list","member":{"shape":"S5"}},"S5":{"type":"structure","members":{"id":{},"resourceName":{},"resourceType":{},"createdAt":{"type":"timestamp"},"location":{"shape":"S9"},"isTerminal":{"type":"boolean"},"operationDetails":{},"operationType":{},"status":{},"statusChangedAt":{"type":"timestamp"},"errorCode":{},"errorDetails":{}}},"S9":{"type":"structure","members":{"availabilityZone":{},"regionName":{}}},"Sk":{"type":"list","member":{}},"Sr":{"type":"structure","members":{"fromPort":{"type":"integer"},"toPort":{"type":"integer"},"protocol":{},"cidrs":{"shape":"Su"},"cidrListAliases":{"shape":"Su"}}},"Su":{"type":"list","member":{}},"S11":{"type":"list","member":{}},"S12":{"type":"list","member":{"type":"structure","members":{"key":{},"value":{}}}},"S17":{"type":"structure","members":{"certificateArn":{},"certificateName":{},"domainName":{},"certificateDetail":{"type":"structure","members":{"arn":{},"name":{},"domainName":{},"status":{},"serialNumber":{},"subjectAlternativeNames":{"shape":"S11"},"domainValidationRecords":{"shape":"S1b"},"requestFailureReason":{},"inUseResourceCount":{"type":"integer"},"keyAlgorithm":{},"createdAt":{"type":"timestamp"},"issuedAt":{"type":"timestamp"},"issuerCA":{},"notBefore":{"type":"timestamp"},"notAfter":{"type":"timestamp"},"eligibleToRenew":{},"renewalSummary":{"type":"structure","members":{"domainValidationRecords":{"shape":"S1b"},"renewalStatus":{},"renewalStatusReason":{},"updatedAt":{"type":"timestamp"}}},"revokedAt":{"type":"timestamp"},"revocationReason":{},"tags":{"shape":"S12"},"supportCode":{}}},"tags":{"shape":"S12"}}},"S1b":{"type":"list","member":{"type":"structure","members":{"domainName":{},"resourceRecord":{"type":"structure","members":{"name":{},"type":{},"value":{}}}}}},"S1y":{"type":"list","member":{"shape":"S1z"}},"S1z":{"type":"structure","required":["addOnType"],"members":{"addOnType":{},"autoSnapshotAddOnRequest":{"type":"structure","members":{"snapshotTimeOfDay":{}}}}},"S29":{"type":"structure","members":{"name":{},"regionName":{},"protocolPolicy":{}}},"S2b":{"type":"structure","members":{"behavior":{}}},"S2d":{"type":"structure","members":{"defaultTTL":{"type":"long"},"minimumTTL":{"type":"long"},"maximumTTL":{"type":"long"},"allowedHTTPMethods":{},"cachedHTTPMethods":{},"forwardedCookies":{"type":"structure","members":{"option":{},"cookiesAllowList":{"shape":"Su"}}},"forwardedHeaders":{"type":"structure","members":{"option":{},"headersAllowList":{"type":"list","member":{}}}},"forwardedQueryStrings":{"type":"structure","members":{"option":{"type":"boolean"},"queryStringsAllowList":{"shape":"Su"}}}}},"S2l":{"type":"list","member":{"type":"structure","members":{"path":{},"behavior":{}}}},"S2o":{"type":"structure","members":{"name":{},"arn":{},"supportCode":{},"createdAt":{"type":"timestamp"},"location":{"shape":"S9"},"resourceType":{},"alternativeDomainNames":{"shape":"Su"},"status":{},"isEnabled":{"type":"boolean"},"domainName":{},"bundleId":{},"certificateName":{},"origin":{"type":"structure","members":{"name":{},"resourceType":{},"regionName":{},"protocolPolicy":{}}},"originPublicDNS":{},"defaultCacheBehavior":{"shape":"S2b"},"cacheBehaviorSettings":{"shape":"S2d"},"cacheBehaviors":{"shape":"S2l"},"ableToUpdateBundle":{"type":"boolean"},"tags":{"shape":"S12"}}},"S2t":{"type":"structure","members":{"id":{},"name":{},"target":{},"isAlias":{"type":"boolean"},"type":{},"options":{"deprecated":true,"type":"map","key":{},"value":{}}}},"S39":{"type":"structure","members":{"name":{},"arn":{},"supportCode":{},"createdAt":{"type":"timestamp"},"location":{"shape":"S9"},"resourceType":{},"tags":{"shape":"S12"},"fingerprint":{}}},"S3c":{"type":"list","member":{}},"S3h":{"type":"string","sensitive":true},"S5i":{"type":"list","member":{}},"S5j":{"type":"list","member":{}},"S6g":{"type":"structure","members":{"id":{},"service":{}}},"S6o":{"type":"structure","members":{"name":{},"arn":{},"supportCode":{},"createdAt":{"type":"timestamp"},"location":{"shape":"S9"},"resourceType":{},"tags":{"shape":"S12"},"addOns":{"shape":"S6p"},"sizeInGb":{"type":"integer"},"isSystemDisk":{"type":"boolean"},"iops":{"type":"integer"},"path":{},"state":{},"attachedTo":{},"isAttached":{"type":"boolean"},"attachmentState":{"deprecated":true},"gbInUse":{"deprecated":true,"type":"integer"}}},"S6p":{"type":"list","member":{"type":"structure","members":{"name":{},"status":{},"snapshotTimeOfDay":{},"nextSnapshotTimeOfDay":{}}}},"S6u":{"type":"structure","members":{"name":{},"arn":{},"supportCode":{},"createdAt":{"type":"timestamp"},"location":{"shape":"S9"},"resourceType":{},"tags":{"shape":"S12"},"sizeInGb":{"type":"integer"},"state":{},"progress":{},"fromDiskName":{},"fromDiskArn":{},"fromInstanceName":{},"fromInstanceArn":{},"isFromAutoSnapshot":{"type":"boolean"}}},"S71":{"type":"list","member":{"shape":"S6o"}},"S7b":{"type":"list","member":{}},"S7d":{"type":"list","member":{"type":"structure","members":{"average":{"type":"double"},"maximum":{"type":"double"},"minimum":{"type":"double"},"sampleCount":{"type":"double"},"sum":{"type":"double"},"timestamp":{"type":"timestamp"},"unit":{}}}},"S7k":{"type":"structure","members":{"name":{},"arn":{},"supportCode":{},"createdAt":{"type":"timestamp"},"location":{"shape":"S9"},"resourceType":{},"tags":{"shape":"S12"},"domainEntries":{"type":"list","member":{"shape":"S2t"}}}},"S81":{"type":"structure","members":{"name":{},"arn":{},"supportCode":{},"createdAt":{"type":"timestamp"},"location":{"shape":"S9"},"resourceType":{},"tags":{"shape":"S12"},"blueprintId":{},"blueprintName":{},"bundleId":{},"addOns":{"shape":"S6p"},"isStaticIp":{"type":"boolean"},"privateIpAddress":{},"publicIpAddress":{},"ipv6Address":{},"hardware":{"type":"structure","members":{"cpuCount":{"type":"integer"},"disks":{"shape":"S71"},"ramSizeInGb":{"type":"float"}}},"networking":{"type":"structure","members":{"monthlyTransfer":{"type":"structure","members":{"gbPerMonthAllocated":{"type":"integer"}}},"ports":{"type":"list","member":{"type":"structure","members":{"fromPort":{"type":"integer"},"toPort":{"type":"integer"},"protocol":{},"accessFrom":{},"accessType":{},"commonName":{},"accessDirection":{},"cidrs":{"shape":"Su"},"cidrListAliases":{"shape":"Su"}}}}}},"state":{"shape":"S8b"},"username":{},"sshKeyName":{}}},"S8b":{"type":"structure","members":{"code":{"type":"integer"},"name":{}}},"S8t":{"type":"structure","members":{"name":{},"arn":{},"supportCode":{},"createdAt":{"type":"timestamp"},"location":{"shape":"S9"},"resourceType":{},"tags":{"shape":"S12"},"state":{},"progress":{},"fromAttachedDisks":{"shape":"S71"},"fromInstanceName":{},"fromInstanceArn":{},"fromBlueprintId":{},"fromBundleId":{},"isFromAutoSnapshot":{"type":"boolean"},"sizeInGb":{"type":"integer"}}},"S9a":{"type":"structure","members":{"name":{},"arn":{},"supportCode":{},"createdAt":{"type":"timestamp"},"location":{"shape":"S9"},"resourceType":{},"tags":{"shape":"S12"},"dnsName":{},"state":{},"protocol":{},"publicPorts":{"type":"list","member":{"type":"integer"}},"healthCheckPath":{},"instancePort":{"type":"integer"},"instanceHealthSummary":{"type":"list","member":{"type":"structure","members":{"instanceName":{},"instanceHealth":{},"instanceHealthReason":{}}}},"tlsCertificateSummaries":{"type":"list","member":{"type":"structure","members":{"name":{},"isAttached":{"type":"boolean"}}}},"configurationOptions":{"type":"map","key":{},"value":{}}}},"Sag":{"type":"list","member":{"type":"structure","members":{"zoneName":{},"state":{}}}},"Sak":{"type":"structure","members":{"name":{},"arn":{},"supportCode":{},"createdAt":{"type":"timestamp"},"location":{"shape":"S9"},"resourceType":{},"tags":{"shape":"S12"},"relationalDatabaseBlueprintId":{},"relationalDatabaseBundleId":{},"masterDatabaseName":{},"hardware":{"type":"structure","members":{"cpuCount":{"type":"integer"},"diskSizeInGb":{"type":"integer"},"ramSizeInGb":{"type":"float"}}},"state":{},"secondaryAvailabilityZone":{},"backupRetentionEnabled":{"type":"boolean"},"pendingModifiedValues":{"type":"structure","members":{"masterUserPassword":{},"engineVersion":{},"backupRetentionEnabled":{"type":"boolean"}}},"engine":{},"engineVersion":{},"latestRestorableTime":{"type":"timestamp"},"masterUsername":{},"parameterApplyStatus":{},"preferredBackupWindow":{},"preferredMaintenanceWindow":{},"publiclyAccessible":{"type":"boolean"},"masterEndpoint":{"type":"structure","members":{"port":{"type":"integer"},"address":{}}},"pendingMaintenanceActions":{"type":"list","member":{"type":"structure","members":{"action":{},"description":{},"currentApplyDate":{"type":"timestamp"}}}},"caCertificateIdentifier":{}}},"Sbh":{"type":"list","member":{"type":"structure","members":{"allowedValues":{},"applyMethod":{},"applyType":{},"dataType":{},"description":{},"isModifiable":{"type":"boolean"},"parameterName":{},"parameterValue":{}}}},"Sbl":{"type":"structure","members":{"name":{},"arn":{},"supportCode":{},"createdAt":{"type":"timestamp"},"location":{"shape":"S9"},"resourceType":{},"tags":{"shape":"S12"},"engine":{},"engineVersion":{},"sizeInGb":{"type":"integer"},"state":{},"fromRelationalDatabaseName":{},"fromRelationalDatabaseArn":{},"fromRelationalDatabaseBundleId":{},"fromRelationalDatabaseBlueprintId":{}}},"Sbu":{"type":"structure","members":{"name":{},"arn":{},"supportCode":{},"createdAt":{"type":"timestamp"},"location":{"shape":"S9"},"resourceType":{},"ipAddress":{},"attachedTo":{},"isAttached":{"type":"boolean"}}}}}; -/***/ }), +var protocolHttp = __nccwpck_require__(2356); +var core = __nccwpck_require__(402); +var propertyProvider = __nccwpck_require__(8857); +var client = __nccwpck_require__(5152); +var signatureV4 = __nccwpck_require__(5118); +var cbor = __nccwpck_require__(4645); +var schema = __nccwpck_require__(6890); +var smithyClient = __nccwpck_require__(1411); +var protocols = __nccwpck_require__(3422); +var serde = __nccwpck_require__(2430); +var utilBase64 = __nccwpck_require__(8385); +var utilUtf8 = __nccwpck_require__(1577); +var xmlBuilder = __nccwpck_require__(4274); + +const state = { + warningEmitted: false, +}; +const emitWarningIfUnsupportedVersion = (version) => { + if (version && !state.warningEmitted && parseInt(version.substring(1, version.indexOf("."))) < 18) { + state.warningEmitted = true; + process.emitWarning(`NodeDeprecationWarning: The AWS SDK for JavaScript (v3) will +no longer support Node.js 16.x on January 6, 2025. -/***/ 1209: -/***/ (function(module) { +To continue receiving updates to AWS services, bug fixes, and security +updates please upgrade to a supported Node.js LTS version. -module.exports = {"metadata":{"apiVersion":"2017-07-25","endpointPrefix":"dataexchange","signingName":"dataexchange","serviceFullName":"AWS Data Exchange","serviceId":"DataExchange","protocol":"rest-json","jsonVersion":"1.1","uid":"dataexchange-2017-07-25","signatureVersion":"v4"},"operations":{"CancelJob":{"http":{"method":"DELETE","requestUri":"/v1/jobs/{JobId}","responseCode":204},"input":{"type":"structure","members":{"JobId":{"location":"uri","locationName":"JobId"}},"required":["JobId"]}},"CreateDataSet":{"http":{"requestUri":"/v1/data-sets","responseCode":201},"input":{"type":"structure","members":{"AssetType":{},"Description":{},"Name":{},"Tags":{"shape":"S7"}},"required":["AssetType","Description","Name"]},"output":{"type":"structure","members":{"Arn":{},"AssetType":{},"CreatedAt":{"shape":"Sa"},"Description":{},"Id":{},"Name":{},"Origin":{},"OriginDetails":{"shape":"Sd"},"SourceId":{},"Tags":{"shape":"S7"},"UpdatedAt":{"shape":"Sa"}}}},"CreateJob":{"http":{"requestUri":"/v1/jobs","responseCode":201},"input":{"type":"structure","members":{"Details":{"type":"structure","members":{"ExportAssetToSignedUrl":{"type":"structure","members":{"AssetId":{},"DataSetId":{},"RevisionId":{}},"required":["DataSetId","AssetId","RevisionId"]},"ExportAssetsToS3":{"type":"structure","members":{"AssetDestinations":{"shape":"Si"},"DataSetId":{},"Encryption":{"shape":"Sk"},"RevisionId":{}},"required":["AssetDestinations","DataSetId","RevisionId"]},"ImportAssetFromSignedUrl":{"type":"structure","members":{"AssetName":{},"DataSetId":{},"Md5Hash":{},"RevisionId":{}},"required":["DataSetId","Md5Hash","RevisionId","AssetName"]},"ImportAssetsFromS3":{"type":"structure","members":{"AssetSources":{"shape":"Sq"},"DataSetId":{},"RevisionId":{}},"required":["DataSetId","AssetSources","RevisionId"]}}},"Type":{}},"required":["Type","Details"]},"output":{"type":"structure","members":{"Arn":{},"CreatedAt":{"shape":"Sa"},"Details":{"shape":"Su"},"Errors":{"shape":"Sz"},"Id":{},"State":{},"Type":{},"UpdatedAt":{"shape":"Sa"}}}},"CreateRevision":{"http":{"requestUri":"/v1/data-sets/{DataSetId}/revisions","responseCode":201},"input":{"type":"structure","members":{"Comment":{},"DataSetId":{"location":"uri","locationName":"DataSetId"},"Tags":{"shape":"S7"}},"required":["DataSetId"]},"output":{"type":"structure","members":{"Arn":{},"Comment":{},"CreatedAt":{"shape":"Sa"},"DataSetId":{},"Finalized":{"type":"boolean"},"Id":{},"SourceId":{},"Tags":{"shape":"S7"},"UpdatedAt":{"shape":"Sa"}}}},"DeleteAsset":{"http":{"method":"DELETE","requestUri":"/v1/data-sets/{DataSetId}/revisions/{RevisionId}/assets/{AssetId}","responseCode":204},"input":{"type":"structure","members":{"AssetId":{"location":"uri","locationName":"AssetId"},"DataSetId":{"location":"uri","locationName":"DataSetId"},"RevisionId":{"location":"uri","locationName":"RevisionId"}},"required":["RevisionId","AssetId","DataSetId"]}},"DeleteDataSet":{"http":{"method":"DELETE","requestUri":"/v1/data-sets/{DataSetId}","responseCode":204},"input":{"type":"structure","members":{"DataSetId":{"location":"uri","locationName":"DataSetId"}},"required":["DataSetId"]}},"DeleteRevision":{"http":{"method":"DELETE","requestUri":"/v1/data-sets/{DataSetId}/revisions/{RevisionId}","responseCode":204},"input":{"type":"structure","members":{"DataSetId":{"location":"uri","locationName":"DataSetId"},"RevisionId":{"location":"uri","locationName":"RevisionId"}},"required":["RevisionId","DataSetId"]}},"GetAsset":{"http":{"method":"GET","requestUri":"/v1/data-sets/{DataSetId}/revisions/{RevisionId}/assets/{AssetId}","responseCode":200},"input":{"type":"structure","members":{"AssetId":{"location":"uri","locationName":"AssetId"},"DataSetId":{"location":"uri","locationName":"DataSetId"},"RevisionId":{"location":"uri","locationName":"RevisionId"}},"required":["RevisionId","AssetId","DataSetId"]},"output":{"type":"structure","members":{"Arn":{},"AssetDetails":{"shape":"S1h"},"AssetType":{},"CreatedAt":{"shape":"Sa"},"DataSetId":{},"Id":{},"Name":{},"RevisionId":{},"SourceId":{},"UpdatedAt":{"shape":"Sa"}}}},"GetDataSet":{"http":{"method":"GET","requestUri":"/v1/data-sets/{DataSetId}","responseCode":200},"input":{"type":"structure","members":{"DataSetId":{"location":"uri","locationName":"DataSetId"}},"required":["DataSetId"]},"output":{"type":"structure","members":{"Arn":{},"AssetType":{},"CreatedAt":{"shape":"Sa"},"Description":{},"Id":{},"Name":{},"Origin":{},"OriginDetails":{"shape":"Sd"},"SourceId":{},"Tags":{"shape":"S7"},"UpdatedAt":{"shape":"Sa"}}}},"GetJob":{"http":{"method":"GET","requestUri":"/v1/jobs/{JobId}","responseCode":200},"input":{"type":"structure","members":{"JobId":{"location":"uri","locationName":"JobId"}},"required":["JobId"]},"output":{"type":"structure","members":{"Arn":{},"CreatedAt":{"shape":"Sa"},"Details":{"shape":"Su"},"Errors":{"shape":"Sz"},"Id":{},"State":{},"Type":{},"UpdatedAt":{"shape":"Sa"}}}},"GetRevision":{"http":{"method":"GET","requestUri":"/v1/data-sets/{DataSetId}/revisions/{RevisionId}","responseCode":200},"input":{"type":"structure","members":{"DataSetId":{"location":"uri","locationName":"DataSetId"},"RevisionId":{"location":"uri","locationName":"RevisionId"}},"required":["RevisionId","DataSetId"]},"output":{"type":"structure","members":{"Arn":{},"Comment":{},"CreatedAt":{"shape":"Sa"},"DataSetId":{},"Finalized":{"type":"boolean"},"Id":{},"SourceId":{},"Tags":{"shape":"S7"},"UpdatedAt":{"shape":"Sa"}}}},"ListDataSetRevisions":{"http":{"method":"GET","requestUri":"/v1/data-sets/{DataSetId}/revisions","responseCode":200},"input":{"type":"structure","members":{"DataSetId":{"location":"uri","locationName":"DataSetId"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}},"required":["DataSetId"]},"output":{"type":"structure","members":{"NextToken":{},"Revisions":{"type":"list","member":{"type":"structure","members":{"Arn":{},"Comment":{},"CreatedAt":{"shape":"Sa"},"DataSetId":{},"Finalized":{"type":"boolean"},"Id":{},"SourceId":{},"UpdatedAt":{"shape":"Sa"}},"required":["CreatedAt","DataSetId","Id","Arn","UpdatedAt"]}}}}},"ListDataSets":{"http":{"method":"GET","requestUri":"/v1/data-sets","responseCode":200},"input":{"type":"structure","members":{"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"},"Origin":{"location":"querystring","locationName":"origin"}}},"output":{"type":"structure","members":{"DataSets":{"type":"list","member":{"type":"structure","members":{"Arn":{},"AssetType":{},"CreatedAt":{"shape":"Sa"},"Description":{},"Id":{},"Name":{},"Origin":{},"OriginDetails":{"shape":"Sd"},"SourceId":{},"UpdatedAt":{"shape":"Sa"}},"required":["Origin","AssetType","Description","CreatedAt","Id","Arn","UpdatedAt","Name"]}},"NextToken":{}}}},"ListJobs":{"http":{"method":"GET","requestUri":"/v1/jobs","responseCode":200},"input":{"type":"structure","members":{"DataSetId":{"location":"querystring","locationName":"dataSetId"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"},"RevisionId":{"location":"querystring","locationName":"revisionId"}}},"output":{"type":"structure","members":{"Jobs":{"type":"list","member":{"type":"structure","members":{"Arn":{},"CreatedAt":{"shape":"Sa"},"Details":{"shape":"Su"},"Errors":{"shape":"Sz"},"Id":{},"State":{},"Type":{},"UpdatedAt":{"shape":"Sa"}},"required":["Type","Details","State","CreatedAt","Id","Arn","UpdatedAt"]}},"NextToken":{}}}},"ListRevisionAssets":{"http":{"method":"GET","requestUri":"/v1/data-sets/{DataSetId}/revisions/{RevisionId}/assets","responseCode":200},"input":{"type":"structure","members":{"DataSetId":{"location":"uri","locationName":"DataSetId"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"},"RevisionId":{"location":"uri","locationName":"RevisionId"}},"required":["RevisionId","DataSetId"]},"output":{"type":"structure","members":{"Assets":{"type":"list","member":{"type":"structure","members":{"Arn":{},"AssetDetails":{"shape":"S1h"},"AssetType":{},"CreatedAt":{"shape":"Sa"},"DataSetId":{},"Id":{},"Name":{},"RevisionId":{},"SourceId":{},"UpdatedAt":{"shape":"Sa"}},"required":["AssetType","CreatedAt","DataSetId","Id","Arn","AssetDetails","UpdatedAt","RevisionId","Name"]}},"NextToken":{}}}},"ListTagsForResource":{"http":{"method":"GET","requestUri":"/tags/{resource-arn}","responseCode":200},"input":{"type":"structure","members":{"ResourceArn":{"location":"uri","locationName":"resource-arn"}},"required":["ResourceArn"]},"output":{"type":"structure","members":{"Tags":{"shape":"S7","locationName":"tags"}}}},"StartJob":{"http":{"method":"PATCH","requestUri":"/v1/jobs/{JobId}","responseCode":202},"input":{"type":"structure","members":{"JobId":{"location":"uri","locationName":"JobId"}},"required":["JobId"]},"output":{"type":"structure","members":{}}},"TagResource":{"http":{"requestUri":"/tags/{resource-arn}","responseCode":204},"input":{"type":"structure","members":{"ResourceArn":{"location":"uri","locationName":"resource-arn"},"Tags":{"shape":"S7","locationName":"tags"}},"required":["ResourceArn","Tags"]}},"UntagResource":{"http":{"method":"DELETE","requestUri":"/tags/{resource-arn}","responseCode":204},"input":{"type":"structure","members":{"ResourceArn":{"location":"uri","locationName":"resource-arn"},"TagKeys":{"location":"querystring","locationName":"tagKeys","type":"list","member":{}}},"required":["TagKeys","ResourceArn"]}},"UpdateAsset":{"http":{"method":"PATCH","requestUri":"/v1/data-sets/{DataSetId}/revisions/{RevisionId}/assets/{AssetId}","responseCode":200},"input":{"type":"structure","members":{"AssetId":{"location":"uri","locationName":"AssetId"},"DataSetId":{"location":"uri","locationName":"DataSetId"},"Name":{},"RevisionId":{"location":"uri","locationName":"RevisionId"}},"required":["RevisionId","AssetId","DataSetId","Name"]},"output":{"type":"structure","members":{"Arn":{},"AssetDetails":{"shape":"S1h"},"AssetType":{},"CreatedAt":{"shape":"Sa"},"DataSetId":{},"Id":{},"Name":{},"RevisionId":{},"SourceId":{},"UpdatedAt":{"shape":"Sa"}}}},"UpdateDataSet":{"http":{"method":"PATCH","requestUri":"/v1/data-sets/{DataSetId}","responseCode":200},"input":{"type":"structure","members":{"DataSetId":{"location":"uri","locationName":"DataSetId"},"Description":{},"Name":{}},"required":["DataSetId"]},"output":{"type":"structure","members":{"Arn":{},"AssetType":{},"CreatedAt":{"shape":"Sa"},"Description":{},"Id":{},"Name":{},"Origin":{},"OriginDetails":{"shape":"Sd"},"SourceId":{},"UpdatedAt":{"shape":"Sa"}}}},"UpdateRevision":{"http":{"method":"PATCH","requestUri":"/v1/data-sets/{DataSetId}/revisions/{RevisionId}","responseCode":200},"input":{"type":"structure","members":{"Comment":{},"DataSetId":{"location":"uri","locationName":"DataSetId"},"Finalized":{"type":"boolean"},"RevisionId":{"location":"uri","locationName":"RevisionId"}},"required":["RevisionId","DataSetId"]},"output":{"type":"structure","members":{"Arn":{},"Comment":{},"CreatedAt":{"shape":"Sa"},"DataSetId":{},"Finalized":{"type":"boolean"},"Id":{},"SourceId":{},"UpdatedAt":{"shape":"Sa"}}}}},"shapes":{"S7":{"type":"map","key":{},"value":{}},"Sa":{"type":"timestamp","timestampFormat":"iso8601"},"Sd":{"type":"structure","members":{"ProductId":{}},"required":["ProductId"]},"Si":{"type":"list","member":{"type":"structure","members":{"AssetId":{},"Bucket":{},"Key":{}},"required":["Bucket","AssetId"]}},"Sk":{"type":"structure","members":{"KmsKeyArn":{},"Type":{}},"required":["Type"]},"Sq":{"type":"list","member":{"type":"structure","members":{"Bucket":{},"Key":{}},"required":["Bucket","Key"]}},"Su":{"type":"structure","members":{"ExportAssetToSignedUrl":{"type":"structure","members":{"AssetId":{},"DataSetId":{},"RevisionId":{},"SignedUrl":{},"SignedUrlExpiresAt":{"shape":"Sa"}},"required":["DataSetId","AssetId","RevisionId"]},"ExportAssetsToS3":{"type":"structure","members":{"AssetDestinations":{"shape":"Si"},"DataSetId":{},"Encryption":{"shape":"Sk"},"RevisionId":{}},"required":["AssetDestinations","DataSetId","RevisionId"]},"ImportAssetFromSignedUrl":{"type":"structure","members":{"AssetName":{},"DataSetId":{},"Md5Hash":{},"RevisionId":{},"SignedUrl":{},"SignedUrlExpiresAt":{"shape":"Sa"}},"required":["DataSetId","AssetName","RevisionId"]},"ImportAssetsFromS3":{"type":"structure","members":{"AssetSources":{"shape":"Sq"},"DataSetId":{},"RevisionId":{}},"required":["DataSetId","AssetSources","RevisionId"]}}},"Sz":{"type":"list","member":{"type":"structure","members":{"Code":{},"Details":{"type":"structure","members":{"ImportAssetFromSignedUrlJobErrorDetails":{"type":"structure","members":{"AssetName":{}},"required":["AssetName"]},"ImportAssetsFromS3JobErrorDetails":{"shape":"Sq"}}},"LimitName":{},"LimitValue":{"type":"double"},"Message":{},"ResourceId":{},"ResourceType":{}},"required":["Message","Code"]}},"S1h":{"type":"structure","members":{"S3SnapshotAsset":{"type":"structure","members":{"Size":{"type":"double"}},"required":["Size"]}}}}}; +More information can be found at: https://a.co/74kJMmI`); + } +}; -/***/ }), +function setCredentialFeature(credentials, feature, value) { + if (!credentials.$source) { + credentials.$source = {}; + } + credentials.$source[feature] = value; + return credentials; +} -/***/ 1220: -/***/ (function(module) { +function setFeature(context, feature, value) { + if (!context.__aws_sdk_context) { + context.__aws_sdk_context = { + features: {}, + }; + } + else if (!context.__aws_sdk_context.features) { + context.__aws_sdk_context.features = {}; + } + context.__aws_sdk_context.features[feature] = value; +} -module.exports = {"pagination":{"GetEffectivePermissionsForPath":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListPermissions":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListResources":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"}}}; +function setTokenFeature(token, feature, value) { + if (!token.$source) { + token.$source = {}; + } + token.$source[feature] = value; + return token; +} -/***/ }), +const getDateHeader = (response) => protocolHttp.HttpResponse.isInstance(response) ? response.headers?.date ?? response.headers?.Date : undefined; -/***/ 1250: -/***/ (function(module, __unusedexports, __webpack_require__) { +const getSkewCorrectedDate = (systemClockOffset) => new Date(Date.now() + systemClockOffset); -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +const isClockSkewed = (clockTime, systemClockOffset) => Math.abs(getSkewCorrectedDate(systemClockOffset).getTime() - clockTime) >= 300000; -apiLoader.services['worklink'] = {}; -AWS.WorkLink = Service.defineService('worklink', ['2018-09-25']); -Object.defineProperty(apiLoader.services['worklink'], '2018-09-25', { - get: function get() { - var model = __webpack_require__(7040); - model.paginators = __webpack_require__(3413).pagination; - return model; - }, - enumerable: true, - configurable: true -}); +const getUpdatedSystemClockOffset = (clockTime, currentSystemClockOffset) => { + const clockTimeInMs = Date.parse(clockTime); + if (isClockSkewed(clockTimeInMs, currentSystemClockOffset)) { + return clockTimeInMs - Date.now(); + } + return currentSystemClockOffset; +}; -module.exports = AWS.WorkLink; +const throwSigningPropertyError = (name, property) => { + if (!property) { + throw new Error(`Property \`${name}\` is not resolved for AWS SDK SigV4Auth`); + } + return property; +}; +const validateSigningProperties = async (signingProperties) => { + const context = throwSigningPropertyError("context", signingProperties.context); + const config = throwSigningPropertyError("config", signingProperties.config); + const authScheme = context.endpointV2?.properties?.authSchemes?.[0]; + const signerFunction = throwSigningPropertyError("signer", config.signer); + const signer = await signerFunction(authScheme); + const signingRegion = signingProperties?.signingRegion; + const signingRegionSet = signingProperties?.signingRegionSet; + const signingName = signingProperties?.signingName; + return { + config, + signer, + signingRegion, + signingRegionSet, + signingName, + }; +}; +class AwsSdkSigV4Signer { + async sign(httpRequest, identity, signingProperties) { + if (!protocolHttp.HttpRequest.isInstance(httpRequest)) { + throw new Error("The request is not an instance of `HttpRequest` and cannot be signed"); + } + const validatedProps = await validateSigningProperties(signingProperties); + const { config, signer } = validatedProps; + let { signingRegion, signingName } = validatedProps; + const handlerExecutionContext = signingProperties.context; + if (handlerExecutionContext?.authSchemes?.length ?? 0 > 1) { + const [first, second] = handlerExecutionContext.authSchemes; + if (first?.name === "sigv4a" && second?.name === "sigv4") { + signingRegion = second?.signingRegion ?? signingRegion; + signingName = second?.signingName ?? signingName; + } + } + const signedRequest = await signer.sign(httpRequest, { + signingDate: getSkewCorrectedDate(config.systemClockOffset), + signingRegion: signingRegion, + signingService: signingName, + }); + return signedRequest; + } + errorHandler(signingProperties) { + return (error) => { + const serverTime = error.ServerTime ?? getDateHeader(error.$response); + if (serverTime) { + const config = throwSigningPropertyError("config", signingProperties.config); + const initialSystemClockOffset = config.systemClockOffset; + config.systemClockOffset = getUpdatedSystemClockOffset(serverTime, config.systemClockOffset); + const clockSkewCorrected = config.systemClockOffset !== initialSystemClockOffset; + if (clockSkewCorrected && error.$metadata) { + error.$metadata.clockSkewCorrected = true; + } + } + throw error; + }; + } + successHandler(httpResponse, signingProperties) { + const dateHeader = getDateHeader(httpResponse); + if (dateHeader) { + const config = throwSigningPropertyError("config", signingProperties.config); + config.systemClockOffset = getUpdatedSystemClockOffset(dateHeader, config.systemClockOffset); + } + } +} +const AWSSDKSigV4Signer = AwsSdkSigV4Signer; +class AwsSdkSigV4ASigner extends AwsSdkSigV4Signer { + async sign(httpRequest, identity, signingProperties) { + if (!protocolHttp.HttpRequest.isInstance(httpRequest)) { + throw new Error("The request is not an instance of `HttpRequest` and cannot be signed"); + } + const { config, signer, signingRegion, signingRegionSet, signingName } = await validateSigningProperties(signingProperties); + const configResolvedSigningRegionSet = await config.sigv4aSigningRegionSet?.(); + const multiRegionOverride = (configResolvedSigningRegionSet ?? + signingRegionSet ?? [signingRegion]).join(","); + const signedRequest = await signer.sign(httpRequest, { + signingDate: getSkewCorrectedDate(config.systemClockOffset), + signingRegion: multiRegionOverride, + signingService: signingName, + }); + return signedRequest; + } +} -/***/ }), +const getArrayForCommaSeparatedString = (str) => typeof str === "string" && str.length > 0 ? str.split(",").map((item) => item.trim()) : []; -/***/ 1256: -/***/ (function(module) { +const getBearerTokenEnvKey = (signingName) => `AWS_BEARER_TOKEN_${signingName.replace(/[\s-]/g, "_").toUpperCase()}`; -module.exports = {"version":"2.0","metadata":{"apiVersion":"2018-07-26","endpointPrefix":"email","jsonVersion":"1.1","protocol":"rest-json","serviceAbbreviation":"Pinpoint Email","serviceFullName":"Amazon Pinpoint Email Service","serviceId":"Pinpoint Email","signatureVersion":"v4","signingName":"ses","uid":"pinpoint-email-2018-07-26"},"operations":{"CreateConfigurationSet":{"http":{"requestUri":"/v1/email/configuration-sets"},"input":{"type":"structure","required":["ConfigurationSetName"],"members":{"ConfigurationSetName":{},"TrackingOptions":{"shape":"S3"},"DeliveryOptions":{"shape":"S5"},"ReputationOptions":{"shape":"S8"},"SendingOptions":{"shape":"Sb"},"Tags":{"shape":"Sc"}}},"output":{"type":"structure","members":{}}},"CreateConfigurationSetEventDestination":{"http":{"requestUri":"/v1/email/configuration-sets/{ConfigurationSetName}/event-destinations"},"input":{"type":"structure","required":["ConfigurationSetName","EventDestinationName","EventDestination"],"members":{"ConfigurationSetName":{"location":"uri","locationName":"ConfigurationSetName"},"EventDestinationName":{},"EventDestination":{"shape":"Sj"}}},"output":{"type":"structure","members":{}}},"CreateDedicatedIpPool":{"http":{"requestUri":"/v1/email/dedicated-ip-pools"},"input":{"type":"structure","required":["PoolName"],"members":{"PoolName":{},"Tags":{"shape":"Sc"}}},"output":{"type":"structure","members":{}}},"CreateDeliverabilityTestReport":{"http":{"requestUri":"/v1/email/deliverability-dashboard/test"},"input":{"type":"structure","required":["FromEmailAddress","Content"],"members":{"ReportName":{},"FromEmailAddress":{},"Content":{"shape":"S12"},"Tags":{"shape":"Sc"}}},"output":{"type":"structure","required":["ReportId","DeliverabilityTestStatus"],"members":{"ReportId":{},"DeliverabilityTestStatus":{}}}},"CreateEmailIdentity":{"http":{"requestUri":"/v1/email/identities"},"input":{"type":"structure","required":["EmailIdentity"],"members":{"EmailIdentity":{},"Tags":{"shape":"Sc"}}},"output":{"type":"structure","members":{"IdentityType":{},"VerifiedForSendingStatus":{"type":"boolean"},"DkimAttributes":{"shape":"S1k"}}}},"DeleteConfigurationSet":{"http":{"method":"DELETE","requestUri":"/v1/email/configuration-sets/{ConfigurationSetName}"},"input":{"type":"structure","required":["ConfigurationSetName"],"members":{"ConfigurationSetName":{"location":"uri","locationName":"ConfigurationSetName"}}},"output":{"type":"structure","members":{}}},"DeleteConfigurationSetEventDestination":{"http":{"method":"DELETE","requestUri":"/v1/email/configuration-sets/{ConfigurationSetName}/event-destinations/{EventDestinationName}"},"input":{"type":"structure","required":["ConfigurationSetName","EventDestinationName"],"members":{"ConfigurationSetName":{"location":"uri","locationName":"ConfigurationSetName"},"EventDestinationName":{"location":"uri","locationName":"EventDestinationName"}}},"output":{"type":"structure","members":{}}},"DeleteDedicatedIpPool":{"http":{"method":"DELETE","requestUri":"/v1/email/dedicated-ip-pools/{PoolName}"},"input":{"type":"structure","required":["PoolName"],"members":{"PoolName":{"location":"uri","locationName":"PoolName"}}},"output":{"type":"structure","members":{}}},"DeleteEmailIdentity":{"http":{"method":"DELETE","requestUri":"/v1/email/identities/{EmailIdentity}"},"input":{"type":"structure","required":["EmailIdentity"],"members":{"EmailIdentity":{"location":"uri","locationName":"EmailIdentity"}}},"output":{"type":"structure","members":{}}},"GetAccount":{"http":{"method":"GET","requestUri":"/v1/email/account"},"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"SendQuota":{"type":"structure","members":{"Max24HourSend":{"type":"double"},"MaxSendRate":{"type":"double"},"SentLast24Hours":{"type":"double"}}},"SendingEnabled":{"type":"boolean"},"DedicatedIpAutoWarmupEnabled":{"type":"boolean"},"EnforcementStatus":{},"ProductionAccessEnabled":{"type":"boolean"}}}},"GetBlacklistReports":{"http":{"method":"GET","requestUri":"/v1/email/deliverability-dashboard/blacklist-report"},"input":{"type":"structure","required":["BlacklistItemNames"],"members":{"BlacklistItemNames":{"location":"querystring","locationName":"BlacklistItemNames","type":"list","member":{}}}},"output":{"type":"structure","required":["BlacklistReport"],"members":{"BlacklistReport":{"type":"map","key":{},"value":{"type":"list","member":{"type":"structure","members":{"RblName":{},"ListingTime":{"type":"timestamp"},"Description":{}}}}}}}},"GetConfigurationSet":{"http":{"method":"GET","requestUri":"/v1/email/configuration-sets/{ConfigurationSetName}"},"input":{"type":"structure","required":["ConfigurationSetName"],"members":{"ConfigurationSetName":{"location":"uri","locationName":"ConfigurationSetName"}}},"output":{"type":"structure","members":{"ConfigurationSetName":{},"TrackingOptions":{"shape":"S3"},"DeliveryOptions":{"shape":"S5"},"ReputationOptions":{"shape":"S8"},"SendingOptions":{"shape":"Sb"},"Tags":{"shape":"Sc"}}}},"GetConfigurationSetEventDestinations":{"http":{"method":"GET","requestUri":"/v1/email/configuration-sets/{ConfigurationSetName}/event-destinations"},"input":{"type":"structure","required":["ConfigurationSetName"],"members":{"ConfigurationSetName":{"location":"uri","locationName":"ConfigurationSetName"}}},"output":{"type":"structure","members":{"EventDestinations":{"type":"list","member":{"type":"structure","required":["Name","MatchingEventTypes"],"members":{"Name":{},"Enabled":{"type":"boolean"},"MatchingEventTypes":{"shape":"Sk"},"KinesisFirehoseDestination":{"shape":"Sm"},"CloudWatchDestination":{"shape":"So"},"SnsDestination":{"shape":"Su"},"PinpointDestination":{"shape":"Sv"}}}}}}},"GetDedicatedIp":{"http":{"method":"GET","requestUri":"/v1/email/dedicated-ips/{IP}"},"input":{"type":"structure","required":["Ip"],"members":{"Ip":{"location":"uri","locationName":"IP"}}},"output":{"type":"structure","members":{"DedicatedIp":{"shape":"S2m"}}}},"GetDedicatedIps":{"http":{"method":"GET","requestUri":"/v1/email/dedicated-ips"},"input":{"type":"structure","members":{"PoolName":{"location":"querystring","locationName":"PoolName"},"NextToken":{"location":"querystring","locationName":"NextToken"},"PageSize":{"location":"querystring","locationName":"PageSize","type":"integer"}}},"output":{"type":"structure","members":{"DedicatedIps":{"type":"list","member":{"shape":"S2m"}},"NextToken":{}}}},"GetDeliverabilityDashboardOptions":{"http":{"method":"GET","requestUri":"/v1/email/deliverability-dashboard"},"input":{"type":"structure","members":{}},"output":{"type":"structure","required":["DashboardEnabled"],"members":{"DashboardEnabled":{"type":"boolean"},"SubscriptionExpiryDate":{"type":"timestamp"},"AccountStatus":{},"ActiveSubscribedDomains":{"shape":"S2x"},"PendingExpirationSubscribedDomains":{"shape":"S2x"}}}},"GetDeliverabilityTestReport":{"http":{"method":"GET","requestUri":"/v1/email/deliverability-dashboard/test-reports/{ReportId}"},"input":{"type":"structure","required":["ReportId"],"members":{"ReportId":{"location":"uri","locationName":"ReportId"}}},"output":{"type":"structure","required":["DeliverabilityTestReport","OverallPlacement","IspPlacements"],"members":{"DeliverabilityTestReport":{"shape":"S35"},"OverallPlacement":{"shape":"S37"},"IspPlacements":{"type":"list","member":{"type":"structure","members":{"IspName":{},"PlacementStatistics":{"shape":"S37"}}}},"Message":{},"Tags":{"shape":"Sc"}}}},"GetDomainDeliverabilityCampaign":{"http":{"method":"GET","requestUri":"/v1/email/deliverability-dashboard/campaigns/{CampaignId}"},"input":{"type":"structure","required":["CampaignId"],"members":{"CampaignId":{"location":"uri","locationName":"CampaignId"}}},"output":{"type":"structure","required":["DomainDeliverabilityCampaign"],"members":{"DomainDeliverabilityCampaign":{"shape":"S3f"}}}},"GetDomainStatisticsReport":{"http":{"method":"GET","requestUri":"/v1/email/deliverability-dashboard/statistics-report/{Domain}"},"input":{"type":"structure","required":["Domain","StartDate","EndDate"],"members":{"Domain":{"location":"uri","locationName":"Domain"},"StartDate":{"location":"querystring","locationName":"StartDate","type":"timestamp"},"EndDate":{"location":"querystring","locationName":"EndDate","type":"timestamp"}}},"output":{"type":"structure","required":["OverallVolume","DailyVolumes"],"members":{"OverallVolume":{"type":"structure","members":{"VolumeStatistics":{"shape":"S3p"},"ReadRatePercent":{"type":"double"},"DomainIspPlacements":{"shape":"S3q"}}},"DailyVolumes":{"type":"list","member":{"type":"structure","members":{"StartDate":{"type":"timestamp"},"VolumeStatistics":{"shape":"S3p"},"DomainIspPlacements":{"shape":"S3q"}}}}}}},"GetEmailIdentity":{"http":{"method":"GET","requestUri":"/v1/email/identities/{EmailIdentity}"},"input":{"type":"structure","required":["EmailIdentity"],"members":{"EmailIdentity":{"location":"uri","locationName":"EmailIdentity"}}},"output":{"type":"structure","members":{"IdentityType":{},"FeedbackForwardingStatus":{"type":"boolean"},"VerifiedForSendingStatus":{"type":"boolean"},"DkimAttributes":{"shape":"S1k"},"MailFromAttributes":{"type":"structure","required":["MailFromDomain","MailFromDomainStatus","BehaviorOnMxFailure"],"members":{"MailFromDomain":{},"MailFromDomainStatus":{},"BehaviorOnMxFailure":{}}},"Tags":{"shape":"Sc"}}}},"ListConfigurationSets":{"http":{"method":"GET","requestUri":"/v1/email/configuration-sets"},"input":{"type":"structure","members":{"NextToken":{"location":"querystring","locationName":"NextToken"},"PageSize":{"location":"querystring","locationName":"PageSize","type":"integer"}}},"output":{"type":"structure","members":{"ConfigurationSets":{"type":"list","member":{}},"NextToken":{}}}},"ListDedicatedIpPools":{"http":{"method":"GET","requestUri":"/v1/email/dedicated-ip-pools"},"input":{"type":"structure","members":{"NextToken":{"location":"querystring","locationName":"NextToken"},"PageSize":{"location":"querystring","locationName":"PageSize","type":"integer"}}},"output":{"type":"structure","members":{"DedicatedIpPools":{"type":"list","member":{}},"NextToken":{}}}},"ListDeliverabilityTestReports":{"http":{"method":"GET","requestUri":"/v1/email/deliverability-dashboard/test-reports"},"input":{"type":"structure","members":{"NextToken":{"location":"querystring","locationName":"NextToken"},"PageSize":{"location":"querystring","locationName":"PageSize","type":"integer"}}},"output":{"type":"structure","required":["DeliverabilityTestReports"],"members":{"DeliverabilityTestReports":{"type":"list","member":{"shape":"S35"}},"NextToken":{}}}},"ListDomainDeliverabilityCampaigns":{"http":{"method":"GET","requestUri":"/v1/email/deliverability-dashboard/domains/{SubscribedDomain}/campaigns"},"input":{"type":"structure","required":["StartDate","EndDate","SubscribedDomain"],"members":{"StartDate":{"location":"querystring","locationName":"StartDate","type":"timestamp"},"EndDate":{"location":"querystring","locationName":"EndDate","type":"timestamp"},"SubscribedDomain":{"location":"uri","locationName":"SubscribedDomain"},"NextToken":{"location":"querystring","locationName":"NextToken"},"PageSize":{"location":"querystring","locationName":"PageSize","type":"integer"}}},"output":{"type":"structure","required":["DomainDeliverabilityCampaigns"],"members":{"DomainDeliverabilityCampaigns":{"type":"list","member":{"shape":"S3f"}},"NextToken":{}}}},"ListEmailIdentities":{"http":{"method":"GET","requestUri":"/v1/email/identities"},"input":{"type":"structure","members":{"NextToken":{"location":"querystring","locationName":"NextToken"},"PageSize":{"location":"querystring","locationName":"PageSize","type":"integer"}}},"output":{"type":"structure","members":{"EmailIdentities":{"type":"list","member":{"type":"structure","members":{"IdentityType":{},"IdentityName":{},"SendingEnabled":{"type":"boolean"}}}},"NextToken":{}}}},"ListTagsForResource":{"http":{"method":"GET","requestUri":"/v1/email/tags"},"input":{"type":"structure","required":["ResourceArn"],"members":{"ResourceArn":{"location":"querystring","locationName":"ResourceArn"}}},"output":{"type":"structure","required":["Tags"],"members":{"Tags":{"shape":"Sc"}}}},"PutAccountDedicatedIpWarmupAttributes":{"http":{"method":"PUT","requestUri":"/v1/email/account/dedicated-ips/warmup"},"input":{"type":"structure","members":{"AutoWarmupEnabled":{"type":"boolean"}}},"output":{"type":"structure","members":{}}},"PutAccountSendingAttributes":{"http":{"method":"PUT","requestUri":"/v1/email/account/sending"},"input":{"type":"structure","members":{"SendingEnabled":{"type":"boolean"}}},"output":{"type":"structure","members":{}}},"PutConfigurationSetDeliveryOptions":{"http":{"method":"PUT","requestUri":"/v1/email/configuration-sets/{ConfigurationSetName}/delivery-options"},"input":{"type":"structure","required":["ConfigurationSetName"],"members":{"ConfigurationSetName":{"location":"uri","locationName":"ConfigurationSetName"},"TlsPolicy":{},"SendingPoolName":{}}},"output":{"type":"structure","members":{}}},"PutConfigurationSetReputationOptions":{"http":{"method":"PUT","requestUri":"/v1/email/configuration-sets/{ConfigurationSetName}/reputation-options"},"input":{"type":"structure","required":["ConfigurationSetName"],"members":{"ConfigurationSetName":{"location":"uri","locationName":"ConfigurationSetName"},"ReputationMetricsEnabled":{"type":"boolean"}}},"output":{"type":"structure","members":{}}},"PutConfigurationSetSendingOptions":{"http":{"method":"PUT","requestUri":"/v1/email/configuration-sets/{ConfigurationSetName}/sending"},"input":{"type":"structure","required":["ConfigurationSetName"],"members":{"ConfigurationSetName":{"location":"uri","locationName":"ConfigurationSetName"},"SendingEnabled":{"type":"boolean"}}},"output":{"type":"structure","members":{}}},"PutConfigurationSetTrackingOptions":{"http":{"method":"PUT","requestUri":"/v1/email/configuration-sets/{ConfigurationSetName}/tracking-options"},"input":{"type":"structure","required":["ConfigurationSetName"],"members":{"ConfigurationSetName":{"location":"uri","locationName":"ConfigurationSetName"},"CustomRedirectDomain":{}}},"output":{"type":"structure","members":{}}},"PutDedicatedIpInPool":{"http":{"method":"PUT","requestUri":"/v1/email/dedicated-ips/{IP}/pool"},"input":{"type":"structure","required":["Ip","DestinationPoolName"],"members":{"Ip":{"location":"uri","locationName":"IP"},"DestinationPoolName":{}}},"output":{"type":"structure","members":{}}},"PutDedicatedIpWarmupAttributes":{"http":{"method":"PUT","requestUri":"/v1/email/dedicated-ips/{IP}/warmup"},"input":{"type":"structure","required":["Ip","WarmupPercentage"],"members":{"Ip":{"location":"uri","locationName":"IP"},"WarmupPercentage":{"type":"integer"}}},"output":{"type":"structure","members":{}}},"PutDeliverabilityDashboardOption":{"http":{"method":"PUT","requestUri":"/v1/email/deliverability-dashboard"},"input":{"type":"structure","required":["DashboardEnabled"],"members":{"DashboardEnabled":{"type":"boolean"},"SubscribedDomains":{"shape":"S2x"}}},"output":{"type":"structure","members":{}}},"PutEmailIdentityDkimAttributes":{"http":{"method":"PUT","requestUri":"/v1/email/identities/{EmailIdentity}/dkim"},"input":{"type":"structure","required":["EmailIdentity"],"members":{"EmailIdentity":{"location":"uri","locationName":"EmailIdentity"},"SigningEnabled":{"type":"boolean"}}},"output":{"type":"structure","members":{}}},"PutEmailIdentityFeedbackAttributes":{"http":{"method":"PUT","requestUri":"/v1/email/identities/{EmailIdentity}/feedback"},"input":{"type":"structure","required":["EmailIdentity"],"members":{"EmailIdentity":{"location":"uri","locationName":"EmailIdentity"},"EmailForwardingEnabled":{"type":"boolean"}}},"output":{"type":"structure","members":{}}},"PutEmailIdentityMailFromAttributes":{"http":{"method":"PUT","requestUri":"/v1/email/identities/{EmailIdentity}/mail-from"},"input":{"type":"structure","required":["EmailIdentity"],"members":{"EmailIdentity":{"location":"uri","locationName":"EmailIdentity"},"MailFromDomain":{},"BehaviorOnMxFailure":{}}},"output":{"type":"structure","members":{}}},"SendEmail":{"http":{"requestUri":"/v1/email/outbound-emails"},"input":{"type":"structure","required":["Destination","Content"],"members":{"FromEmailAddress":{},"Destination":{"type":"structure","members":{"ToAddresses":{"shape":"S59"},"CcAddresses":{"shape":"S59"},"BccAddresses":{"shape":"S59"}}},"ReplyToAddresses":{"shape":"S59"},"FeedbackForwardingEmailAddress":{},"Content":{"shape":"S12"},"EmailTags":{"type":"list","member":{"type":"structure","required":["Name","Value"],"members":{"Name":{},"Value":{}}}},"ConfigurationSetName":{}}},"output":{"type":"structure","members":{"MessageId":{}}}},"TagResource":{"http":{"requestUri":"/v1/email/tags"},"input":{"type":"structure","required":["ResourceArn","Tags"],"members":{"ResourceArn":{},"Tags":{"shape":"Sc"}}},"output":{"type":"structure","members":{}}},"UntagResource":{"http":{"method":"DELETE","requestUri":"/v1/email/tags"},"input":{"type":"structure","required":["ResourceArn","TagKeys"],"members":{"ResourceArn":{"location":"querystring","locationName":"ResourceArn"},"TagKeys":{"location":"querystring","locationName":"TagKeys","type":"list","member":{}}}},"output":{"type":"structure","members":{}}},"UpdateConfigurationSetEventDestination":{"http":{"method":"PUT","requestUri":"/v1/email/configuration-sets/{ConfigurationSetName}/event-destinations/{EventDestinationName}"},"input":{"type":"structure","required":["ConfigurationSetName","EventDestinationName","EventDestination"],"members":{"ConfigurationSetName":{"location":"uri","locationName":"ConfigurationSetName"},"EventDestinationName":{"location":"uri","locationName":"EventDestinationName"},"EventDestination":{"shape":"Sj"}}},"output":{"type":"structure","members":{}}}},"shapes":{"S3":{"type":"structure","required":["CustomRedirectDomain"],"members":{"CustomRedirectDomain":{}}},"S5":{"type":"structure","members":{"TlsPolicy":{},"SendingPoolName":{}}},"S8":{"type":"structure","members":{"ReputationMetricsEnabled":{"type":"boolean"},"LastFreshStart":{"type":"timestamp"}}},"Sb":{"type":"structure","members":{"SendingEnabled":{"type":"boolean"}}},"Sc":{"type":"list","member":{"type":"structure","required":["Key","Value"],"members":{"Key":{},"Value":{}}}},"Sj":{"type":"structure","members":{"Enabled":{"type":"boolean"},"MatchingEventTypes":{"shape":"Sk"},"KinesisFirehoseDestination":{"shape":"Sm"},"CloudWatchDestination":{"shape":"So"},"SnsDestination":{"shape":"Su"},"PinpointDestination":{"shape":"Sv"}}},"Sk":{"type":"list","member":{}},"Sm":{"type":"structure","required":["IamRoleArn","DeliveryStreamArn"],"members":{"IamRoleArn":{},"DeliveryStreamArn":{}}},"So":{"type":"structure","required":["DimensionConfigurations"],"members":{"DimensionConfigurations":{"type":"list","member":{"type":"structure","required":["DimensionName","DimensionValueSource","DefaultDimensionValue"],"members":{"DimensionName":{},"DimensionValueSource":{},"DefaultDimensionValue":{}}}}}},"Su":{"type":"structure","required":["TopicArn"],"members":{"TopicArn":{}}},"Sv":{"type":"structure","members":{"ApplicationArn":{}}},"S12":{"type":"structure","members":{"Simple":{"type":"structure","required":["Subject","Body"],"members":{"Subject":{"shape":"S14"},"Body":{"type":"structure","members":{"Text":{"shape":"S14"},"Html":{"shape":"S14"}}}}},"Raw":{"type":"structure","required":["Data"],"members":{"Data":{"type":"blob"}}},"Template":{"type":"structure","members":{"TemplateArn":{},"TemplateData":{}}}}},"S14":{"type":"structure","required":["Data"],"members":{"Data":{},"Charset":{}}},"S1k":{"type":"structure","members":{"SigningEnabled":{"type":"boolean"},"Status":{},"Tokens":{"type":"list","member":{}}}},"S2m":{"type":"structure","required":["Ip","WarmupStatus","WarmupPercentage"],"members":{"Ip":{},"WarmupStatus":{},"WarmupPercentage":{"type":"integer"},"PoolName":{}}},"S2x":{"type":"list","member":{"type":"structure","members":{"Domain":{},"SubscriptionStartDate":{"type":"timestamp"},"InboxPlacementTrackingOption":{"type":"structure","members":{"Global":{"type":"boolean"},"TrackedIsps":{"type":"list","member":{}}}}}}},"S35":{"type":"structure","members":{"ReportId":{},"ReportName":{},"Subject":{},"FromEmailAddress":{},"CreateDate":{"type":"timestamp"},"DeliverabilityTestStatus":{}}},"S37":{"type":"structure","members":{"InboxPercentage":{"type":"double"},"SpamPercentage":{"type":"double"},"MissingPercentage":{"type":"double"},"SpfPercentage":{"type":"double"},"DkimPercentage":{"type":"double"}}},"S3f":{"type":"structure","members":{"CampaignId":{},"ImageUrl":{},"Subject":{},"FromAddress":{},"SendingIps":{"type":"list","member":{}},"FirstSeenDateTime":{"type":"timestamp"},"LastSeenDateTime":{"type":"timestamp"},"InboxCount":{"type":"long"},"SpamCount":{"type":"long"},"ReadRate":{"type":"double"},"DeleteRate":{"type":"double"},"ReadDeleteRate":{"type":"double"},"ProjectedVolume":{"type":"long"},"Esps":{"type":"list","member":{}}}},"S3p":{"type":"structure","members":{"InboxRawCount":{"type":"long"},"SpamRawCount":{"type":"long"},"ProjectedInbox":{"type":"long"},"ProjectedSpam":{"type":"long"}}},"S3q":{"type":"list","member":{"type":"structure","members":{"IspName":{},"InboxRawCount":{"type":"long"},"SpamRawCount":{"type":"long"},"InboxPercentage":{"type":"double"},"SpamPercentage":{"type":"double"}}}},"S59":{"type":"list","member":{}}}}; +const NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY = "AWS_AUTH_SCHEME_PREFERENCE"; +const NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY = "auth_scheme_preference"; +const NODE_AUTH_SCHEME_PREFERENCE_OPTIONS = { + environmentVariableSelector: (env, options) => { + if (options?.signingName) { + const bearerTokenKey = getBearerTokenEnvKey(options.signingName); + if (bearerTokenKey in env) + return ["httpBearerAuth"]; + } + if (!(NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY in env)) + return undefined; + return getArrayForCommaSeparatedString(env[NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY]); + }, + configFileSelector: (profile) => { + if (!(NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY in profile)) + return undefined; + return getArrayForCommaSeparatedString(profile[NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY]); + }, + default: [], +}; -/***/ }), +const resolveAwsSdkSigV4AConfig = (config) => { + config.sigv4aSigningRegionSet = core.normalizeProvider(config.sigv4aSigningRegionSet); + return config; +}; +const NODE_SIGV4A_CONFIG_OPTIONS = { + environmentVariableSelector(env) { + if (env.AWS_SIGV4A_SIGNING_REGION_SET) { + return env.AWS_SIGV4A_SIGNING_REGION_SET.split(",").map((_) => _.trim()); + } + throw new propertyProvider.ProviderError("AWS_SIGV4A_SIGNING_REGION_SET not set in env.", { + tryNextLink: true, + }); + }, + configFileSelector(profile) { + if (profile.sigv4a_signing_region_set) { + return (profile.sigv4a_signing_region_set ?? "").split(",").map((_) => _.trim()); + } + throw new propertyProvider.ProviderError("sigv4a_signing_region_set not set in profile.", { + tryNextLink: true, + }); + }, + default: undefined, +}; -/***/ 1273: -/***/ (function(module) { - -module.exports = {"version":2,"waiters":{"CertificateAuthorityCSRCreated":{"description":"Wait until a Certificate Authority CSR is created","operation":"GetCertificateAuthorityCsr","delay":3,"maxAttempts":60,"acceptors":[{"state":"success","matcher":"status","expected":200},{"state":"retry","matcher":"error","expected":"RequestInProgressException"}]},"CertificateIssued":{"description":"Wait until a certificate is issued","operation":"GetCertificate","delay":3,"maxAttempts":60,"acceptors":[{"state":"success","matcher":"status","expected":200},{"state":"retry","matcher":"error","expected":"RequestInProgressException"}]},"AuditReportCreated":{"description":"Wait until a Audit Report is created","operation":"DescribeCertificateAuthorityAuditReport","delay":3,"maxAttempts":60,"acceptors":[{"state":"success","matcher":"path","argument":"AuditReportStatus","expected":"SUCCESS"},{"state":"failure","matcher":"path","argument":"AuditReportStatus","expected":"FAILED"}]}}}; - -/***/ }), - -/***/ 1275: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['kafka'] = {}; -AWS.Kafka = Service.defineService('kafka', ['2018-11-14']); -Object.defineProperty(apiLoader.services['kafka'], '2018-11-14', { - get: function get() { - var model = __webpack_require__(2304); - model.paginators = __webpack_require__(1957).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.Kafka; - - -/***/ }), - -/***/ 1283: -/***/ (function(module) { - -module.exports = {"pagination":{"GetExclusionsPreview":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"ListAssessmentRunAgents":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"ListAssessmentRuns":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"ListAssessmentTargets":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"ListAssessmentTemplates":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"ListEventSubscriptions":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"ListExclusions":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"ListFindings":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"ListRulesPackages":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"PreviewAgents":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"}}}; +const resolveAwsSdkSigV4Config = (config) => { + let inputCredentials = config.credentials; + let isUserSupplied = !!config.credentials; + let resolvedCredentials = undefined; + Object.defineProperty(config, "credentials", { + set(credentials) { + if (credentials && credentials !== inputCredentials && credentials !== resolvedCredentials) { + isUserSupplied = true; + } + inputCredentials = credentials; + const memoizedProvider = normalizeCredentialProvider(config, { + credentials: inputCredentials, + credentialDefaultProvider: config.credentialDefaultProvider, + }); + const boundProvider = bindCallerConfig(config, memoizedProvider); + if (isUserSupplied && !boundProvider.attributed) { + resolvedCredentials = async (options) => boundProvider(options).then((creds) => client.setCredentialFeature(creds, "CREDENTIALS_CODE", "e")); + resolvedCredentials.memoized = boundProvider.memoized; + resolvedCredentials.configBound = boundProvider.configBound; + resolvedCredentials.attributed = true; + } + else { + resolvedCredentials = boundProvider; + } + }, + get() { + return resolvedCredentials; + }, + enumerable: true, + configurable: true, + }); + config.credentials = inputCredentials; + const { signingEscapePath = true, systemClockOffset = config.systemClockOffset || 0, sha256, } = config; + let signer; + if (config.signer) { + signer = core.normalizeProvider(config.signer); + } + else if (config.regionInfoProvider) { + signer = () => core.normalizeProvider(config.region)() + .then(async (region) => [ + (await config.regionInfoProvider(region, { + useFipsEndpoint: await config.useFipsEndpoint(), + useDualstackEndpoint: await config.useDualstackEndpoint(), + })) || {}, + region, + ]) + .then(([regionInfo, region]) => { + const { signingRegion, signingService } = regionInfo; + config.signingRegion = config.signingRegion || signingRegion || region; + config.signingName = config.signingName || signingService || config.serviceId; + const params = { + ...config, + credentials: config.credentials, + region: config.signingRegion, + service: config.signingName, + sha256, + uriEscapePath: signingEscapePath, + }; + const SignerCtor = config.signerConstructor || signatureV4.SignatureV4; + return new SignerCtor(params); + }); + } + else { + signer = async (authScheme) => { + authScheme = Object.assign({}, { + name: "sigv4", + signingName: config.signingName || config.defaultSigningName, + signingRegion: await core.normalizeProvider(config.region)(), + properties: {}, + }, authScheme); + const signingRegion = authScheme.signingRegion; + const signingService = authScheme.signingName; + config.signingRegion = config.signingRegion || signingRegion; + config.signingName = config.signingName || signingService || config.serviceId; + const params = { + ...config, + credentials: config.credentials, + region: config.signingRegion, + service: config.signingName, + sha256, + uriEscapePath: signingEscapePath, + }; + const SignerCtor = config.signerConstructor || signatureV4.SignatureV4; + return new SignerCtor(params); + }; + } + const resolvedConfig = Object.assign(config, { + systemClockOffset, + signingEscapePath, + signer, + }); + return resolvedConfig; +}; +const resolveAWSSDKSigV4Config = resolveAwsSdkSigV4Config; +function normalizeCredentialProvider(config, { credentials, credentialDefaultProvider, }) { + let credentialsProvider; + if (credentials) { + if (!credentials?.memoized) { + credentialsProvider = core.memoizeIdentityProvider(credentials, core.isIdentityExpired, core.doesIdentityRequireRefresh); + } + else { + credentialsProvider = credentials; + } + } + else { + if (credentialDefaultProvider) { + credentialsProvider = core.normalizeProvider(credentialDefaultProvider(Object.assign({}, config, { + parentClientConfig: config, + }))); + } + else { + credentialsProvider = async () => { + throw new Error("@aws-sdk/core::resolveAwsSdkSigV4Config - `credentials` not provided and no credentialDefaultProvider was configured."); + }; + } + } + credentialsProvider.memoized = true; + return credentialsProvider; +} +function bindCallerConfig(config, credentialsProvider) { + if (credentialsProvider.configBound) { + return credentialsProvider; + } + const fn = async (options) => credentialsProvider({ ...options, callerClientConfig: config }); + fn.memoized = credentialsProvider.memoized; + fn.configBound = true; + return fn; +} -/***/ }), +class ProtocolLib { + queryCompat; + constructor(queryCompat = false) { + this.queryCompat = queryCompat; + } + resolveRestContentType(defaultContentType, inputSchema) { + const members = inputSchema.getMemberSchemas(); + const httpPayloadMember = Object.values(members).find((m) => { + return !!m.getMergedTraits().httpPayload; + }); + if (httpPayloadMember) { + const mediaType = httpPayloadMember.getMergedTraits().mediaType; + if (mediaType) { + return mediaType; + } + else if (httpPayloadMember.isStringSchema()) { + return "text/plain"; + } + else if (httpPayloadMember.isBlobSchema()) { + return "application/octet-stream"; + } + else { + return defaultContentType; + } + } + else if (!inputSchema.isUnitSchema()) { + const hasBody = Object.values(members).find((m) => { + const { httpQuery, httpQueryParams, httpHeader, httpLabel, httpPrefixHeaders } = m.getMergedTraits(); + const noPrefixHeaders = httpPrefixHeaders === void 0; + return !httpQuery && !httpQueryParams && !httpHeader && !httpLabel && noPrefixHeaders; + }); + if (hasBody) { + return defaultContentType; + } + } + } + async getErrorSchemaOrThrowBaseException(errorIdentifier, defaultNamespace, response, dataObject, metadata, getErrorSchema) { + let namespace = defaultNamespace; + let errorName = errorIdentifier; + if (errorIdentifier.includes("#")) { + [namespace, errorName] = errorIdentifier.split("#"); + } + const errorMetadata = { + $metadata: metadata, + $fault: response.statusCode < 500 ? "client" : "server", + }; + const registry = schema.TypeRegistry.for(namespace); + try { + const errorSchema = getErrorSchema?.(registry, errorName) ?? registry.getSchema(errorIdentifier); + return { errorSchema, errorMetadata }; + } + catch (e) { + dataObject.message = dataObject.message ?? dataObject.Message ?? "UnknownError"; + const synthetic = schema.TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace); + const baseExceptionSchema = synthetic.getBaseException(); + if (baseExceptionSchema) { + const ErrorCtor = synthetic.getErrorCtor(baseExceptionSchema) ?? Error; + throw this.decorateServiceException(Object.assign(new ErrorCtor({ name: errorName }), errorMetadata), dataObject); + } + throw this.decorateServiceException(Object.assign(new Error(errorName), errorMetadata), dataObject); + } + } + decorateServiceException(exception, additions = {}) { + if (this.queryCompat) { + const msg = exception.Message ?? additions.Message; + const error = smithyClient.decorateServiceException(exception, additions); + if (msg) { + error.Message = msg; + error.message = msg; + } + return error; + } + return smithyClient.decorateServiceException(exception, additions); + } + setQueryCompatError(output, response) { + const queryErrorHeader = response.headers?.["x-amzn-query-error"]; + if (output !== undefined && queryErrorHeader != null) { + const [Code, Type] = queryErrorHeader.split(";"); + const entries = Object.entries(output); + const Error = { + Code, + Type, + }; + Object.assign(output, Error); + for (const [k, v] of entries) { + Error[k] = v; + } + delete Error.__type; + output.Error = Error; + } + } + queryCompatOutput(queryCompatErrorData, errorData) { + if (queryCompatErrorData.Error) { + errorData.Error = queryCompatErrorData.Error; + } + if (queryCompatErrorData.Type) { + errorData.Type = queryCompatErrorData.Type; + } + if (queryCompatErrorData.Code) { + errorData.Code = queryCompatErrorData.Code; + } + } +} -/***/ 1287: -/***/ (function(module) { +class AwsSmithyRpcV2CborProtocol extends cbor.SmithyRpcV2CborProtocol { + awsQueryCompatible; + mixin; + constructor({ defaultNamespace, awsQueryCompatible, }) { + super({ defaultNamespace }); + this.awsQueryCompatible = !!awsQueryCompatible; + this.mixin = new ProtocolLib(this.awsQueryCompatible); + } + async serializeRequest(operationSchema, input, context) { + const request = await super.serializeRequest(operationSchema, input, context); + if (this.awsQueryCompatible) { + request.headers["x-amzn-query-mode"] = "true"; + } + return request; + } + async handleError(operationSchema, context, response, dataObject, metadata) { + if (this.awsQueryCompatible) { + this.mixin.setQueryCompatError(dataObject, response); + } + const errorName = cbor.loadSmithyRpcV2CborErrorCode(response, dataObject) ?? "Unknown"; + const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorName, this.options.defaultNamespace, response, dataObject, metadata); + const ns = schema.NormalizedSchema.of(errorSchema); + const message = dataObject.message ?? dataObject.Message ?? "Unknown"; + const ErrorCtor = schema.TypeRegistry.for(errorSchema[1]).getErrorCtor(errorSchema) ?? Error; + const exception = new ErrorCtor(message); + const output = {}; + for (const [name, member] of ns.structIterator()) { + output[name] = this.deserializer.readValue(member, dataObject[name]); + } + if (this.awsQueryCompatible) { + this.mixin.queryCompatOutput(dataObject, output); + } + throw this.mixin.decorateServiceException(Object.assign(exception, errorMetadata, { + $fault: ns.getMergedTraits().error, + message, + }, output), dataObject); + } +} -module.exports = {"pagination":{"ListAppliedSchemaArns":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListAttachedIndices":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListDevelopmentSchemaArns":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListDirectories":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListFacetAttributes":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListFacetNames":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListIndex":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListObjectAttributes":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListObjectChildren":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListObjectParentPaths":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListObjectParents":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListObjectPolicies":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListPolicyAttachments":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListPublishedSchemaArns":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListTagsForResource":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListTypedLinkFacetAttributes":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListTypedLinkFacetNames":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"LookupPolicy":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"}}}; +const _toStr = (val) => { + if (val == null) { + return val; + } + if (typeof val === "number" || typeof val === "bigint") { + const warning = new Error(`Received number ${val} where a string was expected.`); + warning.name = "Warning"; + console.warn(warning); + return String(val); + } + if (typeof val === "boolean") { + const warning = new Error(`Received boolean ${val} where a string was expected.`); + warning.name = "Warning"; + console.warn(warning); + return String(val); + } + return val; +}; +const _toBool = (val) => { + if (val == null) { + return val; + } + if (typeof val === "string") { + const lowercase = val.toLowerCase(); + if (val !== "" && lowercase !== "false" && lowercase !== "true") { + const warning = new Error(`Received string "${val}" where a boolean was expected.`); + warning.name = "Warning"; + console.warn(warning); + } + return val !== "" && lowercase !== "false"; + } + return val; +}; +const _toNum = (val) => { + if (val == null) { + return val; + } + if (typeof val === "string") { + const num = Number(val); + if (num.toString() !== val) { + const warning = new Error(`Received string "${val}" where a number was expected.`); + warning.name = "Warning"; + console.warn(warning); + return val; + } + return num; + } + return val; +}; -/***/ }), +class SerdeContextConfig { + serdeContext; + setSerdeContext(serdeContext) { + this.serdeContext = serdeContext; + } +} -/***/ 1291: -/***/ (function(module, __unusedexports, __webpack_require__) { +function jsonReviver(key, value, context) { + if (context?.source) { + const numericString = context.source; + if (typeof value === "number") { + if (value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER || numericString !== String(value)) { + const isFractional = numericString.includes("."); + if (isFractional) { + return new serde.NumericValue(numericString, "bigDecimal"); + } + else { + return BigInt(numericString); + } + } + } + } + return value; +} -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +const collectBodyString = (streamBody, context) => smithyClient.collectBody(streamBody, context).then((body) => (context?.utf8Encoder ?? utilUtf8.toUtf8)(body)); -apiLoader.services['iotdata'] = {}; -AWS.IotData = Service.defineService('iotdata', ['2015-05-28']); -__webpack_require__(2873); -Object.defineProperty(apiLoader.services['iotdata'], '2015-05-28', { - get: function get() { - var model = __webpack_require__(1200); - model.paginators = __webpack_require__(6010).pagination; - return model; - }, - enumerable: true, - configurable: true +const parseJsonBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => { + if (encoded.length) { + try { + return JSON.parse(encoded); + } + catch (e) { + if (e?.name === "SyntaxError") { + Object.defineProperty(e, "$responseBodyText", { + value: encoded, + }); + } + throw e; + } + } + return {}; }); +const parseJsonErrorBody = async (errorBody, context) => { + const value = await parseJsonBody(errorBody, context); + value.message = value.message ?? value.Message; + return value; +}; +const loadRestJsonErrorCode = (output, data) => { + const findKey = (object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()); + const sanitizeErrorCode = (rawValue) => { + let cleanValue = rawValue; + if (typeof cleanValue === "number") { + cleanValue = cleanValue.toString(); + } + if (cleanValue.indexOf(",") >= 0) { + cleanValue = cleanValue.split(",")[0]; + } + if (cleanValue.indexOf(":") >= 0) { + cleanValue = cleanValue.split(":")[0]; + } + if (cleanValue.indexOf("#") >= 0) { + cleanValue = cleanValue.split("#")[1]; + } + return cleanValue; + }; + const headerKey = findKey(output.headers, "x-amzn-errortype"); + if (headerKey !== undefined) { + return sanitizeErrorCode(output.headers[headerKey]); + } + if (data && typeof data === "object") { + const codeKey = findKey(data, "code"); + if (codeKey && data[codeKey] !== undefined) { + return sanitizeErrorCode(data[codeKey]); + } + if (data["__type"] !== undefined) { + return sanitizeErrorCode(data["__type"]); + } + } +}; -module.exports = AWS.IotData; - - -/***/ }), +class JsonShapeDeserializer extends SerdeContextConfig { + settings; + constructor(settings) { + super(); + this.settings = settings; + } + async read(schema, data) { + return this._read(schema, typeof data === "string" ? JSON.parse(data, jsonReviver) : await parseJsonBody(data, this.serdeContext)); + } + readObject(schema, data) { + return this._read(schema, data); + } + _read(schema$1, value) { + const isObject = value !== null && typeof value === "object"; + const ns = schema.NormalizedSchema.of(schema$1); + if (ns.isListSchema() && Array.isArray(value)) { + const listMember = ns.getValueSchema(); + const out = []; + const sparse = !!ns.getMergedTraits().sparse; + for (const item of value) { + if (sparse || item != null) { + out.push(this._read(listMember, item)); + } + } + return out; + } + else if (ns.isMapSchema() && isObject) { + const mapMember = ns.getValueSchema(); + const out = {}; + const sparse = !!ns.getMergedTraits().sparse; + for (const [_k, _v] of Object.entries(value)) { + if (sparse || _v != null) { + out[_k] = this._read(mapMember, _v); + } + } + return out; + } + else if (ns.isStructSchema() && isObject) { + const out = {}; + for (const [memberName, memberSchema] of ns.structIterator()) { + const fromKey = this.settings.jsonName ? memberSchema.getMergedTraits().jsonName ?? memberName : memberName; + const deserializedValue = this._read(memberSchema, value[fromKey]); + if (deserializedValue != null) { + out[memberName] = deserializedValue; + } + } + return out; + } + if (ns.isBlobSchema() && typeof value === "string") { + return utilBase64.fromBase64(value); + } + const mediaType = ns.getMergedTraits().mediaType; + if (ns.isStringSchema() && typeof value === "string" && mediaType) { + const isJson = mediaType === "application/json" || mediaType.endsWith("+json"); + if (isJson) { + return serde.LazyJsonString.from(value); + } + } + if (ns.isTimestampSchema() && value != null) { + const format = protocols.determineTimestampFormat(ns, this.settings); + switch (format) { + case 5: + return serde.parseRfc3339DateTimeWithOffset(value); + case 6: + return serde.parseRfc7231DateTime(value); + case 7: + return serde.parseEpochTimestamp(value); + default: + console.warn("Missing timestamp format, parsing value with Date constructor:", value); + return new Date(value); + } + } + if (ns.isBigIntegerSchema() && (typeof value === "number" || typeof value === "string")) { + return BigInt(value); + } + if (ns.isBigDecimalSchema() && value != undefined) { + if (value instanceof serde.NumericValue) { + return value; + } + const untyped = value; + if (untyped.type === "bigDecimal" && "string" in untyped) { + return new serde.NumericValue(untyped.string, untyped.type); + } + return new serde.NumericValue(String(value), "bigDecimal"); + } + if (ns.isNumericSchema() && typeof value === "string") { + switch (value) { + case "Infinity": + return Infinity; + case "-Infinity": + return -Infinity; + case "NaN": + return NaN; + } + } + if (ns.isDocumentSchema()) { + if (isObject) { + const out = Array.isArray(value) ? [] : {}; + for (const [k, v] of Object.entries(value)) { + if (v instanceof serde.NumericValue) { + out[k] = v; + } + else { + out[k] = this._read(ns, v); + } + } + return out; + } + else { + return structuredClone(value); + } + } + return value; + } +} -/***/ 1306: -/***/ (function(module) { +const NUMERIC_CONTROL_CHAR = String.fromCharCode(925); +class JsonReplacer { + values = new Map(); + counter = 0; + stage = 0; + createReplacer() { + if (this.stage === 1) { + throw new Error("@aws-sdk/core/protocols - JsonReplacer already created."); + } + if (this.stage === 2) { + throw new Error("@aws-sdk/core/protocols - JsonReplacer exhausted."); + } + this.stage = 1; + return (key, value) => { + if (value instanceof serde.NumericValue) { + const v = `${NUMERIC_CONTROL_CHAR + "nv" + this.counter++}_` + value.string; + this.values.set(`"${v}"`, value.string); + return v; + } + if (typeof value === "bigint") { + const s = value.toString(); + const v = `${NUMERIC_CONTROL_CHAR + "b" + this.counter++}_` + s; + this.values.set(`"${v}"`, s); + return v; + } + return value; + }; + } + replaceInJson(json) { + if (this.stage === 0) { + throw new Error("@aws-sdk/core/protocols - JsonReplacer not created yet."); + } + if (this.stage === 2) { + throw new Error("@aws-sdk/core/protocols - JsonReplacer exhausted."); + } + this.stage = 2; + if (this.counter === 0) { + return json; + } + for (const [key, value] of this.values) { + json = json.replace(key, value); + } + return json; + } +} -module.exports = {"version":2,"waiters":{"BucketExists":{"delay":5,"operation":"HeadBucket","maxAttempts":20,"acceptors":[{"expected":200,"matcher":"status","state":"success"},{"expected":301,"matcher":"status","state":"success"},{"expected":403,"matcher":"status","state":"success"},{"expected":404,"matcher":"status","state":"retry"}]},"BucketNotExists":{"delay":5,"operation":"HeadBucket","maxAttempts":20,"acceptors":[{"expected":404,"matcher":"status","state":"success"}]},"ObjectExists":{"delay":5,"operation":"HeadObject","maxAttempts":20,"acceptors":[{"expected":200,"matcher":"status","state":"success"},{"expected":404,"matcher":"status","state":"retry"}]},"ObjectNotExists":{"delay":5,"operation":"HeadObject","maxAttempts":20,"acceptors":[{"expected":404,"matcher":"status","state":"success"}]}}}; +class JsonShapeSerializer extends SerdeContextConfig { + settings; + buffer; + rootSchema; + constructor(settings) { + super(); + this.settings = settings; + } + write(schema$1, value) { + this.rootSchema = schema.NormalizedSchema.of(schema$1); + this.buffer = this._write(this.rootSchema, value); + } + writeDiscriminatedDocument(schema$1, value) { + this.write(schema$1, value); + if (typeof this.buffer === "object") { + this.buffer.__type = schema.NormalizedSchema.of(schema$1).getName(true); + } + } + flush() { + const { rootSchema } = this; + this.rootSchema = undefined; + if (rootSchema?.isStructSchema() || rootSchema?.isDocumentSchema()) { + const replacer = new JsonReplacer(); + return replacer.replaceInJson(JSON.stringify(this.buffer, replacer.createReplacer(), 0)); + } + return this.buffer; + } + _write(schema$1, value, container) { + const isObject = value !== null && typeof value === "object"; + const ns = schema.NormalizedSchema.of(schema$1); + if (ns.isListSchema() && Array.isArray(value)) { + const listMember = ns.getValueSchema(); + const out = []; + const sparse = !!ns.getMergedTraits().sparse; + for (const item of value) { + if (sparse || item != null) { + out.push(this._write(listMember, item)); + } + } + return out; + } + else if (ns.isMapSchema() && isObject) { + const mapMember = ns.getValueSchema(); + const out = {}; + const sparse = !!ns.getMergedTraits().sparse; + for (const [_k, _v] of Object.entries(value)) { + if (sparse || _v != null) { + out[_k] = this._write(mapMember, _v); + } + } + return out; + } + else if (ns.isStructSchema() && isObject) { + const out = {}; + for (const [memberName, memberSchema] of ns.structIterator()) { + const targetKey = this.settings.jsonName ? memberSchema.getMergedTraits().jsonName ?? memberName : memberName; + const serializableValue = this._write(memberSchema, value[memberName], ns); + if (serializableValue !== undefined) { + out[targetKey] = serializableValue; + } + } + return out; + } + if (value === null && container?.isStructSchema()) { + return void 0; + } + if ((ns.isBlobSchema() && (value instanceof Uint8Array || typeof value === "string")) || + (ns.isDocumentSchema() && value instanceof Uint8Array)) { + if (ns === this.rootSchema) { + return value; + } + return (this.serdeContext?.base64Encoder ?? utilBase64.toBase64)(value); + } + if ((ns.isTimestampSchema() || ns.isDocumentSchema()) && value instanceof Date) { + const format = protocols.determineTimestampFormat(ns, this.settings); + switch (format) { + case 5: + return value.toISOString().replace(".000Z", "Z"); + case 6: + return serde.dateToUtcString(value); + case 7: + return value.getTime() / 1000; + default: + console.warn("Missing timestamp format, using epoch seconds", value); + return value.getTime() / 1000; + } + } + if (ns.isNumericSchema() && typeof value === "number") { + if (Math.abs(value) === Infinity || isNaN(value)) { + return String(value); + } + } + if (ns.isStringSchema()) { + if (typeof value === "undefined" && ns.isIdempotencyToken()) { + return serde.generateIdempotencyToken(); + } + const mediaType = ns.getMergedTraits().mediaType; + if (value != null && mediaType) { + const isJson = mediaType === "application/json" || mediaType.endsWith("+json"); + if (isJson) { + return serde.LazyJsonString.from(value); + } + } + } + if (ns.isDocumentSchema()) { + if (isObject) { + const out = Array.isArray(value) ? [] : {}; + for (const [k, v] of Object.entries(value)) { + if (v instanceof serde.NumericValue) { + out[k] = v; + } + else { + out[k] = this._write(ns, v); + } + } + return out; + } + else { + return structuredClone(value); + } + } + return value; + } +} -/***/ }), +class JsonCodec extends SerdeContextConfig { + settings; + constructor(settings) { + super(); + this.settings = settings; + } + createSerializer() { + const serializer = new JsonShapeSerializer(this.settings); + serializer.setSerdeContext(this.serdeContext); + return serializer; + } + createDeserializer() { + const deserializer = new JsonShapeDeserializer(this.settings); + deserializer.setSerdeContext(this.serdeContext); + return deserializer; + } +} -/***/ 1318: -/***/ (function(module) { +class AwsJsonRpcProtocol extends protocols.RpcProtocol { + serializer; + deserializer; + serviceTarget; + codec; + mixin; + awsQueryCompatible; + constructor({ defaultNamespace, serviceTarget, awsQueryCompatible, }) { + super({ + defaultNamespace, + }); + this.serviceTarget = serviceTarget; + this.codec = new JsonCodec({ + timestampFormat: { + useTrait: true, + default: 7, + }, + jsonName: false, + }); + this.serializer = this.codec.createSerializer(); + this.deserializer = this.codec.createDeserializer(); + this.awsQueryCompatible = !!awsQueryCompatible; + this.mixin = new ProtocolLib(this.awsQueryCompatible); + } + async serializeRequest(operationSchema, input, context) { + const request = await super.serializeRequest(operationSchema, input, context); + if (!request.path.endsWith("/")) { + request.path += "/"; + } + Object.assign(request.headers, { + "content-type": `application/x-amz-json-${this.getJsonRpcVersion()}`, + "x-amz-target": `${this.serviceTarget}.${operationSchema.name}`, + }); + if (this.awsQueryCompatible) { + request.headers["x-amzn-query-mode"] = "true"; + } + if (schema.deref(operationSchema.input) === "unit" || !request.body) { + request.body = "{}"; + } + return request; + } + getPayloadCodec() { + return this.codec; + } + async handleError(operationSchema, context, response, dataObject, metadata) { + if (this.awsQueryCompatible) { + this.mixin.setQueryCompatError(dataObject, response); + } + const errorIdentifier = loadRestJsonErrorCode(response, dataObject) ?? "Unknown"; + const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, dataObject, metadata); + const ns = schema.NormalizedSchema.of(errorSchema); + const message = dataObject.message ?? dataObject.Message ?? "Unknown"; + const ErrorCtor = schema.TypeRegistry.for(errorSchema[1]).getErrorCtor(errorSchema) ?? Error; + const exception = new ErrorCtor(message); + const output = {}; + for (const [name, member] of ns.structIterator()) { + const target = member.getMergedTraits().jsonName ?? name; + output[name] = this.codec.createDeserializer().readObject(member, dataObject[target]); + } + if (this.awsQueryCompatible) { + this.mixin.queryCompatOutput(dataObject, output); + } + throw this.mixin.decorateServiceException(Object.assign(exception, errorMetadata, { + $fault: ns.getMergedTraits().error, + message, + }, output), dataObject); + } +} -module.exports = {"pagination":{"DescribeDBEngineVersions":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DBEngineVersions"},"DescribeDBInstances":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DBInstances"},"DescribeDBLogFiles":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DescribeDBLogFiles"},"DescribeDBParameterGroups":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DBParameterGroups"},"DescribeDBParameters":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"Parameters"},"DescribeDBSecurityGroups":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DBSecurityGroups"},"DescribeDBSnapshots":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DBSnapshots"},"DescribeDBSubnetGroups":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DBSubnetGroups"},"DescribeEngineDefaultParameters":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"EngineDefaults.Marker","result_key":"EngineDefaults.Parameters"},"DescribeEventSubscriptions":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"EventSubscriptionsList"},"DescribeEvents":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"Events"},"DescribeOptionGroupOptions":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"OptionGroupOptions"},"DescribeOptionGroups":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"OptionGroupsList"},"DescribeOrderableDBInstanceOptions":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"OrderableDBInstanceOptions"},"DescribeReservedDBInstances":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"ReservedDBInstances"},"DescribeReservedDBInstancesOfferings":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"ReservedDBInstancesOfferings"},"DownloadDBLogFilePortion":{"input_token":"Marker","limit_key":"NumberOfLines","more_results":"AdditionalDataPending","output_token":"Marker","result_key":"LogFileData"},"ListTagsForResource":{"result_key":"TagList"}}}; +class AwsJson1_0Protocol extends AwsJsonRpcProtocol { + constructor({ defaultNamespace, serviceTarget, awsQueryCompatible, }) { + super({ + defaultNamespace, + serviceTarget, + awsQueryCompatible, + }); + } + getShapeId() { + return "aws.protocols#awsJson1_0"; + } + getJsonRpcVersion() { + return "1.0"; + } + getDefaultContentType() { + return "application/x-amz-json-1.0"; + } +} -/***/ }), +class AwsJson1_1Protocol extends AwsJsonRpcProtocol { + constructor({ defaultNamespace, serviceTarget, awsQueryCompatible, }) { + super({ + defaultNamespace, + serviceTarget, + awsQueryCompatible, + }); + } + getShapeId() { + return "aws.protocols#awsJson1_1"; + } + getJsonRpcVersion() { + return "1.1"; + } + getDefaultContentType() { + return "application/x-amz-json-1.1"; + } +} -/***/ 1327: -/***/ (function(module) { +class AwsRestJsonProtocol extends protocols.HttpBindingProtocol { + serializer; + deserializer; + codec; + mixin = new ProtocolLib(); + constructor({ defaultNamespace }) { + super({ + defaultNamespace, + }); + const settings = { + timestampFormat: { + useTrait: true, + default: 7, + }, + httpBindings: true, + jsonName: true, + }; + this.codec = new JsonCodec(settings); + this.serializer = new protocols.HttpInterceptingShapeSerializer(this.codec.createSerializer(), settings); + this.deserializer = new protocols.HttpInterceptingShapeDeserializer(this.codec.createDeserializer(), settings); + } + getShapeId() { + return "aws.protocols#restJson1"; + } + getPayloadCodec() { + return this.codec; + } + setSerdeContext(serdeContext) { + this.codec.setSerdeContext(serdeContext); + super.setSerdeContext(serdeContext); + } + async serializeRequest(operationSchema, input, context) { + const request = await super.serializeRequest(operationSchema, input, context); + const inputSchema = schema.NormalizedSchema.of(operationSchema.input); + if (!request.headers["content-type"]) { + const contentType = this.mixin.resolveRestContentType(this.getDefaultContentType(), inputSchema); + if (contentType) { + request.headers["content-type"] = contentType; + } + } + if (request.body == null && request.headers["content-type"] === this.getDefaultContentType()) { + request.body = "{}"; + } + return request; + } + async deserializeResponse(operationSchema, context, response) { + const output = await super.deserializeResponse(operationSchema, context, response); + const outputSchema = schema.NormalizedSchema.of(operationSchema.output); + for (const [name, member] of outputSchema.structIterator()) { + if (member.getMemberTraits().httpPayload && !(name in output)) { + output[name] = null; + } + } + return output; + } + async handleError(operationSchema, context, response, dataObject, metadata) { + const errorIdentifier = loadRestJsonErrorCode(response, dataObject) ?? "Unknown"; + const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, dataObject, metadata); + const ns = schema.NormalizedSchema.of(errorSchema); + const message = dataObject.message ?? dataObject.Message ?? "Unknown"; + const ErrorCtor = schema.TypeRegistry.for(errorSchema[1]).getErrorCtor(errorSchema) ?? Error; + const exception = new ErrorCtor(message); + await this.deserializeHttpMessage(errorSchema, context, response, dataObject); + const output = {}; + for (const [name, member] of ns.structIterator()) { + const target = member.getMergedTraits().jsonName ?? name; + output[name] = this.codec.createDeserializer().readObject(member, dataObject[target]); + } + throw this.mixin.decorateServiceException(Object.assign(exception, errorMetadata, { + $fault: ns.getMergedTraits().error, + message, + }, output), dataObject); + } + getDefaultContentType() { + return "application/json"; + } +} -module.exports = {"pagination":{"DescribeMergeConflicts":{"input_token":"nextToken","limit_key":"maxMergeHunks","output_token":"nextToken"},"DescribePullRequestEvents":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken"},"GetCommentReactions":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken"},"GetCommentsForComparedCommit":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken"},"GetCommentsForPullRequest":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken"},"GetDifferences":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"GetMergeConflicts":{"input_token":"nextToken","limit_key":"maxConflictFiles","output_token":"nextToken"},"ListApprovalRuleTemplates":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken"},"ListAssociatedApprovalRuleTemplatesForRepository":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken"},"ListBranches":{"input_token":"nextToken","output_token":"nextToken","result_key":"branches"},"ListPullRequests":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken"},"ListRepositories":{"input_token":"nextToken","output_token":"nextToken","result_key":"repositories"},"ListRepositoriesForApprovalRuleTemplate":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken"}}}; +const awsExpectUnion = (value) => { + if (value == null) { + return undefined; + } + if (typeof value === "object" && "__type" in value) { + delete value.__type; + } + return smithyClient.expectUnion(value); +}; -/***/ }), - -/***/ 1328: -/***/ (function(module) { - -module.exports = {"version":2,"waiters":{"TableExists":{"delay":20,"operation":"DescribeTable","maxAttempts":25,"acceptors":[{"expected":"ACTIVE","matcher":"path","state":"success","argument":"Table.TableStatus"},{"expected":"ResourceNotFoundException","matcher":"error","state":"retry"}]},"TableNotExists":{"delay":20,"operation":"DescribeTable","maxAttempts":25,"acceptors":[{"expected":"ResourceNotFoundException","matcher":"error","state":"success"}]}}}; +class XmlShapeDeserializer extends SerdeContextConfig { + settings; + stringDeserializer; + constructor(settings) { + super(); + this.settings = settings; + this.stringDeserializer = new protocols.FromStringShapeDeserializer(settings); + } + setSerdeContext(serdeContext) { + this.serdeContext = serdeContext; + this.stringDeserializer.setSerdeContext(serdeContext); + } + read(schema$1, bytes, key) { + const ns = schema.NormalizedSchema.of(schema$1); + const memberSchemas = ns.getMemberSchemas(); + const isEventPayload = ns.isStructSchema() && + ns.isMemberSchema() && + !!Object.values(memberSchemas).find((memberNs) => { + return !!memberNs.getMemberTraits().eventPayload; + }); + if (isEventPayload) { + const output = {}; + const memberName = Object.keys(memberSchemas)[0]; + const eventMemberSchema = memberSchemas[memberName]; + if (eventMemberSchema.isBlobSchema()) { + output[memberName] = bytes; + } + else { + output[memberName] = this.read(memberSchemas[memberName], bytes); + } + return output; + } + const xmlString = (this.serdeContext?.utf8Encoder ?? utilUtf8.toUtf8)(bytes); + const parsedObject = this.parseXml(xmlString); + return this.readSchema(schema$1, key ? parsedObject[key] : parsedObject); + } + readSchema(_schema, value) { + const ns = schema.NormalizedSchema.of(_schema); + if (ns.isUnitSchema()) { + return; + } + const traits = ns.getMergedTraits(); + if (ns.isListSchema() && !Array.isArray(value)) { + return this.readSchema(ns, [value]); + } + if (value == null) { + return value; + } + if (typeof value === "object") { + const sparse = !!traits.sparse; + const flat = !!traits.xmlFlattened; + if (ns.isListSchema()) { + const listValue = ns.getValueSchema(); + const buffer = []; + const sourceKey = listValue.getMergedTraits().xmlName ?? "member"; + const source = flat ? value : (value[0] ?? value)[sourceKey]; + const sourceArray = Array.isArray(source) ? source : [source]; + for (const v of sourceArray) { + if (v != null || sparse) { + buffer.push(this.readSchema(listValue, v)); + } + } + return buffer; + } + const buffer = {}; + if (ns.isMapSchema()) { + const keyNs = ns.getKeySchema(); + const memberNs = ns.getValueSchema(); + let entries; + if (flat) { + entries = Array.isArray(value) ? value : [value]; + } + else { + entries = Array.isArray(value.entry) ? value.entry : [value.entry]; + } + const keyProperty = keyNs.getMergedTraits().xmlName ?? "key"; + const valueProperty = memberNs.getMergedTraits().xmlName ?? "value"; + for (const entry of entries) { + const key = entry[keyProperty]; + const value = entry[valueProperty]; + if (value != null || sparse) { + buffer[key] = this.readSchema(memberNs, value); + } + } + return buffer; + } + if (ns.isStructSchema()) { + for (const [memberName, memberSchema] of ns.structIterator()) { + const memberTraits = memberSchema.getMergedTraits(); + const xmlObjectKey = !memberTraits.httpPayload + ? memberSchema.getMemberTraits().xmlName ?? memberName + : memberTraits.xmlName ?? memberSchema.getName(); + if (value[xmlObjectKey] != null) { + buffer[memberName] = this.readSchema(memberSchema, value[xmlObjectKey]); + } + } + return buffer; + } + if (ns.isDocumentSchema()) { + return value; + } + throw new Error(`@aws-sdk/core/protocols - xml deserializer unhandled schema type for ${ns.getName(true)}`); + } + if (ns.isListSchema()) { + return []; + } + if (ns.isMapSchema() || ns.isStructSchema()) { + return {}; + } + return this.stringDeserializer.read(ns, value); + } + parseXml(xml) { + if (xml.length) { + let parsedObj; + try { + parsedObj = xmlBuilder.parseXML(xml); + } + catch (e) { + if (e && typeof e === "object") { + Object.defineProperty(e, "$responseBodyText", { + value: xml, + }); + } + throw e; + } + const textNodeName = "#text"; + const key = Object.keys(parsedObj)[0]; + const parsedObjToReturn = parsedObj[key]; + if (parsedObjToReturn[textNodeName]) { + parsedObjToReturn[key] = parsedObjToReturn[textNodeName]; + delete parsedObjToReturn[textNodeName]; + } + return smithyClient.getValueFromTextNode(parsedObjToReturn); + } + return {}; + } +} -/***/ }), +class QueryShapeSerializer extends SerdeContextConfig { + settings; + buffer; + constructor(settings) { + super(); + this.settings = settings; + } + write(schema$1, value, prefix = "") { + if (this.buffer === undefined) { + this.buffer = ""; + } + const ns = schema.NormalizedSchema.of(schema$1); + if (prefix && !prefix.endsWith(".")) { + prefix += "."; + } + if (ns.isBlobSchema()) { + if (typeof value === "string" || value instanceof Uint8Array) { + this.writeKey(prefix); + this.writeValue((this.serdeContext?.base64Encoder ?? utilBase64.toBase64)(value)); + } + } + else if (ns.isBooleanSchema() || ns.isNumericSchema() || ns.isStringSchema()) { + if (value != null) { + this.writeKey(prefix); + this.writeValue(String(value)); + } + else if (ns.isIdempotencyToken()) { + this.writeKey(prefix); + this.writeValue(serde.generateIdempotencyToken()); + } + } + else if (ns.isBigIntegerSchema()) { + if (value != null) { + this.writeKey(prefix); + this.writeValue(String(value)); + } + } + else if (ns.isBigDecimalSchema()) { + if (value != null) { + this.writeKey(prefix); + this.writeValue(value instanceof serde.NumericValue ? value.string : String(value)); + } + } + else if (ns.isTimestampSchema()) { + if (value instanceof Date) { + this.writeKey(prefix); + const format = protocols.determineTimestampFormat(ns, this.settings); + switch (format) { + case 5: + this.writeValue(value.toISOString().replace(".000Z", "Z")); + break; + case 6: + this.writeValue(smithyClient.dateToUtcString(value)); + break; + case 7: + this.writeValue(String(value.getTime() / 1000)); + break; + } + } + } + else if (ns.isDocumentSchema()) { + throw new Error(`@aws-sdk/core/protocols - QuerySerializer unsupported document type ${ns.getName(true)}`); + } + else if (ns.isListSchema()) { + if (Array.isArray(value)) { + if (value.length === 0) { + if (this.settings.serializeEmptyLists) { + this.writeKey(prefix); + this.writeValue(""); + } + } + else { + const member = ns.getValueSchema(); + const flat = this.settings.flattenLists || ns.getMergedTraits().xmlFlattened; + let i = 1; + for (const item of value) { + if (item == null) { + continue; + } + const suffix = this.getKey("member", member.getMergedTraits().xmlName); + const key = flat ? `${prefix}${i}` : `${prefix}${suffix}.${i}`; + this.write(member, item, key); + ++i; + } + } + } + } + else if (ns.isMapSchema()) { + if (value && typeof value === "object") { + const keySchema = ns.getKeySchema(); + const memberSchema = ns.getValueSchema(); + const flat = ns.getMergedTraits().xmlFlattened; + let i = 1; + for (const [k, v] of Object.entries(value)) { + if (v == null) { + continue; + } + const keySuffix = this.getKey("key", keySchema.getMergedTraits().xmlName); + const key = flat ? `${prefix}${i}.${keySuffix}` : `${prefix}entry.${i}.${keySuffix}`; + const valueSuffix = this.getKey("value", memberSchema.getMergedTraits().xmlName); + const valueKey = flat ? `${prefix}${i}.${valueSuffix}` : `${prefix}entry.${i}.${valueSuffix}`; + this.write(keySchema, k, key); + this.write(memberSchema, v, valueKey); + ++i; + } + } + } + else if (ns.isStructSchema()) { + if (value && typeof value === "object") { + for (const [memberName, member] of ns.structIterator()) { + if (value[memberName] == null && !member.isIdempotencyToken()) { + continue; + } + const suffix = this.getKey(memberName, member.getMergedTraits().xmlName); + const key = `${prefix}${suffix}`; + this.write(member, value[memberName], key); + } + } + } + else if (ns.isUnitSchema()) ; + else { + throw new Error(`@aws-sdk/core/protocols - QuerySerializer unrecognized schema type ${ns.getName(true)}`); + } + } + flush() { + if (this.buffer === undefined) { + throw new Error("@aws-sdk/core/protocols - QuerySerializer cannot flush with nothing written to buffer."); + } + const str = this.buffer; + delete this.buffer; + return str; + } + getKey(memberName, xmlName) { + const key = xmlName ?? memberName; + if (this.settings.capitalizeKeys) { + return key[0].toUpperCase() + key.slice(1); + } + return key; + } + writeKey(key) { + if (key.endsWith(".")) { + key = key.slice(0, key.length - 1); + } + this.buffer += `&${protocols.extendedEncodeURIComponent(key)}=`; + } + writeValue(value) { + this.buffer += protocols.extendedEncodeURIComponent(value); + } +} -/***/ 1340: -/***/ (function(module) { +class AwsQueryProtocol extends protocols.RpcProtocol { + options; + serializer; + deserializer; + mixin = new ProtocolLib(); + constructor(options) { + super({ + defaultNamespace: options.defaultNamespace, + }); + this.options = options; + const settings = { + timestampFormat: { + useTrait: true, + default: 5, + }, + httpBindings: false, + xmlNamespace: options.xmlNamespace, + serviceNamespace: options.defaultNamespace, + serializeEmptyLists: true, + }; + this.serializer = new QueryShapeSerializer(settings); + this.deserializer = new XmlShapeDeserializer(settings); + } + getShapeId() { + return "aws.protocols#awsQuery"; + } + setSerdeContext(serdeContext) { + this.serializer.setSerdeContext(serdeContext); + this.deserializer.setSerdeContext(serdeContext); + } + getPayloadCodec() { + throw new Error("AWSQuery protocol has no payload codec."); + } + async serializeRequest(operationSchema, input, context) { + const request = await super.serializeRequest(operationSchema, input, context); + if (!request.path.endsWith("/")) { + request.path += "/"; + } + Object.assign(request.headers, { + "content-type": `application/x-www-form-urlencoded`, + }); + if (schema.deref(operationSchema.input) === "unit" || !request.body) { + request.body = ""; + } + const action = operationSchema.name.split("#")[1] ?? operationSchema.name; + request.body = `Action=${action}&Version=${this.options.version}` + request.body; + if (request.body.endsWith("&")) { + request.body = request.body.slice(-1); + } + return request; + } + async deserializeResponse(operationSchema, context, response) { + const deserializer = this.deserializer; + const ns = schema.NormalizedSchema.of(operationSchema.output); + const dataObject = {}; + if (response.statusCode >= 300) { + const bytes = await protocols.collectBody(response.body, context); + if (bytes.byteLength > 0) { + Object.assign(dataObject, await deserializer.read(15, bytes)); + } + await this.handleError(operationSchema, context, response, dataObject, this.deserializeMetadata(response)); + } + for (const header in response.headers) { + const value = response.headers[header]; + delete response.headers[header]; + response.headers[header.toLowerCase()] = value; + } + const shortName = operationSchema.name.split("#")[1] ?? operationSchema.name; + const awsQueryResultKey = ns.isStructSchema() && this.useNestedResult() ? shortName + "Result" : undefined; + const bytes = await protocols.collectBody(response.body, context); + if (bytes.byteLength > 0) { + Object.assign(dataObject, await deserializer.read(ns, bytes, awsQueryResultKey)); + } + const output = { + $metadata: this.deserializeMetadata(response), + ...dataObject, + }; + return output; + } + useNestedResult() { + return true; + } + async handleError(operationSchema, context, response, dataObject, metadata) { + const errorIdentifier = this.loadQueryErrorCode(response, dataObject) ?? "Unknown"; + const errorData = this.loadQueryError(dataObject); + const message = this.loadQueryErrorMessage(dataObject); + errorData.message = message; + errorData.Error = { + Type: errorData.Type, + Code: errorData.Code, + Message: message, + }; + const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, errorData, metadata, (registry, errorName) => { + try { + return registry.getSchema(errorName); + } + catch (e) { + return registry.find((schema$1) => schema.NormalizedSchema.of(schema$1).getMergedTraits().awsQueryError?.[0] === errorName); + } + }); + const ns = schema.NormalizedSchema.of(errorSchema); + const ErrorCtor = schema.TypeRegistry.for(errorSchema[1]).getErrorCtor(errorSchema) ?? Error; + const exception = new ErrorCtor(message); + const output = { + Error: errorData.Error, + }; + for (const [name, member] of ns.structIterator()) { + const target = member.getMergedTraits().xmlName ?? name; + const value = errorData[target] ?? dataObject[target]; + output[name] = this.deserializer.readSchema(member, value); + } + throw this.mixin.decorateServiceException(Object.assign(exception, errorMetadata, { + $fault: ns.getMergedTraits().error, + message, + }, output), dataObject); + } + loadQueryErrorCode(output, data) { + const code = (data.Errors?.[0]?.Error ?? data.Errors?.Error ?? data.Error)?.Code; + if (code !== undefined) { + return code; + } + if (output.statusCode == 404) { + return "NotFound"; + } + } + loadQueryError(data) { + return data.Errors?.[0]?.Error ?? data.Errors?.Error ?? data.Error; + } + loadQueryErrorMessage(data) { + const errorData = this.loadQueryError(data); + return errorData?.message ?? errorData?.Message ?? data.message ?? data.Message ?? "Unknown"; + } + getDefaultContentType() { + return "application/x-www-form-urlencoded"; + } +} -module.exports = {"pagination":{"DescribeCanaries":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"DescribeCanariesLastRun":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"DescribeRuntimeVersions":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"GetCanaryRuns":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"}}}; +class AwsEc2QueryProtocol extends AwsQueryProtocol { + options; + constructor(options) { + super(options); + this.options = options; + const ec2Settings = { + capitalizeKeys: true, + flattenLists: true, + serializeEmptyLists: false, + }; + Object.assign(this.serializer.settings, ec2Settings); + } + useNestedResult() { + return false; + } +} -/***/ }), +const parseXmlBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => { + if (encoded.length) { + let parsedObj; + try { + parsedObj = xmlBuilder.parseXML(encoded); + } + catch (e) { + if (e && typeof e === "object") { + Object.defineProperty(e, "$responseBodyText", { + value: encoded, + }); + } + throw e; + } + const textNodeName = "#text"; + const key = Object.keys(parsedObj)[0]; + const parsedObjToReturn = parsedObj[key]; + if (parsedObjToReturn[textNodeName]) { + parsedObjToReturn[key] = parsedObjToReturn[textNodeName]; + delete parsedObjToReturn[textNodeName]; + } + return smithyClient.getValueFromTextNode(parsedObjToReturn); + } + return {}; +}); +const parseXmlErrorBody = async (errorBody, context) => { + const value = await parseXmlBody(errorBody, context); + if (value.Error) { + value.Error.message = value.Error.message ?? value.Error.Message; + } + return value; +}; +const loadRestXmlErrorCode = (output, data) => { + if (data?.Error?.Code !== undefined) { + return data.Error.Code; + } + if (data?.Code !== undefined) { + return data.Code; + } + if (output.statusCode == 404) { + return "NotFound"; + } +}; -/***/ 1344: -/***/ (function(module) { +class XmlShapeSerializer extends SerdeContextConfig { + settings; + stringBuffer; + byteBuffer; + buffer; + constructor(settings) { + super(); + this.settings = settings; + } + write(schema$1, value) { + const ns = schema.NormalizedSchema.of(schema$1); + if (ns.isStringSchema() && typeof value === "string") { + this.stringBuffer = value; + } + else if (ns.isBlobSchema()) { + this.byteBuffer = + "byteLength" in value + ? value + : (this.serdeContext?.base64Decoder ?? utilBase64.fromBase64)(value); + } + else { + this.buffer = this.writeStruct(ns, value, undefined); + const traits = ns.getMergedTraits(); + if (traits.httpPayload && !traits.xmlName) { + this.buffer.withName(ns.getName()); + } + } + } + flush() { + if (this.byteBuffer !== undefined) { + const bytes = this.byteBuffer; + delete this.byteBuffer; + return bytes; + } + if (this.stringBuffer !== undefined) { + const str = this.stringBuffer; + delete this.stringBuffer; + return str; + } + const buffer = this.buffer; + if (this.settings.xmlNamespace) { + if (!buffer?.attributes?.["xmlns"]) { + buffer.addAttribute("xmlns", this.settings.xmlNamespace); + } + } + delete this.buffer; + return buffer.toString(); + } + writeStruct(ns, value, parentXmlns) { + const traits = ns.getMergedTraits(); + const name = ns.isMemberSchema() && !traits.httpPayload + ? ns.getMemberTraits().xmlName ?? ns.getMemberName() + : traits.xmlName ?? ns.getName(); + if (!name || !ns.isStructSchema()) { + throw new Error(`@aws-sdk/core/protocols - xml serializer, cannot write struct with empty name or non-struct, schema=${ns.getName(true)}.`); + } + const structXmlNode = xmlBuilder.XmlNode.of(name); + const [xmlnsAttr, xmlns] = this.getXmlnsAttribute(ns, parentXmlns); + for (const [memberName, memberSchema] of ns.structIterator()) { + const val = value[memberName]; + if (val != null || memberSchema.isIdempotencyToken()) { + if (memberSchema.getMergedTraits().xmlAttribute) { + structXmlNode.addAttribute(memberSchema.getMergedTraits().xmlName ?? memberName, this.writeSimple(memberSchema, val)); + continue; + } + if (memberSchema.isListSchema()) { + this.writeList(memberSchema, val, structXmlNode, xmlns); + } + else if (memberSchema.isMapSchema()) { + this.writeMap(memberSchema, val, structXmlNode, xmlns); + } + else if (memberSchema.isStructSchema()) { + structXmlNode.addChildNode(this.writeStruct(memberSchema, val, xmlns)); + } + else { + const memberNode = xmlBuilder.XmlNode.of(memberSchema.getMergedTraits().xmlName ?? memberSchema.getMemberName()); + this.writeSimpleInto(memberSchema, val, memberNode, xmlns); + structXmlNode.addChildNode(memberNode); + } + } + } + if (xmlns) { + structXmlNode.addAttribute(xmlnsAttr, xmlns); + } + return structXmlNode; + } + writeList(listMember, array, container, parentXmlns) { + if (!listMember.isMemberSchema()) { + throw new Error(`@aws-sdk/core/protocols - xml serializer, cannot write non-member list: ${listMember.getName(true)}`); + } + const listTraits = listMember.getMergedTraits(); + const listValueSchema = listMember.getValueSchema(); + const listValueTraits = listValueSchema.getMergedTraits(); + const sparse = !!listValueTraits.sparse; + const flat = !!listTraits.xmlFlattened; + const [xmlnsAttr, xmlns] = this.getXmlnsAttribute(listMember, parentXmlns); + const writeItem = (container, value) => { + if (listValueSchema.isListSchema()) { + this.writeList(listValueSchema, Array.isArray(value) ? value : [value], container, xmlns); + } + else if (listValueSchema.isMapSchema()) { + this.writeMap(listValueSchema, value, container, xmlns); + } + else if (listValueSchema.isStructSchema()) { + const struct = this.writeStruct(listValueSchema, value, xmlns); + container.addChildNode(struct.withName(flat ? listTraits.xmlName ?? listMember.getMemberName() : listValueTraits.xmlName ?? "member")); + } + else { + const listItemNode = xmlBuilder.XmlNode.of(flat ? listTraits.xmlName ?? listMember.getMemberName() : listValueTraits.xmlName ?? "member"); + this.writeSimpleInto(listValueSchema, value, listItemNode, xmlns); + container.addChildNode(listItemNode); + } + }; + if (flat) { + for (const value of array) { + if (sparse || value != null) { + writeItem(container, value); + } + } + } + else { + const listNode = xmlBuilder.XmlNode.of(listTraits.xmlName ?? listMember.getMemberName()); + if (xmlns) { + listNode.addAttribute(xmlnsAttr, xmlns); + } + for (const value of array) { + if (sparse || value != null) { + writeItem(listNode, value); + } + } + container.addChildNode(listNode); + } + } + writeMap(mapMember, map, container, parentXmlns, containerIsMap = false) { + if (!mapMember.isMemberSchema()) { + throw new Error(`@aws-sdk/core/protocols - xml serializer, cannot write non-member map: ${mapMember.getName(true)}`); + } + const mapTraits = mapMember.getMergedTraits(); + const mapKeySchema = mapMember.getKeySchema(); + const mapKeyTraits = mapKeySchema.getMergedTraits(); + const keyTag = mapKeyTraits.xmlName ?? "key"; + const mapValueSchema = mapMember.getValueSchema(); + const mapValueTraits = mapValueSchema.getMergedTraits(); + const valueTag = mapValueTraits.xmlName ?? "value"; + const sparse = !!mapValueTraits.sparse; + const flat = !!mapTraits.xmlFlattened; + const [xmlnsAttr, xmlns] = this.getXmlnsAttribute(mapMember, parentXmlns); + const addKeyValue = (entry, key, val) => { + const keyNode = xmlBuilder.XmlNode.of(keyTag, key); + const [keyXmlnsAttr, keyXmlns] = this.getXmlnsAttribute(mapKeySchema, xmlns); + if (keyXmlns) { + keyNode.addAttribute(keyXmlnsAttr, keyXmlns); + } + entry.addChildNode(keyNode); + let valueNode = xmlBuilder.XmlNode.of(valueTag); + if (mapValueSchema.isListSchema()) { + this.writeList(mapValueSchema, val, valueNode, xmlns); + } + else if (mapValueSchema.isMapSchema()) { + this.writeMap(mapValueSchema, val, valueNode, xmlns, true); + } + else if (mapValueSchema.isStructSchema()) { + valueNode = this.writeStruct(mapValueSchema, val, xmlns); + } + else { + this.writeSimpleInto(mapValueSchema, val, valueNode, xmlns); + } + entry.addChildNode(valueNode); + }; + if (flat) { + for (const [key, val] of Object.entries(map)) { + if (sparse || val != null) { + const entry = xmlBuilder.XmlNode.of(mapTraits.xmlName ?? mapMember.getMemberName()); + addKeyValue(entry, key, val); + container.addChildNode(entry); + } + } + } + else { + let mapNode; + if (!containerIsMap) { + mapNode = xmlBuilder.XmlNode.of(mapTraits.xmlName ?? mapMember.getMemberName()); + if (xmlns) { + mapNode.addAttribute(xmlnsAttr, xmlns); + } + container.addChildNode(mapNode); + } + for (const [key, val] of Object.entries(map)) { + if (sparse || val != null) { + const entry = xmlBuilder.XmlNode.of("entry"); + addKeyValue(entry, key, val); + (containerIsMap ? container : mapNode).addChildNode(entry); + } + } + } + } + writeSimple(_schema, value) { + if (null === value) { + throw new Error("@aws-sdk/core/protocols - (XML serializer) cannot write null value."); + } + const ns = schema.NormalizedSchema.of(_schema); + let nodeContents = null; + if (value && typeof value === "object") { + if (ns.isBlobSchema()) { + nodeContents = (this.serdeContext?.base64Encoder ?? utilBase64.toBase64)(value); + } + else if (ns.isTimestampSchema() && value instanceof Date) { + const format = protocols.determineTimestampFormat(ns, this.settings); + switch (format) { + case 5: + nodeContents = value.toISOString().replace(".000Z", "Z"); + break; + case 6: + nodeContents = smithyClient.dateToUtcString(value); + break; + case 7: + nodeContents = String(value.getTime() / 1000); + break; + default: + console.warn("Missing timestamp format, using http date", value); + nodeContents = smithyClient.dateToUtcString(value); + break; + } + } + else if (ns.isBigDecimalSchema() && value) { + if (value instanceof serde.NumericValue) { + return value.string; + } + return String(value); + } + else if (ns.isMapSchema() || ns.isListSchema()) { + throw new Error("@aws-sdk/core/protocols - xml serializer, cannot call _write() on List/Map schema, call writeList or writeMap() instead."); + } + else { + throw new Error(`@aws-sdk/core/protocols - xml serializer, unhandled schema type for object value and schema: ${ns.getName(true)}`); + } + } + if (ns.isBooleanSchema() || ns.isNumericSchema() || ns.isBigIntegerSchema() || ns.isBigDecimalSchema()) { + nodeContents = String(value); + } + if (ns.isStringSchema()) { + if (value === undefined && ns.isIdempotencyToken()) { + nodeContents = serde.generateIdempotencyToken(); + } + else { + nodeContents = String(value); + } + } + if (nodeContents === null) { + throw new Error(`Unhandled schema-value pair ${ns.getName(true)}=${value}`); + } + return nodeContents; + } + writeSimpleInto(_schema, value, into, parentXmlns) { + const nodeContents = this.writeSimple(_schema, value); + const ns = schema.NormalizedSchema.of(_schema); + const content = new xmlBuilder.XmlText(nodeContents); + const [xmlnsAttr, xmlns] = this.getXmlnsAttribute(ns, parentXmlns); + if (xmlns) { + into.addAttribute(xmlnsAttr, xmlns); + } + into.addChildNode(content); + } + getXmlnsAttribute(ns, parentXmlns) { + const traits = ns.getMergedTraits(); + const [prefix, xmlns] = traits.xmlNamespace ?? []; + if (xmlns && xmlns !== parentXmlns) { + return [prefix ? `xmlns:${prefix}` : "xmlns", xmlns]; + } + return [void 0, void 0]; + } +} -module.exports = {"pagination":{"ListCloudFrontOriginAccessIdentities":{"input_token":"Marker","limit_key":"MaxItems","more_results":"CloudFrontOriginAccessIdentityList.IsTruncated","output_token":"CloudFrontOriginAccessIdentityList.NextMarker","result_key":"CloudFrontOriginAccessIdentityList.Items"},"ListDistributions":{"input_token":"Marker","limit_key":"MaxItems","more_results":"DistributionList.IsTruncated","output_token":"DistributionList.NextMarker","result_key":"DistributionList.Items"},"ListInvalidations":{"input_token":"Marker","limit_key":"MaxItems","more_results":"InvalidationList.IsTruncated","output_token":"InvalidationList.NextMarker","result_key":"InvalidationList.Items"},"ListStreamingDistributions":{"input_token":"Marker","limit_key":"MaxItems","more_results":"StreamingDistributionList.IsTruncated","output_token":"StreamingDistributionList.NextMarker","result_key":"StreamingDistributionList.Items"}}}; +class XmlCodec extends SerdeContextConfig { + settings; + constructor(settings) { + super(); + this.settings = settings; + } + createSerializer() { + const serializer = new XmlShapeSerializer(this.settings); + serializer.setSerdeContext(this.serdeContext); + return serializer; + } + createDeserializer() { + const deserializer = new XmlShapeDeserializer(this.settings); + deserializer.setSerdeContext(this.serdeContext); + return deserializer; + } +} -/***/ }), +class AwsRestXmlProtocol extends protocols.HttpBindingProtocol { + codec; + serializer; + deserializer; + mixin = new ProtocolLib(); + constructor(options) { + super(options); + const settings = { + timestampFormat: { + useTrait: true, + default: 5, + }, + httpBindings: true, + xmlNamespace: options.xmlNamespace, + serviceNamespace: options.defaultNamespace, + }; + this.codec = new XmlCodec(settings); + this.serializer = new protocols.HttpInterceptingShapeSerializer(this.codec.createSerializer(), settings); + this.deserializer = new protocols.HttpInterceptingShapeDeserializer(this.codec.createDeserializer(), settings); + } + getPayloadCodec() { + return this.codec; + } + getShapeId() { + return "aws.protocols#restXml"; + } + async serializeRequest(operationSchema, input, context) { + const request = await super.serializeRequest(operationSchema, input, context); + const inputSchema = schema.NormalizedSchema.of(operationSchema.input); + if (!request.headers["content-type"]) { + const contentType = this.mixin.resolveRestContentType(this.getDefaultContentType(), inputSchema); + if (contentType) { + request.headers["content-type"] = contentType; + } + } + if (request.headers["content-type"] === this.getDefaultContentType()) { + if (typeof request.body === "string") { + request.body = '' + request.body; + } + } + return request; + } + async deserializeResponse(operationSchema, context, response) { + return super.deserializeResponse(operationSchema, context, response); + } + async handleError(operationSchema, context, response, dataObject, metadata) { + const errorIdentifier = loadRestXmlErrorCode(response, dataObject) ?? "Unknown"; + const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, dataObject, metadata); + const ns = schema.NormalizedSchema.of(errorSchema); + const message = dataObject.Error?.message ?? dataObject.Error?.Message ?? dataObject.message ?? dataObject.Message ?? "Unknown"; + const ErrorCtor = schema.TypeRegistry.for(errorSchema[1]).getErrorCtor(errorSchema) ?? Error; + const exception = new ErrorCtor(message); + await this.deserializeHttpMessage(errorSchema, context, response, dataObject); + const output = {}; + for (const [name, member] of ns.structIterator()) { + const target = member.getMergedTraits().xmlName ?? name; + const value = dataObject.Error?.[target] ?? dataObject[target]; + output[name] = this.codec.createDeserializer().readSchema(member, value); + } + throw this.mixin.decorateServiceException(Object.assign(exception, errorMetadata, { + $fault: ns.getMergedTraits().error, + message, + }, output), dataObject); + } + getDefaultContentType() { + return "application/xml"; + } +} -/***/ 1346: -/***/ (function(module) { +exports.AWSSDKSigV4Signer = AWSSDKSigV4Signer; +exports.AwsEc2QueryProtocol = AwsEc2QueryProtocol; +exports.AwsJson1_0Protocol = AwsJson1_0Protocol; +exports.AwsJson1_1Protocol = AwsJson1_1Protocol; +exports.AwsJsonRpcProtocol = AwsJsonRpcProtocol; +exports.AwsQueryProtocol = AwsQueryProtocol; +exports.AwsRestJsonProtocol = AwsRestJsonProtocol; +exports.AwsRestXmlProtocol = AwsRestXmlProtocol; +exports.AwsSdkSigV4ASigner = AwsSdkSigV4ASigner; +exports.AwsSdkSigV4Signer = AwsSdkSigV4Signer; +exports.AwsSmithyRpcV2CborProtocol = AwsSmithyRpcV2CborProtocol; +exports.JsonCodec = JsonCodec; +exports.JsonShapeDeserializer = JsonShapeDeserializer; +exports.JsonShapeSerializer = JsonShapeSerializer; +exports.NODE_AUTH_SCHEME_PREFERENCE_OPTIONS = NODE_AUTH_SCHEME_PREFERENCE_OPTIONS; +exports.NODE_SIGV4A_CONFIG_OPTIONS = NODE_SIGV4A_CONFIG_OPTIONS; +exports.XmlCodec = XmlCodec; +exports.XmlShapeDeserializer = XmlShapeDeserializer; +exports.XmlShapeSerializer = XmlShapeSerializer; +exports._toBool = _toBool; +exports._toNum = _toNum; +exports._toStr = _toStr; +exports.awsExpectUnion = awsExpectUnion; +exports.emitWarningIfUnsupportedVersion = emitWarningIfUnsupportedVersion; +exports.getBearerTokenEnvKey = getBearerTokenEnvKey; +exports.loadRestJsonErrorCode = loadRestJsonErrorCode; +exports.loadRestXmlErrorCode = loadRestXmlErrorCode; +exports.parseJsonBody = parseJsonBody; +exports.parseJsonErrorBody = parseJsonErrorBody; +exports.parseXmlBody = parseXmlBody; +exports.parseXmlErrorBody = parseXmlErrorBody; +exports.resolveAWSSDKSigV4Config = resolveAWSSDKSigV4Config; +exports.resolveAwsSdkSigV4AConfig = resolveAwsSdkSigV4AConfig; +exports.resolveAwsSdkSigV4Config = resolveAwsSdkSigV4Config; +exports.setCredentialFeature = setCredentialFeature; +exports.setFeature = setFeature; +exports.setTokenFeature = setTokenFeature; +exports.state = state; +exports.validateSigningProperties = validateSigningProperties; + + +/***/ }), + +/***/ 5152: +/***/ ((__unused_webpack_module, exports) => { -module.exports = {"pagination":{}}; +"use strict"; -/***/ }), -/***/ 1349: -/***/ (function(module, __unusedexports, __webpack_require__) { +const state = { + warningEmitted: false, +}; +const emitWarningIfUnsupportedVersion = (version) => { + if (version && !state.warningEmitted && parseInt(version.substring(1, version.indexOf("."))) < 18) { + state.warningEmitted = true; + process.emitWarning(`NodeDeprecationWarning: The AWS SDK for JavaScript (v3) will +no longer support Node.js 16.x on January 6, 2025. -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +To continue receiving updates to AWS services, bug fixes, and security +updates please upgrade to a supported Node.js LTS version. -apiLoader.services['personalizeruntime'] = {}; -AWS.PersonalizeRuntime = Service.defineService('personalizeruntime', ['2018-05-22']); -Object.defineProperty(apiLoader.services['personalizeruntime'], '2018-05-22', { - get: function get() { - var model = __webpack_require__(9370); - model.paginators = __webpack_require__(8367).pagination; - return model; - }, - enumerable: true, - configurable: true -}); +More information can be found at: https://a.co/74kJMmI`); + } +}; -module.exports = AWS.PersonalizeRuntime; +function setCredentialFeature(credentials, feature, value) { + if (!credentials.$source) { + credentials.$source = {}; + } + credentials.$source[feature] = value; + return credentials; +} +function setFeature(context, feature, value) { + if (!context.__aws_sdk_context) { + context.__aws_sdk_context = { + features: {}, + }; + } + else if (!context.__aws_sdk_context.features) { + context.__aws_sdk_context.features = {}; + } + context.__aws_sdk_context.features[feature] = value; +} -/***/ }), +function setTokenFeature(token, feature, value) { + if (!token.$source) { + token.$source = {}; + } + token.$source[feature] = value; + return token; +} -/***/ 1352: -/***/ (function(module) { +exports.emitWarningIfUnsupportedVersion = emitWarningIfUnsupportedVersion; +exports.setCredentialFeature = setCredentialFeature; +exports.setFeature = setFeature; +exports.setTokenFeature = setTokenFeature; +exports.state = state; -module.exports = {"version":"2.0","metadata":{"apiVersion":"2016-11-28","endpointPrefix":"runtime.lex","jsonVersion":"1.1","protocol":"rest-json","serviceFullName":"Amazon Lex Runtime Service","serviceId":"Lex Runtime Service","signatureVersion":"v4","signingName":"lex","uid":"runtime.lex-2016-11-28"},"operations":{"DeleteSession":{"http":{"method":"DELETE","requestUri":"/bot/{botName}/alias/{botAlias}/user/{userId}/session"},"input":{"type":"structure","required":["botName","botAlias","userId"],"members":{"botName":{"location":"uri","locationName":"botName"},"botAlias":{"location":"uri","locationName":"botAlias"},"userId":{"location":"uri","locationName":"userId"}}},"output":{"type":"structure","members":{"botName":{},"botAlias":{},"userId":{},"sessionId":{}}}},"GetSession":{"http":{"method":"GET","requestUri":"/bot/{botName}/alias/{botAlias}/user/{userId}/session/"},"input":{"type":"structure","required":["botName","botAlias","userId"],"members":{"botName":{"location":"uri","locationName":"botName"},"botAlias":{"location":"uri","locationName":"botAlias"},"userId":{"location":"uri","locationName":"userId"},"checkpointLabelFilter":{"location":"querystring","locationName":"checkpointLabelFilter"}}},"output":{"type":"structure","members":{"recentIntentSummaryView":{"shape":"Sa"},"sessionAttributes":{"shape":"Sd"},"sessionId":{},"dialogAction":{"shape":"Sh"}}}},"PostContent":{"http":{"requestUri":"/bot/{botName}/alias/{botAlias}/user/{userId}/content"},"input":{"type":"structure","required":["botName","botAlias","userId","contentType","inputStream"],"members":{"botName":{"location":"uri","locationName":"botName"},"botAlias":{"location":"uri","locationName":"botAlias"},"userId":{"location":"uri","locationName":"userId"},"sessionAttributes":{"shape":"Sl","jsonvalue":true,"location":"header","locationName":"x-amz-lex-session-attributes"},"requestAttributes":{"shape":"Sl","jsonvalue":true,"location":"header","locationName":"x-amz-lex-request-attributes"},"contentType":{"location":"header","locationName":"Content-Type"},"accept":{"location":"header","locationName":"Accept"},"inputStream":{"shape":"So"}},"payload":"inputStream"},"output":{"type":"structure","members":{"contentType":{"location":"header","locationName":"Content-Type"},"intentName":{"location":"header","locationName":"x-amz-lex-intent-name"},"slots":{"jsonvalue":true,"location":"header","locationName":"x-amz-lex-slots"},"sessionAttributes":{"jsonvalue":true,"location":"header","locationName":"x-amz-lex-session-attributes"},"sentimentResponse":{"location":"header","locationName":"x-amz-lex-sentiment"},"message":{"shape":"Si","location":"header","locationName":"x-amz-lex-message"},"messageFormat":{"location":"header","locationName":"x-amz-lex-message-format"},"dialogState":{"location":"header","locationName":"x-amz-lex-dialog-state"},"slotToElicit":{"location":"header","locationName":"x-amz-lex-slot-to-elicit"},"inputTranscript":{"location":"header","locationName":"x-amz-lex-input-transcript"},"audioStream":{"shape":"So"},"sessionId":{"location":"header","locationName":"x-amz-lex-session-id"}},"payload":"audioStream"},"authtype":"v4-unsigned-body"},"PostText":{"http":{"requestUri":"/bot/{botName}/alias/{botAlias}/user/{userId}/text"},"input":{"type":"structure","required":["botName","botAlias","userId","inputText"],"members":{"botName":{"location":"uri","locationName":"botName"},"botAlias":{"location":"uri","locationName":"botAlias"},"userId":{"location":"uri","locationName":"userId"},"sessionAttributes":{"shape":"Sd"},"requestAttributes":{"shape":"Sd"},"inputText":{"shape":"Si"}}},"output":{"type":"structure","members":{"intentName":{},"slots":{"shape":"Sd"},"sessionAttributes":{"shape":"Sd"},"message":{"shape":"Si"},"sentimentResponse":{"type":"structure","members":{"sentimentLabel":{},"sentimentScore":{}}},"messageFormat":{},"dialogState":{},"slotToElicit":{},"responseCard":{"type":"structure","members":{"version":{},"contentType":{},"genericAttachments":{"type":"list","member":{"type":"structure","members":{"title":{},"subTitle":{},"attachmentLinkUrl":{},"imageUrl":{},"buttons":{"type":"list","member":{"type":"structure","required":["text","value"],"members":{"text":{},"value":{}}}}}}}}},"sessionId":{}}}},"PutSession":{"http":{"requestUri":"/bot/{botName}/alias/{botAlias}/user/{userId}/session"},"input":{"type":"structure","required":["botName","botAlias","userId"],"members":{"botName":{"location":"uri","locationName":"botName"},"botAlias":{"location":"uri","locationName":"botAlias"},"userId":{"location":"uri","locationName":"userId"},"sessionAttributes":{"shape":"Sd"},"dialogAction":{"shape":"Sh"},"recentIntentSummaryView":{"shape":"Sa"},"accept":{"location":"header","locationName":"Accept"}}},"output":{"type":"structure","members":{"contentType":{"location":"header","locationName":"Content-Type"},"intentName":{"location":"header","locationName":"x-amz-lex-intent-name"},"slots":{"jsonvalue":true,"location":"header","locationName":"x-amz-lex-slots"},"sessionAttributes":{"jsonvalue":true,"location":"header","locationName":"x-amz-lex-session-attributes"},"message":{"shape":"Si","location":"header","locationName":"x-amz-lex-message"},"messageFormat":{"location":"header","locationName":"x-amz-lex-message-format"},"dialogState":{"location":"header","locationName":"x-amz-lex-dialog-state"},"slotToElicit":{"location":"header","locationName":"x-amz-lex-slot-to-elicit"},"audioStream":{"shape":"So"},"sessionId":{"location":"header","locationName":"x-amz-lex-session-id"}},"payload":"audioStream"}}},"shapes":{"Sa":{"type":"list","member":{"type":"structure","required":["dialogActionType"],"members":{"intentName":{},"checkpointLabel":{},"slots":{"shape":"Sd"},"confirmationStatus":{},"dialogActionType":{},"fulfillmentState":{},"slotToElicit":{}}}},"Sd":{"type":"map","key":{},"value":{},"sensitive":true},"Sh":{"type":"structure","required":["type"],"members":{"type":{},"intentName":{},"slots":{"shape":"Sd"},"slotToElicit":{},"fulfillmentState":{},"message":{"shape":"Si"},"messageFormat":{}}},"Si":{"type":"string","sensitive":true},"Sl":{"type":"string","sensitive":true},"So":{"type":"blob","streaming":true}}}; /***/ }), -/***/ 1353: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['securityhub'] = {}; -AWS.SecurityHub = Service.defineService('securityhub', ['2018-10-26']); -Object.defineProperty(apiLoader.services['securityhub'], '2018-10-26', { - get: function get() { - var model = __webpack_require__(5642); - model.paginators = __webpack_require__(3998).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.SecurityHub; - +/***/ 7288: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -/***/ }), - -/***/ 1371: -/***/ (function(module, __unusedexports, __webpack_require__) { +"use strict"; -var AWS = __webpack_require__(395); -var Translator = __webpack_require__(109); -var DynamoDBSet = __webpack_require__(3815); -/** - * The document client simplifies working with items in Amazon DynamoDB - * by abstracting away the notion of attribute values. This abstraction - * annotates native JavaScript types supplied as input parameters, as well - * as converts annotated response data to native JavaScript types. - * - * ## Marshalling Input and Unmarshalling Response Data - * - * The document client affords developers the use of native JavaScript types - * instead of `AttributeValue`s to simplify the JavaScript development - * experience with Amazon DynamoDB. JavaScript objects passed in as parameters - * are marshalled into `AttributeValue` shapes required by Amazon DynamoDB. - * Responses from DynamoDB are unmarshalled into plain JavaScript objects - * by the `DocumentClient`. The `DocumentClient`, does not accept - * `AttributeValue`s in favor of native JavaScript types. - * - * | JavaScript Type | DynamoDB AttributeValue | - * |:----------------------------------------------------------------------:|-------------------------| - * | String | S | - * | Number | N | - * | Boolean | BOOL | - * | null | NULL | - * | Array | L | - * | Object | M | - * | Buffer, File, Blob, ArrayBuffer, DataView, and JavaScript typed arrays | B | - * - * ## Support for Sets - * - * The `DocumentClient` offers a convenient way to create sets from - * JavaScript Arrays. The type of set is inferred from the first element - * in the array. DynamoDB supports string, number, and binary sets. To - * learn more about supported types see the - * [Amazon DynamoDB Data Model Documentation](http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataModel.html) - * For more information see {AWS.DynamoDB.DocumentClient.createSet} - * - */ -AWS.DynamoDB.DocumentClient = AWS.util.inherit({ - - /** - * Creates a DynamoDB document client with a set of configuration options. - * - * @option options params [map] An optional map of parameters to bind to every - * request sent by this service object. - * @option options service [AWS.DynamoDB] An optional pre-configured instance - * of the AWS.DynamoDB service object to use for requests. The object may - * bound parameters used by the document client. - * @option options convertEmptyValues [Boolean] set to true if you would like - * the document client to convert empty values (0-length strings, binary - * buffers, and sets) to be converted to NULL types when persisting to - * DynamoDB. - * @see AWS.DynamoDB.constructor - * - */ - constructor: function DocumentClient(options) { - var self = this; - self.options = options || {}; - self.configure(self.options); - }, +var cbor = __nccwpck_require__(4645); +var schema = __nccwpck_require__(6890); +var smithyClient = __nccwpck_require__(1411); +var protocols = __nccwpck_require__(3422); +var serde = __nccwpck_require__(2430); +var utilBase64 = __nccwpck_require__(8385); +var utilUtf8 = __nccwpck_require__(1577); +var xmlBuilder = __nccwpck_require__(4274); + +class ProtocolLib { + queryCompat; + constructor(queryCompat = false) { + this.queryCompat = queryCompat; + } + resolveRestContentType(defaultContentType, inputSchema) { + const members = inputSchema.getMemberSchemas(); + const httpPayloadMember = Object.values(members).find((m) => { + return !!m.getMergedTraits().httpPayload; + }); + if (httpPayloadMember) { + const mediaType = httpPayloadMember.getMergedTraits().mediaType; + if (mediaType) { + return mediaType; + } + else if (httpPayloadMember.isStringSchema()) { + return "text/plain"; + } + else if (httpPayloadMember.isBlobSchema()) { + return "application/octet-stream"; + } + else { + return defaultContentType; + } + } + else if (!inputSchema.isUnitSchema()) { + const hasBody = Object.values(members).find((m) => { + const { httpQuery, httpQueryParams, httpHeader, httpLabel, httpPrefixHeaders } = m.getMergedTraits(); + const noPrefixHeaders = httpPrefixHeaders === void 0; + return !httpQuery && !httpQueryParams && !httpHeader && !httpLabel && noPrefixHeaders; + }); + if (hasBody) { + return defaultContentType; + } + } + } + async getErrorSchemaOrThrowBaseException(errorIdentifier, defaultNamespace, response, dataObject, metadata, getErrorSchema) { + let namespace = defaultNamespace; + let errorName = errorIdentifier; + if (errorIdentifier.includes("#")) { + [namespace, errorName] = errorIdentifier.split("#"); + } + const errorMetadata = { + $metadata: metadata, + $fault: response.statusCode < 500 ? "client" : "server", + }; + const registry = schema.TypeRegistry.for(namespace); + try { + const errorSchema = getErrorSchema?.(registry, errorName) ?? registry.getSchema(errorIdentifier); + return { errorSchema, errorMetadata }; + } + catch (e) { + dataObject.message = dataObject.message ?? dataObject.Message ?? "UnknownError"; + const synthetic = schema.TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace); + const baseExceptionSchema = synthetic.getBaseException(); + if (baseExceptionSchema) { + const ErrorCtor = synthetic.getErrorCtor(baseExceptionSchema) ?? Error; + throw this.decorateServiceException(Object.assign(new ErrorCtor({ name: errorName }), errorMetadata), dataObject); + } + throw this.decorateServiceException(Object.assign(new Error(errorName), errorMetadata), dataObject); + } + } + decorateServiceException(exception, additions = {}) { + if (this.queryCompat) { + const msg = exception.Message ?? additions.Message; + const error = smithyClient.decorateServiceException(exception, additions); + if (msg) { + error.Message = msg; + error.message = msg; + } + return error; + } + return smithyClient.decorateServiceException(exception, additions); + } + setQueryCompatError(output, response) { + const queryErrorHeader = response.headers?.["x-amzn-query-error"]; + if (output !== undefined && queryErrorHeader != null) { + const [Code, Type] = queryErrorHeader.split(";"); + const entries = Object.entries(output); + const Error = { + Code, + Type, + }; + Object.assign(output, Error); + for (const [k, v] of entries) { + Error[k] = v; + } + delete Error.__type; + output.Error = Error; + } + } + queryCompatOutput(queryCompatErrorData, errorData) { + if (queryCompatErrorData.Error) { + errorData.Error = queryCompatErrorData.Error; + } + if (queryCompatErrorData.Type) { + errorData.Type = queryCompatErrorData.Type; + } + if (queryCompatErrorData.Code) { + errorData.Code = queryCompatErrorData.Code; + } + } +} - /** - * @api private - */ - configure: function configure(options) { - var self = this; - self.service = options.service; - self.bindServiceObject(options); - self.attrValue = options.attrValue = - self.service.api.operations.putItem.input.members.Item.value.shape; - }, +class AwsSmithyRpcV2CborProtocol extends cbor.SmithyRpcV2CborProtocol { + awsQueryCompatible; + mixin; + constructor({ defaultNamespace, awsQueryCompatible, }) { + super({ defaultNamespace }); + this.awsQueryCompatible = !!awsQueryCompatible; + this.mixin = new ProtocolLib(this.awsQueryCompatible); + } + async serializeRequest(operationSchema, input, context) { + const request = await super.serializeRequest(operationSchema, input, context); + if (this.awsQueryCompatible) { + request.headers["x-amzn-query-mode"] = "true"; + } + return request; + } + async handleError(operationSchema, context, response, dataObject, metadata) { + if (this.awsQueryCompatible) { + this.mixin.setQueryCompatError(dataObject, response); + } + const errorName = cbor.loadSmithyRpcV2CborErrorCode(response, dataObject) ?? "Unknown"; + const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorName, this.options.defaultNamespace, response, dataObject, metadata); + const ns = schema.NormalizedSchema.of(errorSchema); + const message = dataObject.message ?? dataObject.Message ?? "Unknown"; + const ErrorCtor = schema.TypeRegistry.for(errorSchema[1]).getErrorCtor(errorSchema) ?? Error; + const exception = new ErrorCtor(message); + const output = {}; + for (const [name, member] of ns.structIterator()) { + output[name] = this.deserializer.readValue(member, dataObject[name]); + } + if (this.awsQueryCompatible) { + this.mixin.queryCompatOutput(dataObject, output); + } + throw this.mixin.decorateServiceException(Object.assign(exception, errorMetadata, { + $fault: ns.getMergedTraits().error, + message, + }, output), dataObject); + } +} - /** - * @api private - */ - bindServiceObject: function bindServiceObject(options) { - var self = this; - options = options || {}; +const _toStr = (val) => { + if (val == null) { + return val; + } + if (typeof val === "number" || typeof val === "bigint") { + const warning = new Error(`Received number ${val} where a string was expected.`); + warning.name = "Warning"; + console.warn(warning); + return String(val); + } + if (typeof val === "boolean") { + const warning = new Error(`Received boolean ${val} where a string was expected.`); + warning.name = "Warning"; + console.warn(warning); + return String(val); + } + return val; +}; +const _toBool = (val) => { + if (val == null) { + return val; + } + if (typeof val === "string") { + const lowercase = val.toLowerCase(); + if (val !== "" && lowercase !== "false" && lowercase !== "true") { + const warning = new Error(`Received string "${val}" where a boolean was expected.`); + warning.name = "Warning"; + console.warn(warning); + } + return val !== "" && lowercase !== "false"; + } + return val; +}; +const _toNum = (val) => { + if (val == null) { + return val; + } + if (typeof val === "string") { + const num = Number(val); + if (num.toString() !== val) { + const warning = new Error(`Received string "${val}" where a number was expected.`); + warning.name = "Warning"; + console.warn(warning); + return val; + } + return num; + } + return val; +}; - if (!self.service) { - self.service = new AWS.DynamoDB(options); - } else { - var config = AWS.util.copy(self.service.config); - self.service = new self.service.constructor.__super__(config); - self.service.config.params = - AWS.util.merge(self.service.config.params || {}, options.params); +class SerdeContextConfig { + serdeContext; + setSerdeContext(serdeContext) { + this.serdeContext = serdeContext; } - }, +} - /** - * @api private - */ - makeServiceRequest: function(operation, params, callback) { - var self = this; - var request = self.service[operation](params); - self.setupRequest(request); - self.setupResponse(request); - if (typeof callback === 'function') { - request.send(callback); +function jsonReviver(key, value, context) { + if (context?.source) { + const numericString = context.source; + if (typeof value === "number") { + if (value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER || numericString !== String(value)) { + const isFractional = numericString.includes("."); + if (isFractional) { + return new serde.NumericValue(numericString, "bigDecimal"); + } + else { + return BigInt(numericString); + } + } + } } - return request; - }, + return value; +} - /** - * @api private - */ - serviceClientOperationsMap: { - batchGet: 'batchGetItem', - batchWrite: 'batchWriteItem', - delete: 'deleteItem', - get: 'getItem', - put: 'putItem', - query: 'query', - scan: 'scan', - update: 'updateItem', - transactGet: 'transactGetItems', - transactWrite: 'transactWriteItems' - }, +const collectBodyString = (streamBody, context) => smithyClient.collectBody(streamBody, context).then((body) => (context?.utf8Encoder ?? utilUtf8.toUtf8)(body)); - /** - * Returns the attributes of one or more items from one or more tables - * by delegating to `AWS.DynamoDB.batchGetItem()`. - * - * Supply the same parameters as {AWS.DynamoDB.batchGetItem} with - * `AttributeValue`s substituted by native JavaScript types. - * - * @see AWS.DynamoDB.batchGetItem - * @example Get items from multiple tables - * var params = { - * RequestItems: { - * 'Table-1': { - * Keys: [ - * { - * HashKey: 'haskey', - * NumberRangeKey: 1 - * } - * ] - * }, - * 'Table-2': { - * Keys: [ - * { foo: 'bar' }, - * ] - * } - * } - * }; - * - * var documentClient = new AWS.DynamoDB.DocumentClient(); - * - * documentClient.batchGet(params, function(err, data) { - * if (err) console.log(err); - * else console.log(data); - * }); - * - */ - batchGet: function(params, callback) { - var operation = this.serviceClientOperationsMap['batchGet']; - return this.makeServiceRequest(operation, params, callback); - }, +const parseJsonBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => { + if (encoded.length) { + try { + return JSON.parse(encoded); + } + catch (e) { + if (e?.name === "SyntaxError") { + Object.defineProperty(e, "$responseBodyText", { + value: encoded, + }); + } + throw e; + } + } + return {}; +}); +const parseJsonErrorBody = async (errorBody, context) => { + const value = await parseJsonBody(errorBody, context); + value.message = value.message ?? value.Message; + return value; +}; +const loadRestJsonErrorCode = (output, data) => { + const findKey = (object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()); + const sanitizeErrorCode = (rawValue) => { + let cleanValue = rawValue; + if (typeof cleanValue === "number") { + cleanValue = cleanValue.toString(); + } + if (cleanValue.indexOf(",") >= 0) { + cleanValue = cleanValue.split(",")[0]; + } + if (cleanValue.indexOf(":") >= 0) { + cleanValue = cleanValue.split(":")[0]; + } + if (cleanValue.indexOf("#") >= 0) { + cleanValue = cleanValue.split("#")[1]; + } + return cleanValue; + }; + const headerKey = findKey(output.headers, "x-amzn-errortype"); + if (headerKey !== undefined) { + return sanitizeErrorCode(output.headers[headerKey]); + } + if (data && typeof data === "object") { + const codeKey = findKey(data, "code"); + if (codeKey && data[codeKey] !== undefined) { + return sanitizeErrorCode(data[codeKey]); + } + if (data["__type"] !== undefined) { + return sanitizeErrorCode(data["__type"]); + } + } +}; - /** - * Puts or deletes multiple items in one or more tables by delegating - * to `AWS.DynamoDB.batchWriteItem()`. - * - * Supply the same parameters as {AWS.DynamoDB.batchWriteItem} with - * `AttributeValue`s substituted by native JavaScript types. - * - * @see AWS.DynamoDB.batchWriteItem - * @example Write to and delete from a table - * var params = { - * RequestItems: { - * 'Table-1': [ - * { - * DeleteRequest: { - * Key: { HashKey: 'someKey' } - * } - * }, - * { - * PutRequest: { - * Item: { - * HashKey: 'anotherKey', - * NumAttribute: 1, - * BoolAttribute: true, - * ListAttribute: [1, 'two', false], - * MapAttribute: { foo: 'bar' } - * } - * } - * } - * ] - * } - * }; - * - * var documentClient = new AWS.DynamoDB.DocumentClient(); - * - * documentClient.batchWrite(params, function(err, data) { - * if (err) console.log(err); - * else console.log(data); - * }); - * - */ - batchWrite: function(params, callback) { - var operation = this.serviceClientOperationsMap['batchWrite']; - return this.makeServiceRequest(operation, params, callback); - }, +class JsonShapeDeserializer extends SerdeContextConfig { + settings; + constructor(settings) { + super(); + this.settings = settings; + } + async read(schema, data) { + return this._read(schema, typeof data === "string" ? JSON.parse(data, jsonReviver) : await parseJsonBody(data, this.serdeContext)); + } + readObject(schema, data) { + return this._read(schema, data); + } + _read(schema$1, value) { + const isObject = value !== null && typeof value === "object"; + const ns = schema.NormalizedSchema.of(schema$1); + if (ns.isListSchema() && Array.isArray(value)) { + const listMember = ns.getValueSchema(); + const out = []; + const sparse = !!ns.getMergedTraits().sparse; + for (const item of value) { + if (sparse || item != null) { + out.push(this._read(listMember, item)); + } + } + return out; + } + else if (ns.isMapSchema() && isObject) { + const mapMember = ns.getValueSchema(); + const out = {}; + const sparse = !!ns.getMergedTraits().sparse; + for (const [_k, _v] of Object.entries(value)) { + if (sparse || _v != null) { + out[_k] = this._read(mapMember, _v); + } + } + return out; + } + else if (ns.isStructSchema() && isObject) { + const out = {}; + for (const [memberName, memberSchema] of ns.structIterator()) { + const fromKey = this.settings.jsonName ? memberSchema.getMergedTraits().jsonName ?? memberName : memberName; + const deserializedValue = this._read(memberSchema, value[fromKey]); + if (deserializedValue != null) { + out[memberName] = deserializedValue; + } + } + return out; + } + if (ns.isBlobSchema() && typeof value === "string") { + return utilBase64.fromBase64(value); + } + const mediaType = ns.getMergedTraits().mediaType; + if (ns.isStringSchema() && typeof value === "string" && mediaType) { + const isJson = mediaType === "application/json" || mediaType.endsWith("+json"); + if (isJson) { + return serde.LazyJsonString.from(value); + } + } + if (ns.isTimestampSchema() && value != null) { + const format = protocols.determineTimestampFormat(ns, this.settings); + switch (format) { + case 5: + return serde.parseRfc3339DateTimeWithOffset(value); + case 6: + return serde.parseRfc7231DateTime(value); + case 7: + return serde.parseEpochTimestamp(value); + default: + console.warn("Missing timestamp format, parsing value with Date constructor:", value); + return new Date(value); + } + } + if (ns.isBigIntegerSchema() && (typeof value === "number" || typeof value === "string")) { + return BigInt(value); + } + if (ns.isBigDecimalSchema() && value != undefined) { + if (value instanceof serde.NumericValue) { + return value; + } + const untyped = value; + if (untyped.type === "bigDecimal" && "string" in untyped) { + return new serde.NumericValue(untyped.string, untyped.type); + } + return new serde.NumericValue(String(value), "bigDecimal"); + } + if (ns.isNumericSchema() && typeof value === "string") { + switch (value) { + case "Infinity": + return Infinity; + case "-Infinity": + return -Infinity; + case "NaN": + return NaN; + } + } + if (ns.isDocumentSchema()) { + if (isObject) { + const out = Array.isArray(value) ? [] : {}; + for (const [k, v] of Object.entries(value)) { + if (v instanceof serde.NumericValue) { + out[k] = v; + } + else { + out[k] = this._read(ns, v); + } + } + return out; + } + else { + return structuredClone(value); + } + } + return value; + } +} - /** - * Deletes a single item in a table by primary key by delegating to - * `AWS.DynamoDB.deleteItem()` - * - * Supply the same parameters as {AWS.DynamoDB.deleteItem} with - * `AttributeValue`s substituted by native JavaScript types. - * - * @see AWS.DynamoDB.deleteItem - * @example Delete an item from a table - * var params = { - * TableName : 'Table', - * Key: { - * HashKey: 'hashkey', - * NumberRangeKey: 1 - * } - * }; - * - * var documentClient = new AWS.DynamoDB.DocumentClient(); - * - * documentClient.delete(params, function(err, data) { - * if (err) console.log(err); - * else console.log(data); - * }); - * - */ - delete: function(params, callback) { - var operation = this.serviceClientOperationsMap['delete']; - return this.makeServiceRequest(operation, params, callback); - }, +const NUMERIC_CONTROL_CHAR = String.fromCharCode(925); +class JsonReplacer { + values = new Map(); + counter = 0; + stage = 0; + createReplacer() { + if (this.stage === 1) { + throw new Error("@aws-sdk/core/protocols - JsonReplacer already created."); + } + if (this.stage === 2) { + throw new Error("@aws-sdk/core/protocols - JsonReplacer exhausted."); + } + this.stage = 1; + return (key, value) => { + if (value instanceof serde.NumericValue) { + const v = `${NUMERIC_CONTROL_CHAR + "nv" + this.counter++}_` + value.string; + this.values.set(`"${v}"`, value.string); + return v; + } + if (typeof value === "bigint") { + const s = value.toString(); + const v = `${NUMERIC_CONTROL_CHAR + "b" + this.counter++}_` + s; + this.values.set(`"${v}"`, s); + return v; + } + return value; + }; + } + replaceInJson(json) { + if (this.stage === 0) { + throw new Error("@aws-sdk/core/protocols - JsonReplacer not created yet."); + } + if (this.stage === 2) { + throw new Error("@aws-sdk/core/protocols - JsonReplacer exhausted."); + } + this.stage = 2; + if (this.counter === 0) { + return json; + } + for (const [key, value] of this.values) { + json = json.replace(key, value); + } + return json; + } +} - /** - * Returns a set of attributes for the item with the given primary key - * by delegating to `AWS.DynamoDB.getItem()`. - * - * Supply the same parameters as {AWS.DynamoDB.getItem} with - * `AttributeValue`s substituted by native JavaScript types. - * - * @see AWS.DynamoDB.getItem - * @example Get an item from a table - * var params = { - * TableName : 'Table', - * Key: { - * HashKey: 'hashkey' - * } - * }; - * - * var documentClient = new AWS.DynamoDB.DocumentClient(); - * - * documentClient.get(params, function(err, data) { - * if (err) console.log(err); - * else console.log(data); - * }); - * - */ - get: function(params, callback) { - var operation = this.serviceClientOperationsMap['get']; - return this.makeServiceRequest(operation, params, callback); - }, +class JsonShapeSerializer extends SerdeContextConfig { + settings; + buffer; + rootSchema; + constructor(settings) { + super(); + this.settings = settings; + } + write(schema$1, value) { + this.rootSchema = schema.NormalizedSchema.of(schema$1); + this.buffer = this._write(this.rootSchema, value); + } + writeDiscriminatedDocument(schema$1, value) { + this.write(schema$1, value); + if (typeof this.buffer === "object") { + this.buffer.__type = schema.NormalizedSchema.of(schema$1).getName(true); + } + } + flush() { + const { rootSchema } = this; + this.rootSchema = undefined; + if (rootSchema?.isStructSchema() || rootSchema?.isDocumentSchema()) { + const replacer = new JsonReplacer(); + return replacer.replaceInJson(JSON.stringify(this.buffer, replacer.createReplacer(), 0)); + } + return this.buffer; + } + _write(schema$1, value, container) { + const isObject = value !== null && typeof value === "object"; + const ns = schema.NormalizedSchema.of(schema$1); + if (ns.isListSchema() && Array.isArray(value)) { + const listMember = ns.getValueSchema(); + const out = []; + const sparse = !!ns.getMergedTraits().sparse; + for (const item of value) { + if (sparse || item != null) { + out.push(this._write(listMember, item)); + } + } + return out; + } + else if (ns.isMapSchema() && isObject) { + const mapMember = ns.getValueSchema(); + const out = {}; + const sparse = !!ns.getMergedTraits().sparse; + for (const [_k, _v] of Object.entries(value)) { + if (sparse || _v != null) { + out[_k] = this._write(mapMember, _v); + } + } + return out; + } + else if (ns.isStructSchema() && isObject) { + const out = {}; + for (const [memberName, memberSchema] of ns.structIterator()) { + const targetKey = this.settings.jsonName ? memberSchema.getMergedTraits().jsonName ?? memberName : memberName; + const serializableValue = this._write(memberSchema, value[memberName], ns); + if (serializableValue !== undefined) { + out[targetKey] = serializableValue; + } + } + return out; + } + if (value === null && container?.isStructSchema()) { + return void 0; + } + if ((ns.isBlobSchema() && (value instanceof Uint8Array || typeof value === "string")) || + (ns.isDocumentSchema() && value instanceof Uint8Array)) { + if (ns === this.rootSchema) { + return value; + } + return (this.serdeContext?.base64Encoder ?? utilBase64.toBase64)(value); + } + if ((ns.isTimestampSchema() || ns.isDocumentSchema()) && value instanceof Date) { + const format = protocols.determineTimestampFormat(ns, this.settings); + switch (format) { + case 5: + return value.toISOString().replace(".000Z", "Z"); + case 6: + return serde.dateToUtcString(value); + case 7: + return value.getTime() / 1000; + default: + console.warn("Missing timestamp format, using epoch seconds", value); + return value.getTime() / 1000; + } + } + if (ns.isNumericSchema() && typeof value === "number") { + if (Math.abs(value) === Infinity || isNaN(value)) { + return String(value); + } + } + if (ns.isStringSchema()) { + if (typeof value === "undefined" && ns.isIdempotencyToken()) { + return serde.generateIdempotencyToken(); + } + const mediaType = ns.getMergedTraits().mediaType; + if (value != null && mediaType) { + const isJson = mediaType === "application/json" || mediaType.endsWith("+json"); + if (isJson) { + return serde.LazyJsonString.from(value); + } + } + } + if (ns.isDocumentSchema()) { + if (isObject) { + const out = Array.isArray(value) ? [] : {}; + for (const [k, v] of Object.entries(value)) { + if (v instanceof serde.NumericValue) { + out[k] = v; + } + else { + out[k] = this._write(ns, v); + } + } + return out; + } + else { + return structuredClone(value); + } + } + return value; + } +} - /** - * Creates a new item, or replaces an old item with a new item by - * delegating to `AWS.DynamoDB.putItem()`. - * - * Supply the same parameters as {AWS.DynamoDB.putItem} with - * `AttributeValue`s substituted by native JavaScript types. - * - * @see AWS.DynamoDB.putItem - * @example Create a new item in a table - * var params = { - * TableName : 'Table', - * Item: { - * HashKey: 'haskey', - * NumAttribute: 1, - * BoolAttribute: true, - * ListAttribute: [1, 'two', false], - * MapAttribute: { foo: 'bar'}, - * NullAttribute: null - * } - * }; - * - * var documentClient = new AWS.DynamoDB.DocumentClient(); - * - * documentClient.put(params, function(err, data) { - * if (err) console.log(err); - * else console.log(data); - * }); - * - */ - put: function(params, callback) { - var operation = this.serviceClientOperationsMap['put']; - return this.makeServiceRequest(operation, params, callback); - }, +class JsonCodec extends SerdeContextConfig { + settings; + constructor(settings) { + super(); + this.settings = settings; + } + createSerializer() { + const serializer = new JsonShapeSerializer(this.settings); + serializer.setSerdeContext(this.serdeContext); + return serializer; + } + createDeserializer() { + const deserializer = new JsonShapeDeserializer(this.settings); + deserializer.setSerdeContext(this.serdeContext); + return deserializer; + } +} - /** - * Edits an existing item's attributes, or adds a new item to the table if - * it does not already exist by delegating to `AWS.DynamoDB.updateItem()`. - * - * Supply the same parameters as {AWS.DynamoDB.updateItem} with - * `AttributeValue`s substituted by native JavaScript types. - * - * @see AWS.DynamoDB.updateItem - * @example Update an item with expressions - * var params = { - * TableName: 'Table', - * Key: { HashKey : 'hashkey' }, - * UpdateExpression: 'set #a = :x + :y', - * ConditionExpression: '#a < :MAX', - * ExpressionAttributeNames: {'#a' : 'Sum'}, - * ExpressionAttributeValues: { - * ':x' : 20, - * ':y' : 45, - * ':MAX' : 100, - * } - * }; - * - * var documentClient = new AWS.DynamoDB.DocumentClient(); - * - * documentClient.update(params, function(err, data) { - * if (err) console.log(err); - * else console.log(data); - * }); - * - */ - update: function(params, callback) { - var operation = this.serviceClientOperationsMap['update']; - return this.makeServiceRequest(operation, params, callback); - }, +class AwsJsonRpcProtocol extends protocols.RpcProtocol { + serializer; + deserializer; + serviceTarget; + codec; + mixin; + awsQueryCompatible; + constructor({ defaultNamespace, serviceTarget, awsQueryCompatible, }) { + super({ + defaultNamespace, + }); + this.serviceTarget = serviceTarget; + this.codec = new JsonCodec({ + timestampFormat: { + useTrait: true, + default: 7, + }, + jsonName: false, + }); + this.serializer = this.codec.createSerializer(); + this.deserializer = this.codec.createDeserializer(); + this.awsQueryCompatible = !!awsQueryCompatible; + this.mixin = new ProtocolLib(this.awsQueryCompatible); + } + async serializeRequest(operationSchema, input, context) { + const request = await super.serializeRequest(operationSchema, input, context); + if (!request.path.endsWith("/")) { + request.path += "/"; + } + Object.assign(request.headers, { + "content-type": `application/x-amz-json-${this.getJsonRpcVersion()}`, + "x-amz-target": `${this.serviceTarget}.${operationSchema.name}`, + }); + if (this.awsQueryCompatible) { + request.headers["x-amzn-query-mode"] = "true"; + } + if (schema.deref(operationSchema.input) === "unit" || !request.body) { + request.body = "{}"; + } + return request; + } + getPayloadCodec() { + return this.codec; + } + async handleError(operationSchema, context, response, dataObject, metadata) { + if (this.awsQueryCompatible) { + this.mixin.setQueryCompatError(dataObject, response); + } + const errorIdentifier = loadRestJsonErrorCode(response, dataObject) ?? "Unknown"; + const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, dataObject, metadata); + const ns = schema.NormalizedSchema.of(errorSchema); + const message = dataObject.message ?? dataObject.Message ?? "Unknown"; + const ErrorCtor = schema.TypeRegistry.for(errorSchema[1]).getErrorCtor(errorSchema) ?? Error; + const exception = new ErrorCtor(message); + const output = {}; + for (const [name, member] of ns.structIterator()) { + const target = member.getMergedTraits().jsonName ?? name; + output[name] = this.codec.createDeserializer().readObject(member, dataObject[target]); + } + if (this.awsQueryCompatible) { + this.mixin.queryCompatOutput(dataObject, output); + } + throw this.mixin.decorateServiceException(Object.assign(exception, errorMetadata, { + $fault: ns.getMergedTraits().error, + message, + }, output), dataObject); + } +} - /** - * Returns one or more items and item attributes by accessing every item - * in a table or a secondary index. - * - * Supply the same parameters as {AWS.DynamoDB.scan} with - * `AttributeValue`s substituted by native JavaScript types. - * - * @see AWS.DynamoDB.scan - * @example Scan the table with a filter expression - * var params = { - * TableName : 'Table', - * FilterExpression : 'Year = :this_year', - * ExpressionAttributeValues : {':this_year' : 2015} - * }; - * - * var documentClient = new AWS.DynamoDB.DocumentClient(); - * - * documentClient.scan(params, function(err, data) { - * if (err) console.log(err); - * else console.log(data); - * }); - * - */ - scan: function(params, callback) { - var operation = this.serviceClientOperationsMap['scan']; - return this.makeServiceRequest(operation, params, callback); - }, +class AwsJson1_0Protocol extends AwsJsonRpcProtocol { + constructor({ defaultNamespace, serviceTarget, awsQueryCompatible, }) { + super({ + defaultNamespace, + serviceTarget, + awsQueryCompatible, + }); + } + getShapeId() { + return "aws.protocols#awsJson1_0"; + } + getJsonRpcVersion() { + return "1.0"; + } + getDefaultContentType() { + return "application/x-amz-json-1.0"; + } +} - /** - * Directly access items from a table by primary key or a secondary index. - * - * Supply the same parameters as {AWS.DynamoDB.query} with - * `AttributeValue`s substituted by native JavaScript types. - * - * @see AWS.DynamoDB.query - * @example Query an index - * var params = { - * TableName: 'Table', - * IndexName: 'Index', - * KeyConditionExpression: 'HashKey = :hkey and RangeKey > :rkey', - * ExpressionAttributeValues: { - * ':hkey': 'key', - * ':rkey': 2015 - * } - * }; - * - * var documentClient = new AWS.DynamoDB.DocumentClient(); - * - * documentClient.query(params, function(err, data) { - * if (err) console.log(err); - * else console.log(data); - * }); - * - */ - query: function(params, callback) { - var operation = this.serviceClientOperationsMap['query']; - return this.makeServiceRequest(operation, params, callback); - }, - - /** - * Synchronous write operation that groups up to 10 action requests - * - * Supply the same parameters as {AWS.DynamoDB.transactWriteItems} with - * `AttributeValue`s substituted by native JavaScript types. - * - * @see AWS.DynamoDB.transactWriteItems - * @example Get items from multiple tables - * var params = { - * TransactItems: [{ - * Put: { - * TableName : 'Table0', - * Item: { - * HashKey: 'haskey', - * NumAttribute: 1, - * BoolAttribute: true, - * ListAttribute: [1, 'two', false], - * MapAttribute: { foo: 'bar'}, - * NullAttribute: null - * } - * } - * }, { - * Update: { - * TableName: 'Table1', - * Key: { HashKey : 'hashkey' }, - * UpdateExpression: 'set #a = :x + :y', - * ConditionExpression: '#a < :MAX', - * ExpressionAttributeNames: {'#a' : 'Sum'}, - * ExpressionAttributeValues: { - * ':x' : 20, - * ':y' : 45, - * ':MAX' : 100, - * } - * } - * }] - * }; - * - * documentClient.transactWrite(params, function(err, data) { - * if (err) console.log(err); - * else console.log(data); - * }); - */ - transactWrite: function(params, callback) { - var operation = this.serviceClientOperationsMap['transactWrite']; - return this.makeServiceRequest(operation, params, callback); - }, - - /** - * Atomically retrieves multiple items from one or more tables (but not from indexes) - * in a single account and region. - * - * Supply the same parameters as {AWS.DynamoDB.transactGetItems} with - * `AttributeValue`s substituted by native JavaScript types. - * - * @see AWS.DynamoDB.transactGetItems - * @example Get items from multiple tables - * var params = { - * TransactItems: [{ - * Get: { - * TableName : 'Table0', - * Key: { - * HashKey: 'hashkey0' - * } - * } - * }, { - * Get: { - * TableName : 'Table1', - * Key: { - * HashKey: 'hashkey1' - * } - * } - * }] - * }; - * - * documentClient.transactGet(params, function(err, data) { - * if (err) console.log(err); - * else console.log(data); - * }); - */ - transactGet: function(params, callback) { - var operation = this.serviceClientOperationsMap['transactGet']; - return this.makeServiceRequest(operation, params, callback); - }, - - /** - * Creates a set of elements inferring the type of set from - * the type of the first element. Amazon DynamoDB currently supports - * the number sets, string sets, and binary sets. For more information - * about DynamoDB data types see the documentation on the - * [Amazon DynamoDB Data Model](http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataModel.html#DataModel.DataTypes). - * - * @param list [Array] Collection to represent your DynamoDB Set - * @param options [map] - * * **validate** [Boolean] set to true if you want to validate the type - * of each element in the set. Defaults to `false`. - * @example Creating a number set - * var documentClient = new AWS.DynamoDB.DocumentClient(); - * - * var params = { - * Item: { - * hashkey: 'hashkey' - * numbers: documentClient.createSet([1, 2, 3]); - * } - * }; - * - * documentClient.put(params, function(err, data) { - * if (err) console.log(err); - * else console.log(data); - * }); - * - */ - createSet: function(list, options) { - options = options || {}; - return new DynamoDBSet(list, options); - }, - - /** - * @api private - */ - getTranslator: function() { - return new Translator(this.options); - }, - - /** - * @api private - */ - setupRequest: function setupRequest(request) { - var self = this; - var translator = self.getTranslator(); - var operation = request.operation; - var inputShape = request.service.api.operations[operation].input; - request._events.validate.unshift(function(req) { - req.rawParams = AWS.util.copy(req.params); - req.params = translator.translateInput(req.rawParams, inputShape); - }); - }, - - /** - * @api private - */ - setupResponse: function setupResponse(request) { - var self = this; - var translator = self.getTranslator(); - var outputShape = self.service.api.operations[request.operation].output; - request.on('extractData', function(response) { - response.data = translator.translateOutput(response.data, outputShape); - }); - - var response = request.response; - response.nextPage = function(cb) { - var resp = this; - var req = resp.request; - var config; - var service = req.service; - var operation = req.operation; - try { - config = service.paginationConfig(operation, true); - } catch (e) { resp.error = e; } - - if (!resp.hasNextPage()) { - if (cb) cb(resp.error, null); - else if (resp.error) throw resp.error; - return null; - } +class AwsJson1_1Protocol extends AwsJsonRpcProtocol { + constructor({ defaultNamespace, serviceTarget, awsQueryCompatible, }) { + super({ + defaultNamespace, + serviceTarget, + awsQueryCompatible, + }); + } + getShapeId() { + return "aws.protocols#awsJson1_1"; + } + getJsonRpcVersion() { + return "1.1"; + } + getDefaultContentType() { + return "application/x-amz-json-1.1"; + } +} - var params = AWS.util.copy(req.rawParams); - if (!resp.nextPageTokens) { - return cb ? cb(null, null) : null; - } else { - var inputTokens = config.inputToken; - if (typeof inputTokens === 'string') inputTokens = [inputTokens]; - for (var i = 0; i < inputTokens.length; i++) { - params[inputTokens[i]] = resp.nextPageTokens[i]; +class AwsRestJsonProtocol extends protocols.HttpBindingProtocol { + serializer; + deserializer; + codec; + mixin = new ProtocolLib(); + constructor({ defaultNamespace }) { + super({ + defaultNamespace, + }); + const settings = { + timestampFormat: { + useTrait: true, + default: 7, + }, + httpBindings: true, + jsonName: true, + }; + this.codec = new JsonCodec(settings); + this.serializer = new protocols.HttpInterceptingShapeSerializer(this.codec.createSerializer(), settings); + this.deserializer = new protocols.HttpInterceptingShapeDeserializer(this.codec.createDeserializer(), settings); + } + getShapeId() { + return "aws.protocols#restJson1"; + } + getPayloadCodec() { + return this.codec; + } + setSerdeContext(serdeContext) { + this.codec.setSerdeContext(serdeContext); + super.setSerdeContext(serdeContext); + } + async serializeRequest(operationSchema, input, context) { + const request = await super.serializeRequest(operationSchema, input, context); + const inputSchema = schema.NormalizedSchema.of(operationSchema.input); + if (!request.headers["content-type"]) { + const contentType = this.mixin.resolveRestContentType(this.getDefaultContentType(), inputSchema); + if (contentType) { + request.headers["content-type"] = contentType; + } } - return self[operation](params, cb); - } - }; - } - -}); - -/** - * @api private - */ -module.exports = AWS.DynamoDB.DocumentClient; - - -/***/ }), - -/***/ 1372: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['devicefarm'] = {}; -AWS.DeviceFarm = Service.defineService('devicefarm', ['2015-06-23']); -Object.defineProperty(apiLoader.services['devicefarm'], '2015-06-23', { - get: function get() { - var model = __webpack_require__(4622); - model.paginators = __webpack_require__(2522).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.DeviceFarm; - - -/***/ }), - -/***/ 1395: -/***/ (function(module) { - -module.exports = {"pagination":{"ListBusinessReportSchedules":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListConferenceProviders":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListDeviceEvents":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListGatewayGroups":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListGateways":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListSkills":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListSkillsStoreCategories":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListSkillsStoreSkillsByCategory":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListSmartHomeAppliances":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListTags":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"SearchAddressBooks":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"SearchContacts":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"SearchDevices":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"SearchNetworkProfiles":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"SearchProfiles":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"SearchRooms":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"SearchSkillGroups":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"SearchUsers":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"}}}; - -/***/ }), - -/***/ 1401: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['mediastore'] = {}; -AWS.MediaStore = Service.defineService('mediastore', ['2017-09-01']); -Object.defineProperty(apiLoader.services['mediastore'], '2017-09-01', { - get: function get() { - var model = __webpack_require__(5296); - model.paginators = __webpack_require__(6423).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.MediaStore; - - -/***/ }), - -/***/ 1406: -/***/ (function(module) { - -module.exports = {"pagination":{"ListBatchInferenceJobs":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken","result_key":"batchInferenceJobs"},"ListCampaigns":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken","result_key":"campaigns"},"ListDatasetGroups":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken","result_key":"datasetGroups"},"ListDatasetImportJobs":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken","result_key":"datasetImportJobs"},"ListDatasets":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken","result_key":"datasets"},"ListEventTrackers":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken","result_key":"eventTrackers"},"ListRecipes":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken","result_key":"recipes"},"ListSchemas":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken","result_key":"schemas"},"ListSolutionVersions":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken","result_key":"solutionVersions"},"ListSolutions":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken","result_key":"solutions"}}}; - -/***/ }), - -/***/ 1407: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2017-07-25","endpointPrefix":"appsync","jsonVersion":"1.1","protocol":"rest-json","serviceAbbreviation":"AWSAppSync","serviceFullName":"AWS AppSync","serviceId":"AppSync","signatureVersion":"v4","signingName":"appsync","uid":"appsync-2017-07-25"},"operations":{"CreateApiCache":{"http":{"requestUri":"/v1/apis/{apiId}/ApiCaches"},"input":{"type":"structure","required":["apiId","ttl","apiCachingBehavior","type"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"ttl":{"type":"long"},"transitEncryptionEnabled":{"type":"boolean"},"atRestEncryptionEnabled":{"type":"boolean"},"apiCachingBehavior":{},"type":{}}},"output":{"type":"structure","members":{"apiCache":{"shape":"S8"}}}},"CreateApiKey":{"http":{"requestUri":"/v1/apis/{apiId}/apikeys"},"input":{"type":"structure","required":["apiId"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"description":{},"expires":{"type":"long"}}},"output":{"type":"structure","members":{"apiKey":{"shape":"Sc"}}}},"CreateDataSource":{"http":{"requestUri":"/v1/apis/{apiId}/datasources"},"input":{"type":"structure","required":["apiId","name","type"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"name":{},"description":{},"type":{},"serviceRoleArn":{},"dynamodbConfig":{"shape":"Sg"},"lambdaConfig":{"shape":"Si"},"elasticsearchConfig":{"shape":"Sj"},"httpConfig":{"shape":"Sk"},"relationalDatabaseConfig":{"shape":"So"}}},"output":{"type":"structure","members":{"dataSource":{"shape":"Ss"}}}},"CreateFunction":{"http":{"requestUri":"/v1/apis/{apiId}/functions"},"input":{"type":"structure","required":["apiId","name","dataSourceName","requestMappingTemplate","functionVersion"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"name":{},"description":{},"dataSourceName":{},"requestMappingTemplate":{},"responseMappingTemplate":{},"functionVersion":{}}},"output":{"type":"structure","members":{"functionConfiguration":{"shape":"Sw"}}}},"CreateGraphqlApi":{"http":{"requestUri":"/v1/apis"},"input":{"type":"structure","required":["name","authenticationType"],"members":{"name":{},"logConfig":{"shape":"Sy"},"authenticationType":{},"userPoolConfig":{"shape":"S11"},"openIDConnectConfig":{"shape":"S13"},"tags":{"shape":"S14"},"additionalAuthenticationProviders":{"shape":"S17"},"xrayEnabled":{"type":"boolean"}}},"output":{"type":"structure","members":{"graphqlApi":{"shape":"S1b"}}}},"CreateResolver":{"http":{"requestUri":"/v1/apis/{apiId}/types/{typeName}/resolvers"},"input":{"type":"structure","required":["apiId","typeName","fieldName","requestMappingTemplate"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"typeName":{"location":"uri","locationName":"typeName"},"fieldName":{},"dataSourceName":{},"requestMappingTemplate":{},"responseMappingTemplate":{},"kind":{},"pipelineConfig":{"shape":"S1f"},"syncConfig":{"shape":"S1h"},"cachingConfig":{"shape":"S1l"}}},"output":{"type":"structure","members":{"resolver":{"shape":"S1o"}}}},"CreateType":{"http":{"requestUri":"/v1/apis/{apiId}/types"},"input":{"type":"structure","required":["apiId","definition","format"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"definition":{},"format":{}}},"output":{"type":"structure","members":{"type":{"shape":"S1s"}}}},"DeleteApiCache":{"http":{"method":"DELETE","requestUri":"/v1/apis/{apiId}/ApiCaches"},"input":{"type":"structure","required":["apiId"],"members":{"apiId":{"location":"uri","locationName":"apiId"}}},"output":{"type":"structure","members":{}}},"DeleteApiKey":{"http":{"method":"DELETE","requestUri":"/v1/apis/{apiId}/apikeys/{id}"},"input":{"type":"structure","required":["apiId","id"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"id":{"location":"uri","locationName":"id"}}},"output":{"type":"structure","members":{}}},"DeleteDataSource":{"http":{"method":"DELETE","requestUri":"/v1/apis/{apiId}/datasources/{name}"},"input":{"type":"structure","required":["apiId","name"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"name":{"location":"uri","locationName":"name"}}},"output":{"type":"structure","members":{}}},"DeleteFunction":{"http":{"method":"DELETE","requestUri":"/v1/apis/{apiId}/functions/{functionId}"},"input":{"type":"structure","required":["apiId","functionId"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"functionId":{"location":"uri","locationName":"functionId"}}},"output":{"type":"structure","members":{}}},"DeleteGraphqlApi":{"http":{"method":"DELETE","requestUri":"/v1/apis/{apiId}"},"input":{"type":"structure","required":["apiId"],"members":{"apiId":{"location":"uri","locationName":"apiId"}}},"output":{"type":"structure","members":{}}},"DeleteResolver":{"http":{"method":"DELETE","requestUri":"/v1/apis/{apiId}/types/{typeName}/resolvers/{fieldName}"},"input":{"type":"structure","required":["apiId","typeName","fieldName"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"typeName":{"location":"uri","locationName":"typeName"},"fieldName":{"location":"uri","locationName":"fieldName"}}},"output":{"type":"structure","members":{}}},"DeleteType":{"http":{"method":"DELETE","requestUri":"/v1/apis/{apiId}/types/{typeName}"},"input":{"type":"structure","required":["apiId","typeName"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"typeName":{"location":"uri","locationName":"typeName"}}},"output":{"type":"structure","members":{}}},"FlushApiCache":{"http":{"method":"DELETE","requestUri":"/v1/apis/{apiId}/FlushCache"},"input":{"type":"structure","required":["apiId"],"members":{"apiId":{"location":"uri","locationName":"apiId"}}},"output":{"type":"structure","members":{}}},"GetApiCache":{"http":{"method":"GET","requestUri":"/v1/apis/{apiId}/ApiCaches"},"input":{"type":"structure","required":["apiId"],"members":{"apiId":{"location":"uri","locationName":"apiId"}}},"output":{"type":"structure","members":{"apiCache":{"shape":"S8"}}}},"GetDataSource":{"http":{"method":"GET","requestUri":"/v1/apis/{apiId}/datasources/{name}"},"input":{"type":"structure","required":["apiId","name"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"name":{"location":"uri","locationName":"name"}}},"output":{"type":"structure","members":{"dataSource":{"shape":"Ss"}}}},"GetFunction":{"http":{"method":"GET","requestUri":"/v1/apis/{apiId}/functions/{functionId}"},"input":{"type":"structure","required":["apiId","functionId"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"functionId":{"location":"uri","locationName":"functionId"}}},"output":{"type":"structure","members":{"functionConfiguration":{"shape":"Sw"}}}},"GetGraphqlApi":{"http":{"method":"GET","requestUri":"/v1/apis/{apiId}"},"input":{"type":"structure","required":["apiId"],"members":{"apiId":{"location":"uri","locationName":"apiId"}}},"output":{"type":"structure","members":{"graphqlApi":{"shape":"S1b"}}}},"GetIntrospectionSchema":{"http":{"method":"GET","requestUri":"/v1/apis/{apiId}/schema"},"input":{"type":"structure","required":["apiId","format"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"format":{"location":"querystring","locationName":"format"},"includeDirectives":{"location":"querystring","locationName":"includeDirectives","type":"boolean"}}},"output":{"type":"structure","members":{"schema":{"type":"blob"}},"payload":"schema"}},"GetResolver":{"http":{"method":"GET","requestUri":"/v1/apis/{apiId}/types/{typeName}/resolvers/{fieldName}"},"input":{"type":"structure","required":["apiId","typeName","fieldName"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"typeName":{"location":"uri","locationName":"typeName"},"fieldName":{"location":"uri","locationName":"fieldName"}}},"output":{"type":"structure","members":{"resolver":{"shape":"S1o"}}}},"GetSchemaCreationStatus":{"http":{"method":"GET","requestUri":"/v1/apis/{apiId}/schemacreation"},"input":{"type":"structure","required":["apiId"],"members":{"apiId":{"location":"uri","locationName":"apiId"}}},"output":{"type":"structure","members":{"status":{},"details":{}}}},"GetType":{"http":{"method":"GET","requestUri":"/v1/apis/{apiId}/types/{typeName}"},"input":{"type":"structure","required":["apiId","typeName","format"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"typeName":{"location":"uri","locationName":"typeName"},"format":{"location":"querystring","locationName":"format"}}},"output":{"type":"structure","members":{"type":{"shape":"S1s"}}}},"ListApiKeys":{"http":{"method":"GET","requestUri":"/v1/apis/{apiId}/apikeys"},"input":{"type":"structure","required":["apiId"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"apiKeys":{"type":"list","member":{"shape":"Sc"}},"nextToken":{}}}},"ListDataSources":{"http":{"method":"GET","requestUri":"/v1/apis/{apiId}/datasources"},"input":{"type":"structure","required":["apiId"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"dataSources":{"type":"list","member":{"shape":"Ss"}},"nextToken":{}}}},"ListFunctions":{"http":{"method":"GET","requestUri":"/v1/apis/{apiId}/functions"},"input":{"type":"structure","required":["apiId"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"functions":{"type":"list","member":{"shape":"Sw"}},"nextToken":{}}}},"ListGraphqlApis":{"http":{"method":"GET","requestUri":"/v1/apis"},"input":{"type":"structure","members":{"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"graphqlApis":{"type":"list","member":{"shape":"S1b"}},"nextToken":{}}}},"ListResolvers":{"http":{"method":"GET","requestUri":"/v1/apis/{apiId}/types/{typeName}/resolvers"},"input":{"type":"structure","required":["apiId","typeName"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"typeName":{"location":"uri","locationName":"typeName"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"resolvers":{"shape":"S39"},"nextToken":{}}}},"ListResolversByFunction":{"http":{"method":"GET","requestUri":"/v1/apis/{apiId}/functions/{functionId}/resolvers"},"input":{"type":"structure","required":["apiId","functionId"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"functionId":{"location":"uri","locationName":"functionId"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"resolvers":{"shape":"S39"},"nextToken":{}}}},"ListTagsForResource":{"http":{"method":"GET","requestUri":"/v1/tags/{resourceArn}"},"input":{"type":"structure","required":["resourceArn"],"members":{"resourceArn":{"location":"uri","locationName":"resourceArn"}}},"output":{"type":"structure","members":{"tags":{"shape":"S14"}}}},"ListTypes":{"http":{"method":"GET","requestUri":"/v1/apis/{apiId}/types"},"input":{"type":"structure","required":["apiId","format"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"format":{"location":"querystring","locationName":"format"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"types":{"type":"list","member":{"shape":"S1s"}},"nextToken":{}}}},"StartSchemaCreation":{"http":{"requestUri":"/v1/apis/{apiId}/schemacreation"},"input":{"type":"structure","required":["apiId","definition"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"definition":{"type":"blob"}}},"output":{"type":"structure","members":{"status":{}}}},"TagResource":{"http":{"requestUri":"/v1/tags/{resourceArn}"},"input":{"type":"structure","required":["resourceArn","tags"],"members":{"resourceArn":{"location":"uri","locationName":"resourceArn"},"tags":{"shape":"S14"}}},"output":{"type":"structure","members":{}}},"UntagResource":{"http":{"method":"DELETE","requestUri":"/v1/tags/{resourceArn}"},"input":{"type":"structure","required":["resourceArn","tagKeys"],"members":{"resourceArn":{"location":"uri","locationName":"resourceArn"},"tagKeys":{"location":"querystring","locationName":"tagKeys","type":"list","member":{}}}},"output":{"type":"structure","members":{}}},"UpdateApiCache":{"http":{"requestUri":"/v1/apis/{apiId}/ApiCaches/update"},"input":{"type":"structure","required":["apiId","ttl","apiCachingBehavior","type"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"ttl":{"type":"long"},"apiCachingBehavior":{},"type":{}}},"output":{"type":"structure","members":{"apiCache":{"shape":"S8"}}}},"UpdateApiKey":{"http":{"requestUri":"/v1/apis/{apiId}/apikeys/{id}"},"input":{"type":"structure","required":["apiId","id"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"id":{"location":"uri","locationName":"id"},"description":{},"expires":{"type":"long"}}},"output":{"type":"structure","members":{"apiKey":{"shape":"Sc"}}}},"UpdateDataSource":{"http":{"requestUri":"/v1/apis/{apiId}/datasources/{name}"},"input":{"type":"structure","required":["apiId","name","type"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"name":{"location":"uri","locationName":"name"},"description":{},"type":{},"serviceRoleArn":{},"dynamodbConfig":{"shape":"Sg"},"lambdaConfig":{"shape":"Si"},"elasticsearchConfig":{"shape":"Sj"},"httpConfig":{"shape":"Sk"},"relationalDatabaseConfig":{"shape":"So"}}},"output":{"type":"structure","members":{"dataSource":{"shape":"Ss"}}}},"UpdateFunction":{"http":{"requestUri":"/v1/apis/{apiId}/functions/{functionId}"},"input":{"type":"structure","required":["apiId","name","functionId","dataSourceName","requestMappingTemplate","functionVersion"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"name":{},"description":{},"functionId":{"location":"uri","locationName":"functionId"},"dataSourceName":{},"requestMappingTemplate":{},"responseMappingTemplate":{},"functionVersion":{}}},"output":{"type":"structure","members":{"functionConfiguration":{"shape":"Sw"}}}},"UpdateGraphqlApi":{"http":{"requestUri":"/v1/apis/{apiId}"},"input":{"type":"structure","required":["apiId","name"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"name":{},"logConfig":{"shape":"Sy"},"authenticationType":{},"userPoolConfig":{"shape":"S11"},"openIDConnectConfig":{"shape":"S13"},"additionalAuthenticationProviders":{"shape":"S17"},"xrayEnabled":{"type":"boolean"}}},"output":{"type":"structure","members":{"graphqlApi":{"shape":"S1b"}}}},"UpdateResolver":{"http":{"requestUri":"/v1/apis/{apiId}/types/{typeName}/resolvers/{fieldName}"},"input":{"type":"structure","required":["apiId","typeName","fieldName","requestMappingTemplate"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"typeName":{"location":"uri","locationName":"typeName"},"fieldName":{"location":"uri","locationName":"fieldName"},"dataSourceName":{},"requestMappingTemplate":{},"responseMappingTemplate":{},"kind":{},"pipelineConfig":{"shape":"S1f"},"syncConfig":{"shape":"S1h"},"cachingConfig":{"shape":"S1l"}}},"output":{"type":"structure","members":{"resolver":{"shape":"S1o"}}}},"UpdateType":{"http":{"requestUri":"/v1/apis/{apiId}/types/{typeName}"},"input":{"type":"structure","required":["apiId","typeName","format"],"members":{"apiId":{"location":"uri","locationName":"apiId"},"typeName":{"location":"uri","locationName":"typeName"},"definition":{},"format":{}}},"output":{"type":"structure","members":{"type":{"shape":"S1s"}}}}},"shapes":{"S8":{"type":"structure","members":{"ttl":{"type":"long"},"apiCachingBehavior":{},"transitEncryptionEnabled":{"type":"boolean"},"atRestEncryptionEnabled":{"type":"boolean"},"type":{},"status":{}}},"Sc":{"type":"structure","members":{"id":{},"description":{},"expires":{"type":"long"}}},"Sg":{"type":"structure","required":["tableName","awsRegion"],"members":{"tableName":{},"awsRegion":{},"useCallerCredentials":{"type":"boolean"},"deltaSyncConfig":{"type":"structure","members":{"baseTableTTL":{"type":"long"},"deltaSyncTableName":{},"deltaSyncTableTTL":{"type":"long"}}},"versioned":{"type":"boolean"}}},"Si":{"type":"structure","required":["lambdaFunctionArn"],"members":{"lambdaFunctionArn":{}}},"Sj":{"type":"structure","required":["endpoint","awsRegion"],"members":{"endpoint":{},"awsRegion":{}}},"Sk":{"type":"structure","members":{"endpoint":{},"authorizationConfig":{"type":"structure","required":["authorizationType"],"members":{"authorizationType":{},"awsIamConfig":{"type":"structure","members":{"signingRegion":{},"signingServiceName":{}}}}}}},"So":{"type":"structure","members":{"relationalDatabaseSourceType":{},"rdsHttpEndpointConfig":{"type":"structure","members":{"awsRegion":{},"dbClusterIdentifier":{},"databaseName":{},"schema":{},"awsSecretStoreArn":{}}}}},"Ss":{"type":"structure","members":{"dataSourceArn":{},"name":{},"description":{},"type":{},"serviceRoleArn":{},"dynamodbConfig":{"shape":"Sg"},"lambdaConfig":{"shape":"Si"},"elasticsearchConfig":{"shape":"Sj"},"httpConfig":{"shape":"Sk"},"relationalDatabaseConfig":{"shape":"So"}}},"Sw":{"type":"structure","members":{"functionId":{},"functionArn":{},"name":{},"description":{},"dataSourceName":{},"requestMappingTemplate":{},"responseMappingTemplate":{},"functionVersion":{}}},"Sy":{"type":"structure","required":["fieldLogLevel","cloudWatchLogsRoleArn"],"members":{"fieldLogLevel":{},"cloudWatchLogsRoleArn":{},"excludeVerboseContent":{"type":"boolean"}}},"S11":{"type":"structure","required":["userPoolId","awsRegion","defaultAction"],"members":{"userPoolId":{},"awsRegion":{},"defaultAction":{},"appIdClientRegex":{}}},"S13":{"type":"structure","required":["issuer"],"members":{"issuer":{},"clientId":{},"iatTTL":{"type":"long"},"authTTL":{"type":"long"}}},"S14":{"type":"map","key":{},"value":{}},"S17":{"type":"list","member":{"type":"structure","members":{"authenticationType":{},"openIDConnectConfig":{"shape":"S13"},"userPoolConfig":{"type":"structure","required":["userPoolId","awsRegion"],"members":{"userPoolId":{},"awsRegion":{},"appIdClientRegex":{}}}}}},"S1b":{"type":"structure","members":{"name":{},"apiId":{},"authenticationType":{},"logConfig":{"shape":"Sy"},"userPoolConfig":{"shape":"S11"},"openIDConnectConfig":{"shape":"S13"},"arn":{},"uris":{"type":"map","key":{},"value":{}},"tags":{"shape":"S14"},"additionalAuthenticationProviders":{"shape":"S17"},"xrayEnabled":{"type":"boolean"}}},"S1f":{"type":"structure","members":{"functions":{"type":"list","member":{}}}},"S1h":{"type":"structure","members":{"conflictHandler":{},"conflictDetection":{},"lambdaConflictHandlerConfig":{"type":"structure","members":{"lambdaConflictHandlerArn":{}}}}},"S1l":{"type":"structure","members":{"ttl":{"type":"long"},"cachingKeys":{"type":"list","member":{}}}},"S1o":{"type":"structure","members":{"typeName":{},"fieldName":{},"dataSourceName":{},"resolverArn":{},"requestMappingTemplate":{},"responseMappingTemplate":{},"kind":{},"pipelineConfig":{"shape":"S1f"},"syncConfig":{"shape":"S1h"},"cachingConfig":{"shape":"S1l"}}},"S1s":{"type":"structure","members":{"name":{},"description":{},"arn":{},"definition":{},"format":{}}},"S39":{"type":"list","member":{"shape":"S1o"}}}}; - -/***/ }), - -/***/ 1411: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2014-10-31","endpointPrefix":"rds","protocol":"query","serviceAbbreviation":"Amazon Neptune","serviceFullName":"Amazon Neptune","serviceId":"Neptune","signatureVersion":"v4","signingName":"rds","uid":"neptune-2014-10-31","xmlNamespace":"http://rds.amazonaws.com/doc/2014-10-31/"},"operations":{"AddRoleToDBCluster":{"input":{"type":"structure","required":["DBClusterIdentifier","RoleArn"],"members":{"DBClusterIdentifier":{},"RoleArn":{}}}},"AddSourceIdentifierToSubscription":{"input":{"type":"structure","required":["SubscriptionName","SourceIdentifier"],"members":{"SubscriptionName":{},"SourceIdentifier":{}}},"output":{"resultWrapper":"AddSourceIdentifierToSubscriptionResult","type":"structure","members":{"EventSubscription":{"shape":"S5"}}}},"AddTagsToResource":{"input":{"type":"structure","required":["ResourceName","Tags"],"members":{"ResourceName":{},"Tags":{"shape":"Sa"}}}},"ApplyPendingMaintenanceAction":{"input":{"type":"structure","required":["ResourceIdentifier","ApplyAction","OptInType"],"members":{"ResourceIdentifier":{},"ApplyAction":{},"OptInType":{}}},"output":{"resultWrapper":"ApplyPendingMaintenanceActionResult","type":"structure","members":{"ResourcePendingMaintenanceActions":{"shape":"Se"}}}},"CopyDBClusterParameterGroup":{"input":{"type":"structure","required":["SourceDBClusterParameterGroupIdentifier","TargetDBClusterParameterGroupIdentifier","TargetDBClusterParameterGroupDescription"],"members":{"SourceDBClusterParameterGroupIdentifier":{},"TargetDBClusterParameterGroupIdentifier":{},"TargetDBClusterParameterGroupDescription":{},"Tags":{"shape":"Sa"}}},"output":{"resultWrapper":"CopyDBClusterParameterGroupResult","type":"structure","members":{"DBClusterParameterGroup":{"shape":"Sk"}}}},"CopyDBClusterSnapshot":{"input":{"type":"structure","required":["SourceDBClusterSnapshotIdentifier","TargetDBClusterSnapshotIdentifier"],"members":{"SourceDBClusterSnapshotIdentifier":{},"TargetDBClusterSnapshotIdentifier":{},"KmsKeyId":{},"PreSignedUrl":{},"CopyTags":{"type":"boolean"},"Tags":{"shape":"Sa"}}},"output":{"resultWrapper":"CopyDBClusterSnapshotResult","type":"structure","members":{"DBClusterSnapshot":{"shape":"So"}}}},"CopyDBParameterGroup":{"input":{"type":"structure","required":["SourceDBParameterGroupIdentifier","TargetDBParameterGroupIdentifier","TargetDBParameterGroupDescription"],"members":{"SourceDBParameterGroupIdentifier":{},"TargetDBParameterGroupIdentifier":{},"TargetDBParameterGroupDescription":{},"Tags":{"shape":"Sa"}}},"output":{"resultWrapper":"CopyDBParameterGroupResult","type":"structure","members":{"DBParameterGroup":{"shape":"St"}}}},"CreateDBCluster":{"input":{"type":"structure","required":["DBClusterIdentifier","Engine"],"members":{"AvailabilityZones":{"shape":"Sp"},"BackupRetentionPeriod":{"type":"integer"},"CharacterSetName":{},"DatabaseName":{},"DBClusterIdentifier":{},"DBClusterParameterGroupName":{},"VpcSecurityGroupIds":{"shape":"Sw"},"DBSubnetGroupName":{},"Engine":{},"EngineVersion":{},"Port":{"type":"integer"},"MasterUsername":{},"MasterUserPassword":{},"OptionGroupName":{},"PreferredBackupWindow":{},"PreferredMaintenanceWindow":{},"ReplicationSourceIdentifier":{},"Tags":{"shape":"Sa"},"StorageEncrypted":{"type":"boolean"},"KmsKeyId":{},"PreSignedUrl":{},"EnableIAMDatabaseAuthentication":{"type":"boolean"},"EnableCloudwatchLogsExports":{"shape":"Sx"},"DeletionProtection":{"type":"boolean"}}},"output":{"resultWrapper":"CreateDBClusterResult","type":"structure","members":{"DBCluster":{"shape":"Sz"}}}},"CreateDBClusterParameterGroup":{"input":{"type":"structure","required":["DBClusterParameterGroupName","DBParameterGroupFamily","Description"],"members":{"DBClusterParameterGroupName":{},"DBParameterGroupFamily":{},"Description":{},"Tags":{"shape":"Sa"}}},"output":{"resultWrapper":"CreateDBClusterParameterGroupResult","type":"structure","members":{"DBClusterParameterGroup":{"shape":"Sk"}}}},"CreateDBClusterSnapshot":{"input":{"type":"structure","required":["DBClusterSnapshotIdentifier","DBClusterIdentifier"],"members":{"DBClusterSnapshotIdentifier":{},"DBClusterIdentifier":{},"Tags":{"shape":"Sa"}}},"output":{"resultWrapper":"CreateDBClusterSnapshotResult","type":"structure","members":{"DBClusterSnapshot":{"shape":"So"}}}},"CreateDBInstance":{"input":{"type":"structure","required":["DBInstanceIdentifier","DBInstanceClass","Engine"],"members":{"DBName":{},"DBInstanceIdentifier":{},"AllocatedStorage":{"type":"integer"},"DBInstanceClass":{},"Engine":{},"MasterUsername":{},"MasterUserPassword":{},"DBSecurityGroups":{"shape":"S1e"},"VpcSecurityGroupIds":{"shape":"Sw"},"AvailabilityZone":{},"DBSubnetGroupName":{},"PreferredMaintenanceWindow":{},"DBParameterGroupName":{},"BackupRetentionPeriod":{"type":"integer"},"PreferredBackupWindow":{},"Port":{"type":"integer"},"MultiAZ":{"type":"boolean"},"EngineVersion":{},"AutoMinorVersionUpgrade":{"type":"boolean"},"LicenseModel":{},"Iops":{"type":"integer"},"OptionGroupName":{},"CharacterSetName":{},"PubliclyAccessible":{"deprecated":true,"type":"boolean"},"Tags":{"shape":"Sa"},"DBClusterIdentifier":{},"StorageType":{},"TdeCredentialArn":{},"TdeCredentialPassword":{},"StorageEncrypted":{"type":"boolean"},"KmsKeyId":{},"Domain":{},"CopyTagsToSnapshot":{"type":"boolean"},"MonitoringInterval":{"type":"integer"},"MonitoringRoleArn":{},"DomainIAMRoleName":{},"PromotionTier":{"type":"integer"},"Timezone":{},"EnableIAMDatabaseAuthentication":{"type":"boolean"},"EnablePerformanceInsights":{"type":"boolean"},"PerformanceInsightsKMSKeyId":{},"EnableCloudwatchLogsExports":{"shape":"Sx"},"DeletionProtection":{"type":"boolean"}}},"output":{"resultWrapper":"CreateDBInstanceResult","type":"structure","members":{"DBInstance":{"shape":"S1g"}}}},"CreateDBParameterGroup":{"input":{"type":"structure","required":["DBParameterGroupName","DBParameterGroupFamily","Description"],"members":{"DBParameterGroupName":{},"DBParameterGroupFamily":{},"Description":{},"Tags":{"shape":"Sa"}}},"output":{"resultWrapper":"CreateDBParameterGroupResult","type":"structure","members":{"DBParameterGroup":{"shape":"St"}}}},"CreateDBSubnetGroup":{"input":{"type":"structure","required":["DBSubnetGroupName","DBSubnetGroupDescription","SubnetIds"],"members":{"DBSubnetGroupName":{},"DBSubnetGroupDescription":{},"SubnetIds":{"shape":"S23"},"Tags":{"shape":"Sa"}}},"output":{"resultWrapper":"CreateDBSubnetGroupResult","type":"structure","members":{"DBSubnetGroup":{"shape":"S1m"}}}},"CreateEventSubscription":{"input":{"type":"structure","required":["SubscriptionName","SnsTopicArn"],"members":{"SubscriptionName":{},"SnsTopicArn":{},"SourceType":{},"EventCategories":{"shape":"S7"},"SourceIds":{"shape":"S6"},"Enabled":{"type":"boolean"},"Tags":{"shape":"Sa"}}},"output":{"resultWrapper":"CreateEventSubscriptionResult","type":"structure","members":{"EventSubscription":{"shape":"S5"}}}},"DeleteDBCluster":{"input":{"type":"structure","required":["DBClusterIdentifier"],"members":{"DBClusterIdentifier":{},"SkipFinalSnapshot":{"type":"boolean"},"FinalDBSnapshotIdentifier":{}}},"output":{"resultWrapper":"DeleteDBClusterResult","type":"structure","members":{"DBCluster":{"shape":"Sz"}}}},"DeleteDBClusterParameterGroup":{"input":{"type":"structure","required":["DBClusterParameterGroupName"],"members":{"DBClusterParameterGroupName":{}}}},"DeleteDBClusterSnapshot":{"input":{"type":"structure","required":["DBClusterSnapshotIdentifier"],"members":{"DBClusterSnapshotIdentifier":{}}},"output":{"resultWrapper":"DeleteDBClusterSnapshotResult","type":"structure","members":{"DBClusterSnapshot":{"shape":"So"}}}},"DeleteDBInstance":{"input":{"type":"structure","required":["DBInstanceIdentifier"],"members":{"DBInstanceIdentifier":{},"SkipFinalSnapshot":{"type":"boolean"},"FinalDBSnapshotIdentifier":{}}},"output":{"resultWrapper":"DeleteDBInstanceResult","type":"structure","members":{"DBInstance":{"shape":"S1g"}}}},"DeleteDBParameterGroup":{"input":{"type":"structure","required":["DBParameterGroupName"],"members":{"DBParameterGroupName":{}}}},"DeleteDBSubnetGroup":{"input":{"type":"structure","required":["DBSubnetGroupName"],"members":{"DBSubnetGroupName":{}}}},"DeleteEventSubscription":{"input":{"type":"structure","required":["SubscriptionName"],"members":{"SubscriptionName":{}}},"output":{"resultWrapper":"DeleteEventSubscriptionResult","type":"structure","members":{"EventSubscription":{"shape":"S5"}}}},"DescribeDBClusterParameterGroups":{"input":{"type":"structure","members":{"DBClusterParameterGroupName":{},"Filters":{"shape":"S2j"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeDBClusterParameterGroupsResult","type":"structure","members":{"Marker":{},"DBClusterParameterGroups":{"type":"list","member":{"shape":"Sk","locationName":"DBClusterParameterGroup"}}}}},"DescribeDBClusterParameters":{"input":{"type":"structure","required":["DBClusterParameterGroupName"],"members":{"DBClusterParameterGroupName":{},"Source":{},"Filters":{"shape":"S2j"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeDBClusterParametersResult","type":"structure","members":{"Parameters":{"shape":"S2q"},"Marker":{}}}},"DescribeDBClusterSnapshotAttributes":{"input":{"type":"structure","required":["DBClusterSnapshotIdentifier"],"members":{"DBClusterSnapshotIdentifier":{}}},"output":{"resultWrapper":"DescribeDBClusterSnapshotAttributesResult","type":"structure","members":{"DBClusterSnapshotAttributesResult":{"shape":"S2v"}}}},"DescribeDBClusterSnapshots":{"input":{"type":"structure","members":{"DBClusterIdentifier":{},"DBClusterSnapshotIdentifier":{},"SnapshotType":{},"Filters":{"shape":"S2j"},"MaxRecords":{"type":"integer"},"Marker":{},"IncludeShared":{"type":"boolean"},"IncludePublic":{"type":"boolean"}}},"output":{"resultWrapper":"DescribeDBClusterSnapshotsResult","type":"structure","members":{"Marker":{},"DBClusterSnapshots":{"type":"list","member":{"shape":"So","locationName":"DBClusterSnapshot"}}}}},"DescribeDBClusters":{"input":{"type":"structure","members":{"DBClusterIdentifier":{},"Filters":{"shape":"S2j"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeDBClustersResult","type":"structure","members":{"Marker":{},"DBClusters":{"type":"list","member":{"shape":"Sz","locationName":"DBCluster"}}}}},"DescribeDBEngineVersions":{"input":{"type":"structure","members":{"Engine":{},"EngineVersion":{},"DBParameterGroupFamily":{},"Filters":{"shape":"S2j"},"MaxRecords":{"type":"integer"},"Marker":{},"DefaultOnly":{"type":"boolean"},"ListSupportedCharacterSets":{"type":"boolean"},"ListSupportedTimezones":{"type":"boolean"}}},"output":{"resultWrapper":"DescribeDBEngineVersionsResult","type":"structure","members":{"Marker":{},"DBEngineVersions":{"type":"list","member":{"locationName":"DBEngineVersion","type":"structure","members":{"Engine":{},"EngineVersion":{},"DBParameterGroupFamily":{},"DBEngineDescription":{},"DBEngineVersionDescription":{},"DefaultCharacterSet":{"shape":"S39"},"SupportedCharacterSets":{"type":"list","member":{"shape":"S39","locationName":"CharacterSet"}},"ValidUpgradeTarget":{"type":"list","member":{"locationName":"UpgradeTarget","type":"structure","members":{"Engine":{},"EngineVersion":{},"Description":{},"AutoUpgrade":{"type":"boolean"},"IsMajorVersionUpgrade":{"type":"boolean"}}}},"SupportedTimezones":{"type":"list","member":{"locationName":"Timezone","type":"structure","members":{"TimezoneName":{}}}},"ExportableLogTypes":{"shape":"Sx"},"SupportsLogExportsToCloudwatchLogs":{"type":"boolean"},"SupportsReadReplica":{"type":"boolean"}}}}}}},"DescribeDBInstances":{"input":{"type":"structure","members":{"DBInstanceIdentifier":{},"Filters":{"shape":"S2j"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeDBInstancesResult","type":"structure","members":{"Marker":{},"DBInstances":{"type":"list","member":{"shape":"S1g","locationName":"DBInstance"}}}}},"DescribeDBParameterGroups":{"input":{"type":"structure","members":{"DBParameterGroupName":{},"Filters":{"shape":"S2j"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeDBParameterGroupsResult","type":"structure","members":{"Marker":{},"DBParameterGroups":{"type":"list","member":{"shape":"St","locationName":"DBParameterGroup"}}}}},"DescribeDBParameters":{"input":{"type":"structure","required":["DBParameterGroupName"],"members":{"DBParameterGroupName":{},"Source":{},"Filters":{"shape":"S2j"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeDBParametersResult","type":"structure","members":{"Parameters":{"shape":"S2q"},"Marker":{}}}},"DescribeDBSubnetGroups":{"input":{"type":"structure","members":{"DBSubnetGroupName":{},"Filters":{"shape":"S2j"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeDBSubnetGroupsResult","type":"structure","members":{"Marker":{},"DBSubnetGroups":{"type":"list","member":{"shape":"S1m","locationName":"DBSubnetGroup"}}}}},"DescribeEngineDefaultClusterParameters":{"input":{"type":"structure","required":["DBParameterGroupFamily"],"members":{"DBParameterGroupFamily":{},"Filters":{"shape":"S2j"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeEngineDefaultClusterParametersResult","type":"structure","members":{"EngineDefaults":{"shape":"S3s"}}}},"DescribeEngineDefaultParameters":{"input":{"type":"structure","required":["DBParameterGroupFamily"],"members":{"DBParameterGroupFamily":{},"Filters":{"shape":"S2j"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeEngineDefaultParametersResult","type":"structure","members":{"EngineDefaults":{"shape":"S3s"}}}},"DescribeEventCategories":{"input":{"type":"structure","members":{"SourceType":{},"Filters":{"shape":"S2j"}}},"output":{"resultWrapper":"DescribeEventCategoriesResult","type":"structure","members":{"EventCategoriesMapList":{"type":"list","member":{"locationName":"EventCategoriesMap","type":"structure","members":{"SourceType":{},"EventCategories":{"shape":"S7"}},"wrapper":true}}}}},"DescribeEventSubscriptions":{"input":{"type":"structure","members":{"SubscriptionName":{},"Filters":{"shape":"S2j"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeEventSubscriptionsResult","type":"structure","members":{"Marker":{},"EventSubscriptionsList":{"type":"list","member":{"shape":"S5","locationName":"EventSubscription"}}}}},"DescribeEvents":{"input":{"type":"structure","members":{"SourceIdentifier":{},"SourceType":{},"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"Duration":{"type":"integer"},"EventCategories":{"shape":"S7"},"Filters":{"shape":"S2j"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeEventsResult","type":"structure","members":{"Marker":{},"Events":{"type":"list","member":{"locationName":"Event","type":"structure","members":{"SourceIdentifier":{},"SourceType":{},"Message":{},"EventCategories":{"shape":"S7"},"Date":{"type":"timestamp"},"SourceArn":{}}}}}}},"DescribeOrderableDBInstanceOptions":{"input":{"type":"structure","required":["Engine"],"members":{"Engine":{},"EngineVersion":{},"DBInstanceClass":{},"LicenseModel":{},"Vpc":{"type":"boolean"},"Filters":{"shape":"S2j"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeOrderableDBInstanceOptionsResult","type":"structure","members":{"OrderableDBInstanceOptions":{"type":"list","member":{"locationName":"OrderableDBInstanceOption","type":"structure","members":{"Engine":{},"EngineVersion":{},"DBInstanceClass":{},"LicenseModel":{},"AvailabilityZones":{"type":"list","member":{"shape":"S1p","locationName":"AvailabilityZone"}},"MultiAZCapable":{"type":"boolean"},"ReadReplicaCapable":{"type":"boolean"},"Vpc":{"type":"boolean"},"SupportsStorageEncryption":{"type":"boolean"},"StorageType":{},"SupportsIops":{"type":"boolean"},"SupportsEnhancedMonitoring":{"type":"boolean"},"SupportsIAMDatabaseAuthentication":{"type":"boolean"},"SupportsPerformanceInsights":{"type":"boolean"},"MinStorageSize":{"type":"integer"},"MaxStorageSize":{"type":"integer"},"MinIopsPerDbInstance":{"type":"integer"},"MaxIopsPerDbInstance":{"type":"integer"},"MinIopsPerGib":{"type":"double"},"MaxIopsPerGib":{"type":"double"}},"wrapper":true}},"Marker":{}}}},"DescribePendingMaintenanceActions":{"input":{"type":"structure","members":{"ResourceIdentifier":{},"Filters":{"shape":"S2j"},"Marker":{},"MaxRecords":{"type":"integer"}}},"output":{"resultWrapper":"DescribePendingMaintenanceActionsResult","type":"structure","members":{"PendingMaintenanceActions":{"type":"list","member":{"shape":"Se","locationName":"ResourcePendingMaintenanceActions"}},"Marker":{}}}},"DescribeValidDBInstanceModifications":{"input":{"type":"structure","required":["DBInstanceIdentifier"],"members":{"DBInstanceIdentifier":{}}},"output":{"resultWrapper":"DescribeValidDBInstanceModificationsResult","type":"structure","members":{"ValidDBInstanceModificationsMessage":{"type":"structure","members":{"Storage":{"type":"list","member":{"locationName":"ValidStorageOptions","type":"structure","members":{"StorageType":{},"StorageSize":{"shape":"S4l"},"ProvisionedIops":{"shape":"S4l"},"IopsToStorageRatio":{"type":"list","member":{"locationName":"DoubleRange","type":"structure","members":{"From":{"type":"double"},"To":{"type":"double"}}}}}}}},"wrapper":true}}}},"FailoverDBCluster":{"input":{"type":"structure","members":{"DBClusterIdentifier":{},"TargetDBInstanceIdentifier":{}}},"output":{"resultWrapper":"FailoverDBClusterResult","type":"structure","members":{"DBCluster":{"shape":"Sz"}}}},"ListTagsForResource":{"input":{"type":"structure","required":["ResourceName"],"members":{"ResourceName":{},"Filters":{"shape":"S2j"}}},"output":{"resultWrapper":"ListTagsForResourceResult","type":"structure","members":{"TagList":{"shape":"Sa"}}}},"ModifyDBCluster":{"input":{"type":"structure","required":["DBClusterIdentifier"],"members":{"DBClusterIdentifier":{},"NewDBClusterIdentifier":{},"ApplyImmediately":{"type":"boolean"},"BackupRetentionPeriod":{"type":"integer"},"DBClusterParameterGroupName":{},"VpcSecurityGroupIds":{"shape":"Sw"},"Port":{"type":"integer"},"MasterUserPassword":{},"OptionGroupName":{},"PreferredBackupWindow":{},"PreferredMaintenanceWindow":{},"EnableIAMDatabaseAuthentication":{"type":"boolean"},"CloudwatchLogsExportConfiguration":{"shape":"S4v"},"EngineVersion":{},"DeletionProtection":{"type":"boolean"}}},"output":{"resultWrapper":"ModifyDBClusterResult","type":"structure","members":{"DBCluster":{"shape":"Sz"}}}},"ModifyDBClusterParameterGroup":{"input":{"type":"structure","required":["DBClusterParameterGroupName","Parameters"],"members":{"DBClusterParameterGroupName":{},"Parameters":{"shape":"S2q"}}},"output":{"shape":"S4y","resultWrapper":"ModifyDBClusterParameterGroupResult"}},"ModifyDBClusterSnapshotAttribute":{"input":{"type":"structure","required":["DBClusterSnapshotIdentifier","AttributeName"],"members":{"DBClusterSnapshotIdentifier":{},"AttributeName":{},"ValuesToAdd":{"shape":"S2y"},"ValuesToRemove":{"shape":"S2y"}}},"output":{"resultWrapper":"ModifyDBClusterSnapshotAttributeResult","type":"structure","members":{"DBClusterSnapshotAttributesResult":{"shape":"S2v"}}}},"ModifyDBInstance":{"input":{"type":"structure","required":["DBInstanceIdentifier"],"members":{"DBInstanceIdentifier":{},"AllocatedStorage":{"type":"integer"},"DBInstanceClass":{},"DBSubnetGroupName":{},"DBSecurityGroups":{"shape":"S1e"},"VpcSecurityGroupIds":{"shape":"Sw"},"ApplyImmediately":{"type":"boolean"},"MasterUserPassword":{},"DBParameterGroupName":{},"BackupRetentionPeriod":{"type":"integer"},"PreferredBackupWindow":{},"PreferredMaintenanceWindow":{},"MultiAZ":{"type":"boolean"},"EngineVersion":{},"AllowMajorVersionUpgrade":{"type":"boolean"},"AutoMinorVersionUpgrade":{"type":"boolean"},"LicenseModel":{},"Iops":{"type":"integer"},"OptionGroupName":{},"NewDBInstanceIdentifier":{},"StorageType":{},"TdeCredentialArn":{},"TdeCredentialPassword":{},"CACertificateIdentifier":{},"Domain":{},"CopyTagsToSnapshot":{"type":"boolean"},"MonitoringInterval":{"type":"integer"},"DBPortNumber":{"type":"integer"},"PubliclyAccessible":{"deprecated":true,"type":"boolean"},"MonitoringRoleArn":{},"DomainIAMRoleName":{},"PromotionTier":{"type":"integer"},"EnableIAMDatabaseAuthentication":{"type":"boolean"},"EnablePerformanceInsights":{"type":"boolean"},"PerformanceInsightsKMSKeyId":{},"CloudwatchLogsExportConfiguration":{"shape":"S4v"},"DeletionProtection":{"type":"boolean"}}},"output":{"resultWrapper":"ModifyDBInstanceResult","type":"structure","members":{"DBInstance":{"shape":"S1g"}}}},"ModifyDBParameterGroup":{"input":{"type":"structure","required":["DBParameterGroupName","Parameters"],"members":{"DBParameterGroupName":{},"Parameters":{"shape":"S2q"}}},"output":{"shape":"S54","resultWrapper":"ModifyDBParameterGroupResult"}},"ModifyDBSubnetGroup":{"input":{"type":"structure","required":["DBSubnetGroupName","SubnetIds"],"members":{"DBSubnetGroupName":{},"DBSubnetGroupDescription":{},"SubnetIds":{"shape":"S23"}}},"output":{"resultWrapper":"ModifyDBSubnetGroupResult","type":"structure","members":{"DBSubnetGroup":{"shape":"S1m"}}}},"ModifyEventSubscription":{"input":{"type":"structure","required":["SubscriptionName"],"members":{"SubscriptionName":{},"SnsTopicArn":{},"SourceType":{},"EventCategories":{"shape":"S7"},"Enabled":{"type":"boolean"}}},"output":{"resultWrapper":"ModifyEventSubscriptionResult","type":"structure","members":{"EventSubscription":{"shape":"S5"}}}},"PromoteReadReplicaDBCluster":{"input":{"type":"structure","required":["DBClusterIdentifier"],"members":{"DBClusterIdentifier":{}}},"output":{"resultWrapper":"PromoteReadReplicaDBClusterResult","type":"structure","members":{"DBCluster":{"shape":"Sz"}}}},"RebootDBInstance":{"input":{"type":"structure","required":["DBInstanceIdentifier"],"members":{"DBInstanceIdentifier":{},"ForceFailover":{"type":"boolean"}}},"output":{"resultWrapper":"RebootDBInstanceResult","type":"structure","members":{"DBInstance":{"shape":"S1g"}}}},"RemoveRoleFromDBCluster":{"input":{"type":"structure","required":["DBClusterIdentifier","RoleArn"],"members":{"DBClusterIdentifier":{},"RoleArn":{}}}},"RemoveSourceIdentifierFromSubscription":{"input":{"type":"structure","required":["SubscriptionName","SourceIdentifier"],"members":{"SubscriptionName":{},"SourceIdentifier":{}}},"output":{"resultWrapper":"RemoveSourceIdentifierFromSubscriptionResult","type":"structure","members":{"EventSubscription":{"shape":"S5"}}}},"RemoveTagsFromResource":{"input":{"type":"structure","required":["ResourceName","TagKeys"],"members":{"ResourceName":{},"TagKeys":{"type":"list","member":{}}}}},"ResetDBClusterParameterGroup":{"input":{"type":"structure","required":["DBClusterParameterGroupName"],"members":{"DBClusterParameterGroupName":{},"ResetAllParameters":{"type":"boolean"},"Parameters":{"shape":"S2q"}}},"output":{"shape":"S4y","resultWrapper":"ResetDBClusterParameterGroupResult"}},"ResetDBParameterGroup":{"input":{"type":"structure","required":["DBParameterGroupName"],"members":{"DBParameterGroupName":{},"ResetAllParameters":{"type":"boolean"},"Parameters":{"shape":"S2q"}}},"output":{"shape":"S54","resultWrapper":"ResetDBParameterGroupResult"}},"RestoreDBClusterFromSnapshot":{"input":{"type":"structure","required":["DBClusterIdentifier","SnapshotIdentifier","Engine"],"members":{"AvailabilityZones":{"shape":"Sp"},"DBClusterIdentifier":{},"SnapshotIdentifier":{},"Engine":{},"EngineVersion":{},"Port":{"type":"integer"},"DBSubnetGroupName":{},"DatabaseName":{},"OptionGroupName":{},"VpcSecurityGroupIds":{"shape":"Sw"},"Tags":{"shape":"Sa"},"KmsKeyId":{},"EnableIAMDatabaseAuthentication":{"type":"boolean"},"EnableCloudwatchLogsExports":{"shape":"Sx"},"DBClusterParameterGroupName":{},"DeletionProtection":{"type":"boolean"}}},"output":{"resultWrapper":"RestoreDBClusterFromSnapshotResult","type":"structure","members":{"DBCluster":{"shape":"Sz"}}}},"RestoreDBClusterToPointInTime":{"input":{"type":"structure","required":["DBClusterIdentifier","SourceDBClusterIdentifier"],"members":{"DBClusterIdentifier":{},"RestoreType":{},"SourceDBClusterIdentifier":{},"RestoreToTime":{"type":"timestamp"},"UseLatestRestorableTime":{"type":"boolean"},"Port":{"type":"integer"},"DBSubnetGroupName":{},"OptionGroupName":{},"VpcSecurityGroupIds":{"shape":"Sw"},"Tags":{"shape":"Sa"},"KmsKeyId":{},"EnableIAMDatabaseAuthentication":{"type":"boolean"},"EnableCloudwatchLogsExports":{"shape":"Sx"},"DBClusterParameterGroupName":{},"DeletionProtection":{"type":"boolean"}}},"output":{"resultWrapper":"RestoreDBClusterToPointInTimeResult","type":"structure","members":{"DBCluster":{"shape":"Sz"}}}},"StartDBCluster":{"input":{"type":"structure","required":["DBClusterIdentifier"],"members":{"DBClusterIdentifier":{}}},"output":{"resultWrapper":"StartDBClusterResult","type":"structure","members":{"DBCluster":{"shape":"Sz"}}}},"StopDBCluster":{"input":{"type":"structure","required":["DBClusterIdentifier"],"members":{"DBClusterIdentifier":{}}},"output":{"resultWrapper":"StopDBClusterResult","type":"structure","members":{"DBCluster":{"shape":"Sz"}}}}},"shapes":{"S5":{"type":"structure","members":{"CustomerAwsId":{},"CustSubscriptionId":{},"SnsTopicArn":{},"Status":{},"SubscriptionCreationTime":{},"SourceType":{},"SourceIdsList":{"shape":"S6"},"EventCategoriesList":{"shape":"S7"},"Enabled":{"type":"boolean"},"EventSubscriptionArn":{}},"wrapper":true},"S6":{"type":"list","member":{"locationName":"SourceId"}},"S7":{"type":"list","member":{"locationName":"EventCategory"}},"Sa":{"type":"list","member":{"locationName":"Tag","type":"structure","members":{"Key":{},"Value":{}}}},"Se":{"type":"structure","members":{"ResourceIdentifier":{},"PendingMaintenanceActionDetails":{"type":"list","member":{"locationName":"PendingMaintenanceAction","type":"structure","members":{"Action":{},"AutoAppliedAfterDate":{"type":"timestamp"},"ForcedApplyDate":{"type":"timestamp"},"OptInStatus":{},"CurrentApplyDate":{"type":"timestamp"},"Description":{}}}}},"wrapper":true},"Sk":{"type":"structure","members":{"DBClusterParameterGroupName":{},"DBParameterGroupFamily":{},"Description":{},"DBClusterParameterGroupArn":{}},"wrapper":true},"So":{"type":"structure","members":{"AvailabilityZones":{"shape":"Sp"},"DBClusterSnapshotIdentifier":{},"DBClusterIdentifier":{},"SnapshotCreateTime":{"type":"timestamp"},"Engine":{},"AllocatedStorage":{"type":"integer"},"Status":{},"Port":{"type":"integer"},"VpcId":{},"ClusterCreateTime":{"type":"timestamp"},"MasterUsername":{},"EngineVersion":{},"LicenseModel":{},"SnapshotType":{},"PercentProgress":{"type":"integer"},"StorageEncrypted":{"type":"boolean"},"KmsKeyId":{},"DBClusterSnapshotArn":{},"SourceDBClusterSnapshotArn":{},"IAMDatabaseAuthenticationEnabled":{"type":"boolean"}},"wrapper":true},"Sp":{"type":"list","member":{"locationName":"AvailabilityZone"}},"St":{"type":"structure","members":{"DBParameterGroupName":{},"DBParameterGroupFamily":{},"Description":{},"DBParameterGroupArn":{}},"wrapper":true},"Sw":{"type":"list","member":{"locationName":"VpcSecurityGroupId"}},"Sx":{"type":"list","member":{}},"Sz":{"type":"structure","members":{"AllocatedStorage":{"type":"integer"},"AvailabilityZones":{"shape":"Sp"},"BackupRetentionPeriod":{"type":"integer"},"CharacterSetName":{},"DatabaseName":{},"DBClusterIdentifier":{},"DBClusterParameterGroup":{},"DBSubnetGroup":{},"Status":{},"PercentProgress":{},"EarliestRestorableTime":{"type":"timestamp"},"Endpoint":{},"ReaderEndpoint":{},"MultiAZ":{"type":"boolean"},"Engine":{},"EngineVersion":{},"LatestRestorableTime":{"type":"timestamp"},"Port":{"type":"integer"},"MasterUsername":{},"DBClusterOptionGroupMemberships":{"type":"list","member":{"locationName":"DBClusterOptionGroup","type":"structure","members":{"DBClusterOptionGroupName":{},"Status":{}}}},"PreferredBackupWindow":{},"PreferredMaintenanceWindow":{},"ReplicationSourceIdentifier":{},"ReadReplicaIdentifiers":{"type":"list","member":{"locationName":"ReadReplicaIdentifier"}},"DBClusterMembers":{"type":"list","member":{"locationName":"DBClusterMember","type":"structure","members":{"DBInstanceIdentifier":{},"IsClusterWriter":{"type":"boolean"},"DBClusterParameterGroupStatus":{},"PromotionTier":{"type":"integer"}},"wrapper":true}},"VpcSecurityGroups":{"shape":"S15"},"HostedZoneId":{},"StorageEncrypted":{"type":"boolean"},"KmsKeyId":{},"DbClusterResourceId":{},"DBClusterArn":{},"AssociatedRoles":{"type":"list","member":{"locationName":"DBClusterRole","type":"structure","members":{"RoleArn":{},"Status":{}}}},"IAMDatabaseAuthenticationEnabled":{"type":"boolean"},"CloneGroupId":{},"ClusterCreateTime":{"type":"timestamp"},"EnabledCloudwatchLogsExports":{"shape":"Sx"},"DeletionProtection":{"type":"boolean"}},"wrapper":true},"S15":{"type":"list","member":{"locationName":"VpcSecurityGroupMembership","type":"structure","members":{"VpcSecurityGroupId":{},"Status":{}}}},"S1e":{"type":"list","member":{"locationName":"DBSecurityGroupName"}},"S1g":{"type":"structure","members":{"DBInstanceIdentifier":{},"DBInstanceClass":{},"Engine":{},"DBInstanceStatus":{},"MasterUsername":{},"DBName":{},"Endpoint":{"type":"structure","members":{"Address":{},"Port":{"type":"integer"},"HostedZoneId":{}}},"AllocatedStorage":{"type":"integer"},"InstanceCreateTime":{"type":"timestamp"},"PreferredBackupWindow":{},"BackupRetentionPeriod":{"type":"integer"},"DBSecurityGroups":{"type":"list","member":{"locationName":"DBSecurityGroup","type":"structure","members":{"DBSecurityGroupName":{},"Status":{}}}},"VpcSecurityGroups":{"shape":"S15"},"DBParameterGroups":{"type":"list","member":{"locationName":"DBParameterGroup","type":"structure","members":{"DBParameterGroupName":{},"ParameterApplyStatus":{}}}},"AvailabilityZone":{},"DBSubnetGroup":{"shape":"S1m"},"PreferredMaintenanceWindow":{},"PendingModifiedValues":{"type":"structure","members":{"DBInstanceClass":{},"AllocatedStorage":{"type":"integer"},"MasterUserPassword":{},"Port":{"type":"integer"},"BackupRetentionPeriod":{"type":"integer"},"MultiAZ":{"type":"boolean"},"EngineVersion":{},"LicenseModel":{},"Iops":{"type":"integer"},"DBInstanceIdentifier":{},"StorageType":{},"CACertificateIdentifier":{},"DBSubnetGroupName":{},"PendingCloudwatchLogsExports":{"type":"structure","members":{"LogTypesToEnable":{"shape":"Sx"},"LogTypesToDisable":{"shape":"Sx"}}}}},"LatestRestorableTime":{"type":"timestamp"},"MultiAZ":{"type":"boolean"},"EngineVersion":{},"AutoMinorVersionUpgrade":{"type":"boolean"},"ReadReplicaSourceDBInstanceIdentifier":{},"ReadReplicaDBInstanceIdentifiers":{"type":"list","member":{"locationName":"ReadReplicaDBInstanceIdentifier"}},"ReadReplicaDBClusterIdentifiers":{"type":"list","member":{"locationName":"ReadReplicaDBClusterIdentifier"}},"LicenseModel":{},"Iops":{"type":"integer"},"OptionGroupMemberships":{"type":"list","member":{"locationName":"OptionGroupMembership","type":"structure","members":{"OptionGroupName":{},"Status":{}}}},"CharacterSetName":{},"SecondaryAvailabilityZone":{},"PubliclyAccessible":{"deprecated":true,"type":"boolean"},"StatusInfos":{"type":"list","member":{"locationName":"DBInstanceStatusInfo","type":"structure","members":{"StatusType":{},"Normal":{"type":"boolean"},"Status":{},"Message":{}}}},"StorageType":{},"TdeCredentialArn":{},"DbInstancePort":{"type":"integer"},"DBClusterIdentifier":{},"StorageEncrypted":{"type":"boolean"},"KmsKeyId":{},"DbiResourceId":{},"CACertificateIdentifier":{},"DomainMemberships":{"type":"list","member":{"locationName":"DomainMembership","type":"structure","members":{"Domain":{},"Status":{},"FQDN":{},"IAMRoleName":{}}}},"CopyTagsToSnapshot":{"type":"boolean"},"MonitoringInterval":{"type":"integer"},"EnhancedMonitoringResourceArn":{},"MonitoringRoleArn":{},"PromotionTier":{"type":"integer"},"DBInstanceArn":{},"Timezone":{},"IAMDatabaseAuthenticationEnabled":{"type":"boolean"},"PerformanceInsightsEnabled":{"type":"boolean"},"PerformanceInsightsKMSKeyId":{},"EnabledCloudwatchLogsExports":{"shape":"Sx"},"DeletionProtection":{"type":"boolean"}},"wrapper":true},"S1m":{"type":"structure","members":{"DBSubnetGroupName":{},"DBSubnetGroupDescription":{},"VpcId":{},"SubnetGroupStatus":{},"Subnets":{"type":"list","member":{"locationName":"Subnet","type":"structure","members":{"SubnetIdentifier":{},"SubnetAvailabilityZone":{"shape":"S1p"},"SubnetStatus":{}}}},"DBSubnetGroupArn":{}},"wrapper":true},"S1p":{"type":"structure","members":{"Name":{}},"wrapper":true},"S23":{"type":"list","member":{"locationName":"SubnetIdentifier"}},"S2j":{"type":"list","member":{"locationName":"Filter","type":"structure","required":["Name","Values"],"members":{"Name":{},"Values":{"type":"list","member":{"locationName":"Value"}}}}},"S2q":{"type":"list","member":{"locationName":"Parameter","type":"structure","members":{"ParameterName":{},"ParameterValue":{},"Description":{},"Source":{},"ApplyType":{},"DataType":{},"AllowedValues":{},"IsModifiable":{"type":"boolean"},"MinimumEngineVersion":{},"ApplyMethod":{}}}},"S2v":{"type":"structure","members":{"DBClusterSnapshotIdentifier":{},"DBClusterSnapshotAttributes":{"type":"list","member":{"locationName":"DBClusterSnapshotAttribute","type":"structure","members":{"AttributeName":{},"AttributeValues":{"shape":"S2y"}}}}},"wrapper":true},"S2y":{"type":"list","member":{"locationName":"AttributeValue"}},"S39":{"type":"structure","members":{"CharacterSetName":{},"CharacterSetDescription":{}}},"S3s":{"type":"structure","members":{"DBParameterGroupFamily":{},"Marker":{},"Parameters":{"shape":"S2q"}},"wrapper":true},"S4l":{"type":"list","member":{"locationName":"Range","type":"structure","members":{"From":{"type":"integer"},"To":{"type":"integer"},"Step":{"type":"integer"}}}},"S4v":{"type":"structure","members":{"EnableLogTypes":{"shape":"Sx"},"DisableLogTypes":{"shape":"Sx"}}},"S4y":{"type":"structure","members":{"DBClusterParameterGroupName":{}}},"S54":{"type":"structure","members":{"DBParameterGroupName":{}}}}}; - -/***/ }), - -/***/ 1413: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2014-09-01","endpointPrefix":"rds","protocol":"query","serviceAbbreviation":"Amazon RDS","serviceFullName":"Amazon Relational Database Service","serviceId":"RDS","signatureVersion":"v4","uid":"rds-2014-09-01","xmlNamespace":"http://rds.amazonaws.com/doc/2014-09-01/"},"operations":{"AddSourceIdentifierToSubscription":{"input":{"type":"structure","required":["SubscriptionName","SourceIdentifier"],"members":{"SubscriptionName":{},"SourceIdentifier":{}}},"output":{"resultWrapper":"AddSourceIdentifierToSubscriptionResult","type":"structure","members":{"EventSubscription":{"shape":"S4"}}}},"AddTagsToResource":{"input":{"type":"structure","required":["ResourceName","Tags"],"members":{"ResourceName":{},"Tags":{"shape":"S9"}}}},"AuthorizeDBSecurityGroupIngress":{"input":{"type":"structure","required":["DBSecurityGroupName"],"members":{"DBSecurityGroupName":{},"CIDRIP":{},"EC2SecurityGroupName":{},"EC2SecurityGroupId":{},"EC2SecurityGroupOwnerId":{}}},"output":{"resultWrapper":"AuthorizeDBSecurityGroupIngressResult","type":"structure","members":{"DBSecurityGroup":{"shape":"Sd"}}}},"CopyDBParameterGroup":{"input":{"type":"structure","required":["SourceDBParameterGroupIdentifier","TargetDBParameterGroupIdentifier","TargetDBParameterGroupDescription"],"members":{"SourceDBParameterGroupIdentifier":{},"TargetDBParameterGroupIdentifier":{},"TargetDBParameterGroupDescription":{},"Tags":{"shape":"S9"}}},"output":{"resultWrapper":"CopyDBParameterGroupResult","type":"structure","members":{"DBParameterGroup":{"shape":"Sk"}}}},"CopyDBSnapshot":{"input":{"type":"structure","required":["SourceDBSnapshotIdentifier","TargetDBSnapshotIdentifier"],"members":{"SourceDBSnapshotIdentifier":{},"TargetDBSnapshotIdentifier":{},"Tags":{"shape":"S9"}}},"output":{"resultWrapper":"CopyDBSnapshotResult","type":"structure","members":{"DBSnapshot":{"shape":"Sn"}}}},"CopyOptionGroup":{"input":{"type":"structure","required":["SourceOptionGroupIdentifier","TargetOptionGroupIdentifier","TargetOptionGroupDescription"],"members":{"SourceOptionGroupIdentifier":{},"TargetOptionGroupIdentifier":{},"TargetOptionGroupDescription":{},"Tags":{"shape":"S9"}}},"output":{"resultWrapper":"CopyOptionGroupResult","type":"structure","members":{"OptionGroup":{"shape":"St"}}}},"CreateDBInstance":{"input":{"type":"structure","required":["DBInstanceIdentifier","AllocatedStorage","DBInstanceClass","Engine","MasterUsername","MasterUserPassword"],"members":{"DBName":{},"DBInstanceIdentifier":{},"AllocatedStorage":{"type":"integer"},"DBInstanceClass":{},"Engine":{},"MasterUsername":{},"MasterUserPassword":{},"DBSecurityGroups":{"shape":"S13"},"VpcSecurityGroupIds":{"shape":"S14"},"AvailabilityZone":{},"DBSubnetGroupName":{},"PreferredMaintenanceWindow":{},"DBParameterGroupName":{},"BackupRetentionPeriod":{"type":"integer"},"PreferredBackupWindow":{},"Port":{"type":"integer"},"MultiAZ":{"type":"boolean"},"EngineVersion":{},"AutoMinorVersionUpgrade":{"type":"boolean"},"LicenseModel":{},"Iops":{"type":"integer"},"OptionGroupName":{},"CharacterSetName":{},"PubliclyAccessible":{"type":"boolean"},"Tags":{"shape":"S9"},"StorageType":{},"TdeCredentialArn":{},"TdeCredentialPassword":{}}},"output":{"resultWrapper":"CreateDBInstanceResult","type":"structure","members":{"DBInstance":{"shape":"S17"}}}},"CreateDBInstanceReadReplica":{"input":{"type":"structure","required":["DBInstanceIdentifier","SourceDBInstanceIdentifier"],"members":{"DBInstanceIdentifier":{},"SourceDBInstanceIdentifier":{},"DBInstanceClass":{},"AvailabilityZone":{},"Port":{"type":"integer"},"AutoMinorVersionUpgrade":{"type":"boolean"},"Iops":{"type":"integer"},"OptionGroupName":{},"PubliclyAccessible":{"type":"boolean"},"Tags":{"shape":"S9"},"DBSubnetGroupName":{},"StorageType":{}}},"output":{"resultWrapper":"CreateDBInstanceReadReplicaResult","type":"structure","members":{"DBInstance":{"shape":"S17"}}}},"CreateDBParameterGroup":{"input":{"type":"structure","required":["DBParameterGroupName","DBParameterGroupFamily","Description"],"members":{"DBParameterGroupName":{},"DBParameterGroupFamily":{},"Description":{},"Tags":{"shape":"S9"}}},"output":{"resultWrapper":"CreateDBParameterGroupResult","type":"structure","members":{"DBParameterGroup":{"shape":"Sk"}}}},"CreateDBSecurityGroup":{"input":{"type":"structure","required":["DBSecurityGroupName","DBSecurityGroupDescription"],"members":{"DBSecurityGroupName":{},"DBSecurityGroupDescription":{},"Tags":{"shape":"S9"}}},"output":{"resultWrapper":"CreateDBSecurityGroupResult","type":"structure","members":{"DBSecurityGroup":{"shape":"Sd"}}}},"CreateDBSnapshot":{"input":{"type":"structure","required":["DBSnapshotIdentifier","DBInstanceIdentifier"],"members":{"DBSnapshotIdentifier":{},"DBInstanceIdentifier":{},"Tags":{"shape":"S9"}}},"output":{"resultWrapper":"CreateDBSnapshotResult","type":"structure","members":{"DBSnapshot":{"shape":"Sn"}}}},"CreateDBSubnetGroup":{"input":{"type":"structure","required":["DBSubnetGroupName","DBSubnetGroupDescription","SubnetIds"],"members":{"DBSubnetGroupName":{},"DBSubnetGroupDescription":{},"SubnetIds":{"shape":"S1u"},"Tags":{"shape":"S9"}}},"output":{"resultWrapper":"CreateDBSubnetGroupResult","type":"structure","members":{"DBSubnetGroup":{"shape":"S1b"}}}},"CreateEventSubscription":{"input":{"type":"structure","required":["SubscriptionName","SnsTopicArn"],"members":{"SubscriptionName":{},"SnsTopicArn":{},"SourceType":{},"EventCategories":{"shape":"S6"},"SourceIds":{"shape":"S5"},"Enabled":{"type":"boolean"},"Tags":{"shape":"S9"}}},"output":{"resultWrapper":"CreateEventSubscriptionResult","type":"structure","members":{"EventSubscription":{"shape":"S4"}}}},"CreateOptionGroup":{"input":{"type":"structure","required":["OptionGroupName","EngineName","MajorEngineVersion","OptionGroupDescription"],"members":{"OptionGroupName":{},"EngineName":{},"MajorEngineVersion":{},"OptionGroupDescription":{},"Tags":{"shape":"S9"}}},"output":{"resultWrapper":"CreateOptionGroupResult","type":"structure","members":{"OptionGroup":{"shape":"St"}}}},"DeleteDBInstance":{"input":{"type":"structure","required":["DBInstanceIdentifier"],"members":{"DBInstanceIdentifier":{},"SkipFinalSnapshot":{"type":"boolean"},"FinalDBSnapshotIdentifier":{}}},"output":{"resultWrapper":"DeleteDBInstanceResult","type":"structure","members":{"DBInstance":{"shape":"S17"}}}},"DeleteDBParameterGroup":{"input":{"type":"structure","required":["DBParameterGroupName"],"members":{"DBParameterGroupName":{}}}},"DeleteDBSecurityGroup":{"input":{"type":"structure","required":["DBSecurityGroupName"],"members":{"DBSecurityGroupName":{}}}},"DeleteDBSnapshot":{"input":{"type":"structure","required":["DBSnapshotIdentifier"],"members":{"DBSnapshotIdentifier":{}}},"output":{"resultWrapper":"DeleteDBSnapshotResult","type":"structure","members":{"DBSnapshot":{"shape":"Sn"}}}},"DeleteDBSubnetGroup":{"input":{"type":"structure","required":["DBSubnetGroupName"],"members":{"DBSubnetGroupName":{}}}},"DeleteEventSubscription":{"input":{"type":"structure","required":["SubscriptionName"],"members":{"SubscriptionName":{}}},"output":{"resultWrapper":"DeleteEventSubscriptionResult","type":"structure","members":{"EventSubscription":{"shape":"S4"}}}},"DeleteOptionGroup":{"input":{"type":"structure","required":["OptionGroupName"],"members":{"OptionGroupName":{}}}},"DescribeDBEngineVersions":{"input":{"type":"structure","members":{"Engine":{},"EngineVersion":{},"DBParameterGroupFamily":{},"Filters":{"shape":"S2b"},"MaxRecords":{"type":"integer"},"Marker":{},"DefaultOnly":{"type":"boolean"},"ListSupportedCharacterSets":{"type":"boolean"}}},"output":{"resultWrapper":"DescribeDBEngineVersionsResult","type":"structure","members":{"Marker":{},"DBEngineVersions":{"type":"list","member":{"locationName":"DBEngineVersion","type":"structure","members":{"Engine":{},"EngineVersion":{},"DBParameterGroupFamily":{},"DBEngineDescription":{},"DBEngineVersionDescription":{},"DefaultCharacterSet":{"shape":"S2h"},"SupportedCharacterSets":{"type":"list","member":{"shape":"S2h","locationName":"CharacterSet"}}}}}}}},"DescribeDBInstances":{"input":{"type":"structure","members":{"DBInstanceIdentifier":{},"Filters":{"shape":"S2b"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeDBInstancesResult","type":"structure","members":{"Marker":{},"DBInstances":{"type":"list","member":{"shape":"S17","locationName":"DBInstance"}}}}},"DescribeDBLogFiles":{"input":{"type":"structure","required":["DBInstanceIdentifier"],"members":{"DBInstanceIdentifier":{},"FilenameContains":{},"FileLastWritten":{"type":"long"},"FileSize":{"type":"long"},"Filters":{"shape":"S2b"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeDBLogFilesResult","type":"structure","members":{"DescribeDBLogFiles":{"type":"list","member":{"locationName":"DescribeDBLogFilesDetails","type":"structure","members":{"LogFileName":{},"LastWritten":{"type":"long"},"Size":{"type":"long"}}}},"Marker":{}}}},"DescribeDBParameterGroups":{"input":{"type":"structure","members":{"DBParameterGroupName":{},"Filters":{"shape":"S2b"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeDBParameterGroupsResult","type":"structure","members":{"Marker":{},"DBParameterGroups":{"type":"list","member":{"shape":"Sk","locationName":"DBParameterGroup"}}}}},"DescribeDBParameters":{"input":{"type":"structure","required":["DBParameterGroupName"],"members":{"DBParameterGroupName":{},"Source":{},"Filters":{"shape":"S2b"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeDBParametersResult","type":"structure","members":{"Parameters":{"shape":"S2w"},"Marker":{}}}},"DescribeDBSecurityGroups":{"input":{"type":"structure","members":{"DBSecurityGroupName":{},"Filters":{"shape":"S2b"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeDBSecurityGroupsResult","type":"structure","members":{"Marker":{},"DBSecurityGroups":{"type":"list","member":{"shape":"Sd","locationName":"DBSecurityGroup"}}}}},"DescribeDBSnapshots":{"input":{"type":"structure","members":{"DBInstanceIdentifier":{},"DBSnapshotIdentifier":{},"SnapshotType":{},"Filters":{"shape":"S2b"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeDBSnapshotsResult","type":"structure","members":{"Marker":{},"DBSnapshots":{"type":"list","member":{"shape":"Sn","locationName":"DBSnapshot"}}}}},"DescribeDBSubnetGroups":{"input":{"type":"structure","members":{"DBSubnetGroupName":{},"Filters":{"shape":"S2b"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeDBSubnetGroupsResult","type":"structure","members":{"Marker":{},"DBSubnetGroups":{"type":"list","member":{"shape":"S1b","locationName":"DBSubnetGroup"}}}}},"DescribeEngineDefaultParameters":{"input":{"type":"structure","required":["DBParameterGroupFamily"],"members":{"DBParameterGroupFamily":{},"Filters":{"shape":"S2b"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeEngineDefaultParametersResult","type":"structure","members":{"EngineDefaults":{"type":"structure","members":{"DBParameterGroupFamily":{},"Marker":{},"Parameters":{"shape":"S2w"}},"wrapper":true}}}},"DescribeEventCategories":{"input":{"type":"structure","members":{"SourceType":{},"Filters":{"shape":"S2b"}}},"output":{"resultWrapper":"DescribeEventCategoriesResult","type":"structure","members":{"EventCategoriesMapList":{"type":"list","member":{"locationName":"EventCategoriesMap","type":"structure","members":{"SourceType":{},"EventCategories":{"shape":"S6"}},"wrapper":true}}}}},"DescribeEventSubscriptions":{"input":{"type":"structure","members":{"SubscriptionName":{},"Filters":{"shape":"S2b"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeEventSubscriptionsResult","type":"structure","members":{"Marker":{},"EventSubscriptionsList":{"type":"list","member":{"shape":"S4","locationName":"EventSubscription"}}}}},"DescribeEvents":{"input":{"type":"structure","members":{"SourceIdentifier":{},"SourceType":{},"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"Duration":{"type":"integer"},"EventCategories":{"shape":"S6"},"Filters":{"shape":"S2b"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeEventsResult","type":"structure","members":{"Marker":{},"Events":{"type":"list","member":{"locationName":"Event","type":"structure","members":{"SourceIdentifier":{},"SourceType":{},"Message":{},"EventCategories":{"shape":"S6"},"Date":{"type":"timestamp"}}}}}}},"DescribeOptionGroupOptions":{"input":{"type":"structure","required":["EngineName"],"members":{"EngineName":{},"MajorEngineVersion":{},"Filters":{"shape":"S2b"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeOptionGroupOptionsResult","type":"structure","members":{"OptionGroupOptions":{"type":"list","member":{"locationName":"OptionGroupOption","type":"structure","members":{"Name":{},"Description":{},"EngineName":{},"MajorEngineVersion":{},"MinimumRequiredMinorEngineVersion":{},"PortRequired":{"type":"boolean"},"DefaultPort":{"type":"integer"},"OptionsDependedOn":{"type":"list","member":{"locationName":"OptionName"}},"Persistent":{"type":"boolean"},"Permanent":{"type":"boolean"},"OptionGroupOptionSettings":{"type":"list","member":{"locationName":"OptionGroupOptionSetting","type":"structure","members":{"SettingName":{},"SettingDescription":{},"DefaultValue":{},"ApplyType":{},"AllowedValues":{},"IsModifiable":{"type":"boolean"}}}}}}},"Marker":{}}}},"DescribeOptionGroups":{"input":{"type":"structure","members":{"OptionGroupName":{},"Filters":{"shape":"S2b"},"Marker":{},"MaxRecords":{"type":"integer"},"EngineName":{},"MajorEngineVersion":{}}},"output":{"resultWrapper":"DescribeOptionGroupsResult","type":"structure","members":{"OptionGroupsList":{"type":"list","member":{"shape":"St","locationName":"OptionGroup"}},"Marker":{}}}},"DescribeOrderableDBInstanceOptions":{"input":{"type":"structure","required":["Engine"],"members":{"Engine":{},"EngineVersion":{},"DBInstanceClass":{},"LicenseModel":{},"Vpc":{"type":"boolean"},"Filters":{"shape":"S2b"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeOrderableDBInstanceOptionsResult","type":"structure","members":{"OrderableDBInstanceOptions":{"type":"list","member":{"locationName":"OrderableDBInstanceOption","type":"structure","members":{"Engine":{},"EngineVersion":{},"DBInstanceClass":{},"LicenseModel":{},"AvailabilityZones":{"type":"list","member":{"shape":"S1e","locationName":"AvailabilityZone"}},"MultiAZCapable":{"type":"boolean"},"ReadReplicaCapable":{"type":"boolean"},"Vpc":{"type":"boolean"},"StorageType":{},"SupportsIops":{"type":"boolean"}},"wrapper":true}},"Marker":{}}}},"DescribeReservedDBInstances":{"input":{"type":"structure","members":{"ReservedDBInstanceId":{},"ReservedDBInstancesOfferingId":{},"DBInstanceClass":{},"Duration":{},"ProductDescription":{},"OfferingType":{},"MultiAZ":{"type":"boolean"},"Filters":{"shape":"S2b"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeReservedDBInstancesResult","type":"structure","members":{"Marker":{},"ReservedDBInstances":{"type":"list","member":{"shape":"S45","locationName":"ReservedDBInstance"}}}}},"DescribeReservedDBInstancesOfferings":{"input":{"type":"structure","members":{"ReservedDBInstancesOfferingId":{},"DBInstanceClass":{},"Duration":{},"ProductDescription":{},"OfferingType":{},"MultiAZ":{"type":"boolean"},"Filters":{"shape":"S2b"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeReservedDBInstancesOfferingsResult","type":"structure","members":{"Marker":{},"ReservedDBInstancesOfferings":{"type":"list","member":{"locationName":"ReservedDBInstancesOffering","type":"structure","members":{"ReservedDBInstancesOfferingId":{},"DBInstanceClass":{},"Duration":{"type":"integer"},"FixedPrice":{"type":"double"},"UsagePrice":{"type":"double"},"CurrencyCode":{},"ProductDescription":{},"OfferingType":{},"MultiAZ":{"type":"boolean"},"RecurringCharges":{"shape":"S47"}},"wrapper":true}}}}},"DownloadDBLogFilePortion":{"input":{"type":"structure","required":["DBInstanceIdentifier","LogFileName"],"members":{"DBInstanceIdentifier":{},"LogFileName":{},"Marker":{},"NumberOfLines":{"type":"integer"}}},"output":{"resultWrapper":"DownloadDBLogFilePortionResult","type":"structure","members":{"LogFileData":{},"Marker":{},"AdditionalDataPending":{"type":"boolean"}}}},"ListTagsForResource":{"input":{"type":"structure","required":["ResourceName"],"members":{"ResourceName":{},"Filters":{"shape":"S2b"}}},"output":{"resultWrapper":"ListTagsForResourceResult","type":"structure","members":{"TagList":{"shape":"S9"}}}},"ModifyDBInstance":{"input":{"type":"structure","required":["DBInstanceIdentifier"],"members":{"DBInstanceIdentifier":{},"AllocatedStorage":{"type":"integer"},"DBInstanceClass":{},"DBSecurityGroups":{"shape":"S13"},"VpcSecurityGroupIds":{"shape":"S14"},"ApplyImmediately":{"type":"boolean"},"MasterUserPassword":{},"DBParameterGroupName":{},"BackupRetentionPeriod":{"type":"integer"},"PreferredBackupWindow":{},"PreferredMaintenanceWindow":{},"MultiAZ":{"type":"boolean"},"EngineVersion":{},"AllowMajorVersionUpgrade":{"type":"boolean"},"AutoMinorVersionUpgrade":{"type":"boolean"},"Iops":{"type":"integer"},"OptionGroupName":{},"NewDBInstanceIdentifier":{},"StorageType":{},"TdeCredentialArn":{},"TdeCredentialPassword":{}}},"output":{"resultWrapper":"ModifyDBInstanceResult","type":"structure","members":{"DBInstance":{"shape":"S17"}}}},"ModifyDBParameterGroup":{"input":{"type":"structure","required":["DBParameterGroupName","Parameters"],"members":{"DBParameterGroupName":{},"Parameters":{"shape":"S2w"}}},"output":{"shape":"S4k","resultWrapper":"ModifyDBParameterGroupResult"}},"ModifyDBSubnetGroup":{"input":{"type":"structure","required":["DBSubnetGroupName","SubnetIds"],"members":{"DBSubnetGroupName":{},"DBSubnetGroupDescription":{},"SubnetIds":{"shape":"S1u"}}},"output":{"resultWrapper":"ModifyDBSubnetGroupResult","type":"structure","members":{"DBSubnetGroup":{"shape":"S1b"}}}},"ModifyEventSubscription":{"input":{"type":"structure","required":["SubscriptionName"],"members":{"SubscriptionName":{},"SnsTopicArn":{},"SourceType":{},"EventCategories":{"shape":"S6"},"Enabled":{"type":"boolean"}}},"output":{"resultWrapper":"ModifyEventSubscriptionResult","type":"structure","members":{"EventSubscription":{"shape":"S4"}}}},"ModifyOptionGroup":{"input":{"type":"structure","required":["OptionGroupName"],"members":{"OptionGroupName":{},"OptionsToInclude":{"type":"list","member":{"locationName":"OptionConfiguration","type":"structure","required":["OptionName"],"members":{"OptionName":{},"Port":{"type":"integer"},"DBSecurityGroupMemberships":{"shape":"S13"},"VpcSecurityGroupMemberships":{"shape":"S14"},"OptionSettings":{"type":"list","member":{"shape":"Sx","locationName":"OptionSetting"}}}}},"OptionsToRemove":{"type":"list","member":{}},"ApplyImmediately":{"type":"boolean"}}},"output":{"resultWrapper":"ModifyOptionGroupResult","type":"structure","members":{"OptionGroup":{"shape":"St"}}}},"PromoteReadReplica":{"input":{"type":"structure","required":["DBInstanceIdentifier"],"members":{"DBInstanceIdentifier":{},"BackupRetentionPeriod":{"type":"integer"},"PreferredBackupWindow":{}}},"output":{"resultWrapper":"PromoteReadReplicaResult","type":"structure","members":{"DBInstance":{"shape":"S17"}}}},"PurchaseReservedDBInstancesOffering":{"input":{"type":"structure","required":["ReservedDBInstancesOfferingId"],"members":{"ReservedDBInstancesOfferingId":{},"ReservedDBInstanceId":{},"DBInstanceCount":{"type":"integer"},"Tags":{"shape":"S9"}}},"output":{"resultWrapper":"PurchaseReservedDBInstancesOfferingResult","type":"structure","members":{"ReservedDBInstance":{"shape":"S45"}}}},"RebootDBInstance":{"input":{"type":"structure","required":["DBInstanceIdentifier"],"members":{"DBInstanceIdentifier":{},"ForceFailover":{"type":"boolean"}}},"output":{"resultWrapper":"RebootDBInstanceResult","type":"structure","members":{"DBInstance":{"shape":"S17"}}}},"RemoveSourceIdentifierFromSubscription":{"input":{"type":"structure","required":["SubscriptionName","SourceIdentifier"],"members":{"SubscriptionName":{},"SourceIdentifier":{}}},"output":{"resultWrapper":"RemoveSourceIdentifierFromSubscriptionResult","type":"structure","members":{"EventSubscription":{"shape":"S4"}}}},"RemoveTagsFromResource":{"input":{"type":"structure","required":["ResourceName","TagKeys"],"members":{"ResourceName":{},"TagKeys":{"type":"list","member":{}}}}},"ResetDBParameterGroup":{"input":{"type":"structure","required":["DBParameterGroupName"],"members":{"DBParameterGroupName":{},"ResetAllParameters":{"type":"boolean"},"Parameters":{"shape":"S2w"}}},"output":{"shape":"S4k","resultWrapper":"ResetDBParameterGroupResult"}},"RestoreDBInstanceFromDBSnapshot":{"input":{"type":"structure","required":["DBInstanceIdentifier","DBSnapshotIdentifier"],"members":{"DBInstanceIdentifier":{},"DBSnapshotIdentifier":{},"DBInstanceClass":{},"Port":{"type":"integer"},"AvailabilityZone":{},"DBSubnetGroupName":{},"MultiAZ":{"type":"boolean"},"PubliclyAccessible":{"type":"boolean"},"AutoMinorVersionUpgrade":{"type":"boolean"},"LicenseModel":{},"DBName":{},"Engine":{},"Iops":{"type":"integer"},"OptionGroupName":{},"Tags":{"shape":"S9"},"StorageType":{},"TdeCredentialArn":{},"TdeCredentialPassword":{}}},"output":{"resultWrapper":"RestoreDBInstanceFromDBSnapshotResult","type":"structure","members":{"DBInstance":{"shape":"S17"}}}},"RestoreDBInstanceToPointInTime":{"input":{"type":"structure","required":["SourceDBInstanceIdentifier","TargetDBInstanceIdentifier"],"members":{"SourceDBInstanceIdentifier":{},"TargetDBInstanceIdentifier":{},"RestoreTime":{"type":"timestamp"},"UseLatestRestorableTime":{"type":"boolean"},"DBInstanceClass":{},"Port":{"type":"integer"},"AvailabilityZone":{},"DBSubnetGroupName":{},"MultiAZ":{"type":"boolean"},"PubliclyAccessible":{"type":"boolean"},"AutoMinorVersionUpgrade":{"type":"boolean"},"LicenseModel":{},"DBName":{},"Engine":{},"Iops":{"type":"integer"},"OptionGroupName":{},"Tags":{"shape":"S9"},"StorageType":{},"TdeCredentialArn":{},"TdeCredentialPassword":{}}},"output":{"resultWrapper":"RestoreDBInstanceToPointInTimeResult","type":"structure","members":{"DBInstance":{"shape":"S17"}}}},"RevokeDBSecurityGroupIngress":{"input":{"type":"structure","required":["DBSecurityGroupName"],"members":{"DBSecurityGroupName":{},"CIDRIP":{},"EC2SecurityGroupName":{},"EC2SecurityGroupId":{},"EC2SecurityGroupOwnerId":{}}},"output":{"resultWrapper":"RevokeDBSecurityGroupIngressResult","type":"structure","members":{"DBSecurityGroup":{"shape":"Sd"}}}}},"shapes":{"S4":{"type":"structure","members":{"CustomerAwsId":{},"CustSubscriptionId":{},"SnsTopicArn":{},"Status":{},"SubscriptionCreationTime":{},"SourceType":{},"SourceIdsList":{"shape":"S5"},"EventCategoriesList":{"shape":"S6"},"Enabled":{"type":"boolean"}},"wrapper":true},"S5":{"type":"list","member":{"locationName":"SourceId"}},"S6":{"type":"list","member":{"locationName":"EventCategory"}},"S9":{"type":"list","member":{"locationName":"Tag","type":"structure","members":{"Key":{},"Value":{}}}},"Sd":{"type":"structure","members":{"OwnerId":{},"DBSecurityGroupName":{},"DBSecurityGroupDescription":{},"VpcId":{},"EC2SecurityGroups":{"type":"list","member":{"locationName":"EC2SecurityGroup","type":"structure","members":{"Status":{},"EC2SecurityGroupName":{},"EC2SecurityGroupId":{},"EC2SecurityGroupOwnerId":{}}}},"IPRanges":{"type":"list","member":{"locationName":"IPRange","type":"structure","members":{"Status":{},"CIDRIP":{}}}}},"wrapper":true},"Sk":{"type":"structure","members":{"DBParameterGroupName":{},"DBParameterGroupFamily":{},"Description":{}},"wrapper":true},"Sn":{"type":"structure","members":{"DBSnapshotIdentifier":{},"DBInstanceIdentifier":{},"SnapshotCreateTime":{"type":"timestamp"},"Engine":{},"AllocatedStorage":{"type":"integer"},"Status":{},"Port":{"type":"integer"},"AvailabilityZone":{},"VpcId":{},"InstanceCreateTime":{"type":"timestamp"},"MasterUsername":{},"EngineVersion":{},"LicenseModel":{},"SnapshotType":{},"Iops":{"type":"integer"},"OptionGroupName":{},"PercentProgress":{"type":"integer"},"SourceRegion":{},"StorageType":{},"TdeCredentialArn":{}},"wrapper":true},"St":{"type":"structure","members":{"OptionGroupName":{},"OptionGroupDescription":{},"EngineName":{},"MajorEngineVersion":{},"Options":{"type":"list","member":{"locationName":"Option","type":"structure","members":{"OptionName":{},"OptionDescription":{},"Persistent":{"type":"boolean"},"Permanent":{"type":"boolean"},"Port":{"type":"integer"},"OptionSettings":{"type":"list","member":{"shape":"Sx","locationName":"OptionSetting"}},"DBSecurityGroupMemberships":{"shape":"Sy"},"VpcSecurityGroupMemberships":{"shape":"S10"}}}},"AllowsVpcAndNonVpcInstanceMemberships":{"type":"boolean"},"VpcId":{}},"wrapper":true},"Sx":{"type":"structure","members":{"Name":{},"Value":{},"DefaultValue":{},"Description":{},"ApplyType":{},"DataType":{},"AllowedValues":{},"IsModifiable":{"type":"boolean"},"IsCollection":{"type":"boolean"}}},"Sy":{"type":"list","member":{"locationName":"DBSecurityGroup","type":"structure","members":{"DBSecurityGroupName":{},"Status":{}}}},"S10":{"type":"list","member":{"locationName":"VpcSecurityGroupMembership","type":"structure","members":{"VpcSecurityGroupId":{},"Status":{}}}},"S13":{"type":"list","member":{"locationName":"DBSecurityGroupName"}},"S14":{"type":"list","member":{"locationName":"VpcSecurityGroupId"}},"S17":{"type":"structure","members":{"DBInstanceIdentifier":{},"DBInstanceClass":{},"Engine":{},"DBInstanceStatus":{},"MasterUsername":{},"DBName":{},"Endpoint":{"type":"structure","members":{"Address":{},"Port":{"type":"integer"}}},"AllocatedStorage":{"type":"integer"},"InstanceCreateTime":{"type":"timestamp"},"PreferredBackupWindow":{},"BackupRetentionPeriod":{"type":"integer"},"DBSecurityGroups":{"shape":"Sy"},"VpcSecurityGroups":{"shape":"S10"},"DBParameterGroups":{"type":"list","member":{"locationName":"DBParameterGroup","type":"structure","members":{"DBParameterGroupName":{},"ParameterApplyStatus":{}}}},"AvailabilityZone":{},"DBSubnetGroup":{"shape":"S1b"},"PreferredMaintenanceWindow":{},"PendingModifiedValues":{"type":"structure","members":{"DBInstanceClass":{},"AllocatedStorage":{"type":"integer"},"MasterUserPassword":{},"Port":{"type":"integer"},"BackupRetentionPeriod":{"type":"integer"},"MultiAZ":{"type":"boolean"},"EngineVersion":{},"Iops":{"type":"integer"},"DBInstanceIdentifier":{},"StorageType":{}}},"LatestRestorableTime":{"type":"timestamp"},"MultiAZ":{"type":"boolean"},"EngineVersion":{},"AutoMinorVersionUpgrade":{"type":"boolean"},"ReadReplicaSourceDBInstanceIdentifier":{},"ReadReplicaDBInstanceIdentifiers":{"type":"list","member":{"locationName":"ReadReplicaDBInstanceIdentifier"}},"LicenseModel":{},"Iops":{"type":"integer"},"OptionGroupMemberships":{"type":"list","member":{"locationName":"OptionGroupMembership","type":"structure","members":{"OptionGroupName":{},"Status":{}}}},"CharacterSetName":{},"SecondaryAvailabilityZone":{},"PubliclyAccessible":{"type":"boolean"},"StatusInfos":{"type":"list","member":{"locationName":"DBInstanceStatusInfo","type":"structure","members":{"StatusType":{},"Normal":{"type":"boolean"},"Status":{},"Message":{}}}},"StorageType":{},"TdeCredentialArn":{}},"wrapper":true},"S1b":{"type":"structure","members":{"DBSubnetGroupName":{},"DBSubnetGroupDescription":{},"VpcId":{},"SubnetGroupStatus":{},"Subnets":{"type":"list","member":{"locationName":"Subnet","type":"structure","members":{"SubnetIdentifier":{},"SubnetAvailabilityZone":{"shape":"S1e"},"SubnetStatus":{}}}}},"wrapper":true},"S1e":{"type":"structure","members":{"Name":{}},"wrapper":true},"S1u":{"type":"list","member":{"locationName":"SubnetIdentifier"}},"S2b":{"type":"list","member":{"locationName":"Filter","type":"structure","required":["Name","Values"],"members":{"Name":{},"Values":{"type":"list","member":{"locationName":"Value"}}}}},"S2h":{"type":"structure","members":{"CharacterSetName":{},"CharacterSetDescription":{}}},"S2w":{"type":"list","member":{"locationName":"Parameter","type":"structure","members":{"ParameterName":{},"ParameterValue":{},"Description":{},"Source":{},"ApplyType":{},"DataType":{},"AllowedValues":{},"IsModifiable":{"type":"boolean"},"MinimumEngineVersion":{},"ApplyMethod":{}}}},"S45":{"type":"structure","members":{"ReservedDBInstanceId":{},"ReservedDBInstancesOfferingId":{},"DBInstanceClass":{},"StartTime":{"type":"timestamp"},"Duration":{"type":"integer"},"FixedPrice":{"type":"double"},"UsagePrice":{"type":"double"},"CurrencyCode":{},"DBInstanceCount":{"type":"integer"},"ProductDescription":{},"OfferingType":{},"MultiAZ":{"type":"boolean"},"State":{},"RecurringCharges":{"shape":"S47"}},"wrapper":true},"S47":{"type":"list","member":{"locationName":"RecurringCharge","type":"structure","members":{"RecurringChargeAmount":{"type":"double"},"RecurringChargeFrequency":{}},"wrapper":true}},"S4k":{"type":"structure","members":{"DBParameterGroupName":{}}}}}; - -/***/ }), - -/***/ 1420: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['elbv2'] = {}; -AWS.ELBv2 = Service.defineService('elbv2', ['2015-12-01']); -Object.defineProperty(apiLoader.services['elbv2'], '2015-12-01', { - get: function get() { - var model = __webpack_require__(9843); - model.paginators = __webpack_require__(956).pagination; - model.waiters = __webpack_require__(4303).waiters; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.ELBv2; - - -/***/ }), - -/***/ 1426: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2019-12-03","endpointPrefix":"outposts","jsonVersion":"1.1","protocol":"rest-json","serviceAbbreviation":"Outposts","serviceFullName":"AWS Outposts","serviceId":"Outposts","signatureVersion":"v4","signingName":"outposts","uid":"outposts-2019-12-03"},"operations":{"CreateOutpost":{"http":{"requestUri":"/outposts"},"input":{"type":"structure","required":["SiteId"],"members":{"Name":{},"Description":{},"SiteId":{},"AvailabilityZone":{},"AvailabilityZoneId":{}}},"output":{"type":"structure","members":{"Outpost":{"shape":"S8"}}}},"DeleteOutpost":{"http":{"method":"DELETE","requestUri":"/outposts/{OutpostId}"},"input":{"type":"structure","required":["OutpostId"],"members":{"OutpostId":{"location":"uri","locationName":"OutpostId"}}},"output":{"type":"structure","members":{}}},"DeleteSite":{"http":{"method":"DELETE","requestUri":"/sites/{SiteId}"},"input":{"type":"structure","required":["SiteId"],"members":{"SiteId":{"location":"uri","locationName":"SiteId"}}},"output":{"type":"structure","members":{}}},"GetOutpost":{"http":{"method":"GET","requestUri":"/outposts/{OutpostId}"},"input":{"type":"structure","required":["OutpostId"],"members":{"OutpostId":{"location":"uri","locationName":"OutpostId"}}},"output":{"type":"structure","members":{"Outpost":{"shape":"S8"}}}},"GetOutpostInstanceTypes":{"http":{"method":"GET","requestUri":"/outposts/{OutpostId}/instanceTypes"},"input":{"type":"structure","required":["OutpostId"],"members":{"OutpostId":{"location":"uri","locationName":"OutpostId"},"NextToken":{"location":"querystring","locationName":"NextToken"},"MaxResults":{"location":"querystring","locationName":"MaxResults","type":"integer"}}},"output":{"type":"structure","members":{"InstanceTypes":{"type":"list","member":{"type":"structure","members":{"InstanceType":{}}}},"NextToken":{},"OutpostId":{},"OutpostArn":{}}}},"ListOutposts":{"http":{"method":"GET","requestUri":"/outposts"},"input":{"type":"structure","members":{"NextToken":{"location":"querystring","locationName":"NextToken"},"MaxResults":{"location":"querystring","locationName":"MaxResults","type":"integer"}}},"output":{"type":"structure","members":{"Outposts":{"type":"list","member":{"shape":"S8"}},"NextToken":{}}}},"ListSites":{"http":{"method":"GET","requestUri":"/sites"},"input":{"type":"structure","members":{"NextToken":{"location":"querystring","locationName":"NextToken"},"MaxResults":{"location":"querystring","locationName":"MaxResults","type":"integer"}}},"output":{"type":"structure","members":{"Sites":{"type":"list","member":{"type":"structure","members":{"SiteId":{},"AccountId":{},"Name":{},"Description":{}}}},"NextToken":{}}}}},"shapes":{"S8":{"type":"structure","members":{"OutpostId":{},"OwnerId":{},"OutpostArn":{},"SiteId":{},"Name":{},"Description":{},"LifeCycleStatus":{},"AvailabilityZone":{},"AvailabilityZoneId":{}}}}}; - -/***/ }), - -/***/ 1429: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['eks'] = {}; -AWS.EKS = Service.defineService('eks', ['2017-11-01']); -Object.defineProperty(apiLoader.services['eks'], '2017-11-01', { - get: function get() { - var model = __webpack_require__(3370); - model.paginators = __webpack_require__(6823).pagination; - model.waiters = __webpack_require__(912).waiters; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.EKS; - - -/***/ }), - -/***/ 1437: -/***/ (function(module) { - -module.exports = {"version":2,"waiters":{"ClusterAvailable":{"delay":60,"operation":"DescribeClusters","maxAttempts":30,"acceptors":[{"expected":"available","matcher":"pathAll","state":"success","argument":"Clusters[].ClusterStatus"},{"expected":"deleting","matcher":"pathAny","state":"failure","argument":"Clusters[].ClusterStatus"},{"expected":"ClusterNotFound","matcher":"error","state":"retry"}]},"ClusterDeleted":{"delay":60,"operation":"DescribeClusters","maxAttempts":30,"acceptors":[{"expected":"ClusterNotFound","matcher":"error","state":"success"},{"expected":"creating","matcher":"pathAny","state":"failure","argument":"Clusters[].ClusterStatus"},{"expected":"modifying","matcher":"pathAny","state":"failure","argument":"Clusters[].ClusterStatus"}]},"ClusterRestored":{"operation":"DescribeClusters","maxAttempts":30,"delay":60,"acceptors":[{"state":"success","matcher":"pathAll","argument":"Clusters[].RestoreStatus.Status","expected":"completed"},{"state":"failure","matcher":"pathAny","argument":"Clusters[].ClusterStatus","expected":"deleting"}]},"SnapshotAvailable":{"delay":15,"operation":"DescribeClusterSnapshots","maxAttempts":20,"acceptors":[{"expected":"available","matcher":"pathAll","state":"success","argument":"Snapshots[].Status"},{"expected":"failed","matcher":"pathAny","state":"failure","argument":"Snapshots[].Status"},{"expected":"deleted","matcher":"pathAny","state":"failure","argument":"Snapshots[].Status"}]}}}; - -/***/ }), - -/***/ 1455: -/***/ (function(module) { - -module.exports = {"pagination":{"ListCertificateAuthorities":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"CertificateAuthorities"},"ListPermissions":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Permissions"},"ListTags":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Tags"}}}; - -/***/ }), - -/***/ 1459: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2013-11-01","endpointPrefix":"cloudtrail","jsonVersion":"1.1","protocol":"json","serviceAbbreviation":"CloudTrail","serviceFullName":"AWS CloudTrail","serviceId":"CloudTrail","signatureVersion":"v4","targetPrefix":"com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101","uid":"cloudtrail-2013-11-01"},"operations":{"AddTags":{"input":{"type":"structure","required":["ResourceId"],"members":{"ResourceId":{},"TagsList":{"shape":"S3"}}},"output":{"type":"structure","members":{}},"idempotent":true},"CreateTrail":{"input":{"type":"structure","required":["Name","S3BucketName"],"members":{"Name":{},"S3BucketName":{},"S3KeyPrefix":{},"SnsTopicName":{},"IncludeGlobalServiceEvents":{"type":"boolean"},"IsMultiRegionTrail":{"type":"boolean"},"EnableLogFileValidation":{"type":"boolean"},"CloudWatchLogsLogGroupArn":{},"CloudWatchLogsRoleArn":{},"KmsKeyId":{},"IsOrganizationTrail":{"type":"boolean"},"TagsList":{"shape":"S3"}}},"output":{"type":"structure","members":{"Name":{},"S3BucketName":{},"S3KeyPrefix":{},"SnsTopicName":{"deprecated":true},"SnsTopicARN":{},"IncludeGlobalServiceEvents":{"type":"boolean"},"IsMultiRegionTrail":{"type":"boolean"},"TrailARN":{},"LogFileValidationEnabled":{"type":"boolean"},"CloudWatchLogsLogGroupArn":{},"CloudWatchLogsRoleArn":{},"KmsKeyId":{},"IsOrganizationTrail":{"type":"boolean"}}},"idempotent":true},"DeleteTrail":{"input":{"type":"structure","required":["Name"],"members":{"Name":{}}},"output":{"type":"structure","members":{}},"idempotent":true},"DescribeTrails":{"input":{"type":"structure","members":{"trailNameList":{"type":"list","member":{}},"includeShadowTrails":{"type":"boolean"}}},"output":{"type":"structure","members":{"trailList":{"type":"list","member":{"shape":"Sf"}}}},"idempotent":true},"GetEventSelectors":{"input":{"type":"structure","required":["TrailName"],"members":{"TrailName":{}}},"output":{"type":"structure","members":{"TrailARN":{},"EventSelectors":{"shape":"Si"}}},"idempotent":true},"GetInsightSelectors":{"input":{"type":"structure","required":["TrailName"],"members":{"TrailName":{}}},"output":{"type":"structure","members":{"TrailARN":{},"InsightSelectors":{"shape":"Sr"}}},"idempotent":true},"GetTrail":{"input":{"type":"structure","required":["Name"],"members":{"Name":{}}},"output":{"type":"structure","members":{"Trail":{"shape":"Sf"}}},"idempotent":true},"GetTrailStatus":{"input":{"type":"structure","required":["Name"],"members":{"Name":{}}},"output":{"type":"structure","members":{"IsLogging":{"type":"boolean"},"LatestDeliveryError":{},"LatestNotificationError":{},"LatestDeliveryTime":{"type":"timestamp"},"LatestNotificationTime":{"type":"timestamp"},"StartLoggingTime":{"type":"timestamp"},"StopLoggingTime":{"type":"timestamp"},"LatestCloudWatchLogsDeliveryError":{},"LatestCloudWatchLogsDeliveryTime":{"type":"timestamp"},"LatestDigestDeliveryTime":{"type":"timestamp"},"LatestDigestDeliveryError":{},"LatestDeliveryAttemptTime":{},"LatestNotificationAttemptTime":{},"LatestNotificationAttemptSucceeded":{},"LatestDeliveryAttemptSucceeded":{},"TimeLoggingStarted":{},"TimeLoggingStopped":{}}},"idempotent":true},"ListPublicKeys":{"input":{"type":"structure","members":{"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"NextToken":{}}},"output":{"type":"structure","members":{"PublicKeyList":{"type":"list","member":{"type":"structure","members":{"Value":{"type":"blob"},"ValidityStartTime":{"type":"timestamp"},"ValidityEndTime":{"type":"timestamp"},"Fingerprint":{}}}},"NextToken":{}}},"idempotent":true},"ListTags":{"input":{"type":"structure","required":["ResourceIdList"],"members":{"ResourceIdList":{"type":"list","member":{}},"NextToken":{}}},"output":{"type":"structure","members":{"ResourceTagList":{"type":"list","member":{"type":"structure","members":{"ResourceId":{},"TagsList":{"shape":"S3"}}}},"NextToken":{}}},"idempotent":true},"ListTrails":{"input":{"type":"structure","members":{"NextToken":{}}},"output":{"type":"structure","members":{"Trails":{"type":"list","member":{"type":"structure","members":{"TrailARN":{},"Name":{},"HomeRegion":{}}}},"NextToken":{}}},"idempotent":true},"LookupEvents":{"input":{"type":"structure","members":{"LookupAttributes":{"type":"list","member":{"type":"structure","required":["AttributeKey","AttributeValue"],"members":{"AttributeKey":{},"AttributeValue":{}}}},"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"EventCategory":{},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"Events":{"type":"list","member":{"type":"structure","members":{"EventId":{},"EventName":{},"ReadOnly":{},"AccessKeyId":{},"EventTime":{"type":"timestamp"},"EventSource":{},"Username":{},"Resources":{"type":"list","member":{"type":"structure","members":{"ResourceType":{},"ResourceName":{}}}},"CloudTrailEvent":{}}}},"NextToken":{}}},"idempotent":true},"PutEventSelectors":{"input":{"type":"structure","required":["TrailName","EventSelectors"],"members":{"TrailName":{},"EventSelectors":{"shape":"Si"}}},"output":{"type":"structure","members":{"TrailARN":{},"EventSelectors":{"shape":"Si"}}},"idempotent":true},"PutInsightSelectors":{"input":{"type":"structure","required":["TrailName","InsightSelectors"],"members":{"TrailName":{},"InsightSelectors":{"shape":"Sr"}}},"output":{"type":"structure","members":{"TrailARN":{},"InsightSelectors":{"shape":"Sr"}}},"idempotent":true},"RemoveTags":{"input":{"type":"structure","required":["ResourceId"],"members":{"ResourceId":{},"TagsList":{"shape":"S3"}}},"output":{"type":"structure","members":{}},"idempotent":true},"StartLogging":{"input":{"type":"structure","required":["Name"],"members":{"Name":{}}},"output":{"type":"structure","members":{}},"idempotent":true},"StopLogging":{"input":{"type":"structure","required":["Name"],"members":{"Name":{}}},"output":{"type":"structure","members":{}},"idempotent":true},"UpdateTrail":{"input":{"type":"structure","required":["Name"],"members":{"Name":{},"S3BucketName":{},"S3KeyPrefix":{},"SnsTopicName":{},"IncludeGlobalServiceEvents":{"type":"boolean"},"IsMultiRegionTrail":{"type":"boolean"},"EnableLogFileValidation":{"type":"boolean"},"CloudWatchLogsLogGroupArn":{},"CloudWatchLogsRoleArn":{},"KmsKeyId":{},"IsOrganizationTrail":{"type":"boolean"}}},"output":{"type":"structure","members":{"Name":{},"S3BucketName":{},"S3KeyPrefix":{},"SnsTopicName":{"deprecated":true},"SnsTopicARN":{},"IncludeGlobalServiceEvents":{"type":"boolean"},"IsMultiRegionTrail":{"type":"boolean"},"TrailARN":{},"LogFileValidationEnabled":{"type":"boolean"},"CloudWatchLogsLogGroupArn":{},"CloudWatchLogsRoleArn":{},"KmsKeyId":{},"IsOrganizationTrail":{"type":"boolean"}}},"idempotent":true}},"shapes":{"S3":{"type":"list","member":{"type":"structure","required":["Key"],"members":{"Key":{},"Value":{}}}},"Sf":{"type":"structure","members":{"Name":{},"S3BucketName":{},"S3KeyPrefix":{},"SnsTopicName":{"deprecated":true},"SnsTopicARN":{},"IncludeGlobalServiceEvents":{"type":"boolean"},"IsMultiRegionTrail":{"type":"boolean"},"HomeRegion":{},"TrailARN":{},"LogFileValidationEnabled":{"type":"boolean"},"CloudWatchLogsLogGroupArn":{},"CloudWatchLogsRoleArn":{},"KmsKeyId":{},"HasCustomEventSelectors":{"type":"boolean"},"HasInsightSelectors":{"type":"boolean"},"IsOrganizationTrail":{"type":"boolean"}}},"Si":{"type":"list","member":{"type":"structure","members":{"ReadWriteType":{},"IncludeManagementEvents":{"type":"boolean"},"DataResources":{"type":"list","member":{"type":"structure","members":{"Type":{},"Values":{"type":"list","member":{}}}}},"ExcludeManagementEventSources":{"type":"list","member":{}}}}},"Sr":{"type":"list","member":{"type":"structure","members":{"InsightType":{}}}}}}; - -/***/ }), - -/***/ 1479: -/***/ (function(module) { - -module.exports = {"pagination":{"GetCurrentMetricData":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"GetMetricData":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"ListContactFlows":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"ContactFlowSummaryList"},"ListHoursOfOperations":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"HoursOfOperationSummaryList"},"ListPhoneNumbers":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"PhoneNumberSummaryList"},"ListQueues":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"QueueSummaryList"},"ListRoutingProfiles":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"RoutingProfileSummaryList"},"ListSecurityProfiles":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"SecurityProfileSummaryList"},"ListUserHierarchyGroups":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"UserHierarchyGroupSummaryList"},"ListUsers":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"UserSummaryList"}}}; - -/***/ }), - -/***/ 1489: -/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) { - -var AWS = __webpack_require__(395); - -AWS.util.update(AWS.S3Control.prototype, { - /** - * @api private - */ - setupRequestListeners: function setupRequestListeners(request) { - request.addListener('afterBuild', this.prependAccountId); - request.addListener('extractError', this.extractHostId); - request.addListener('extractData', this.extractHostId); - request.addListener('validate', this.validateAccountId); - }, - - /** - * @api private - */ - prependAccountId: function(request) { - var api = request.service.api; - var operationModel = api.operations[request.operation]; - var inputModel = operationModel.input; - var params = request.params; - if (inputModel.members.AccountId && params.AccountId) { - //customization needed - var accountId = params.AccountId; - var endpoint = request.httpRequest.endpoint; - var newHostname = String(accountId) + '.' + endpoint.hostname; - endpoint.hostname = newHostname; - request.httpRequest.headers.Host = newHostname; - delete request.httpRequest.headers['x-amz-account-id']; + if (request.body == null && request.headers["content-type"] === this.getDefaultContentType()) { + request.body = "{}"; + } + return request; + } + async deserializeResponse(operationSchema, context, response) { + const output = await super.deserializeResponse(operationSchema, context, response); + const outputSchema = schema.NormalizedSchema.of(operationSchema.output); + for (const [name, member] of outputSchema.structIterator()) { + if (member.getMemberTraits().httpPayload && !(name in output)) { + output[name] = null; + } + } + return output; + } + async handleError(operationSchema, context, response, dataObject, metadata) { + const errorIdentifier = loadRestJsonErrorCode(response, dataObject) ?? "Unknown"; + const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, dataObject, metadata); + const ns = schema.NormalizedSchema.of(errorSchema); + const message = dataObject.message ?? dataObject.Message ?? "Unknown"; + const ErrorCtor = schema.TypeRegistry.for(errorSchema[1]).getErrorCtor(errorSchema) ?? Error; + const exception = new ErrorCtor(message); + await this.deserializeHttpMessage(errorSchema, context, response, dataObject); + const output = {}; + for (const [name, member] of ns.structIterator()) { + const target = member.getMergedTraits().jsonName ?? name; + output[name] = this.codec.createDeserializer().readObject(member, dataObject[target]); + } + throw this.mixin.decorateServiceException(Object.assign(exception, errorMetadata, { + $fault: ns.getMergedTraits().error, + message, + }, output), dataObject); } - }, + getDefaultContentType() { + return "application/json"; + } +} - /** - * @api private - */ - extractHostId: function(response) { - var hostId = response.httpResponse.headers ? response.httpResponse.headers['x-amz-id-2'] : null; - response.extendedRequestId = hostId; - if (response.error) { - response.error.extendedRequestId = hostId; +const awsExpectUnion = (value) => { + if (value == null) { + return undefined; } - }, + if (typeof value === "object" && "__type" in value) { + delete value.__type; + } + return smithyClient.expectUnion(value); +}; - /** - * @api private - */ - validateAccountId: function(request) { - var params = request.params; - if (!Object.prototype.hasOwnProperty.call(params, 'AccountId')) return; - var accountId = params.AccountId; - //validate type - if (typeof accountId !== 'string') { - throw AWS.util.error( - new Error(), - {code: 'ValidationError', message: 'AccountId must be a string.'} - ); +class XmlShapeDeserializer extends SerdeContextConfig { + settings; + stringDeserializer; + constructor(settings) { + super(); + this.settings = settings; + this.stringDeserializer = new protocols.FromStringShapeDeserializer(settings); + } + setSerdeContext(serdeContext) { + this.serdeContext = serdeContext; + this.stringDeserializer.setSerdeContext(serdeContext); + } + read(schema$1, bytes, key) { + const ns = schema.NormalizedSchema.of(schema$1); + const memberSchemas = ns.getMemberSchemas(); + const isEventPayload = ns.isStructSchema() && + ns.isMemberSchema() && + !!Object.values(memberSchemas).find((memberNs) => { + return !!memberNs.getMemberTraits().eventPayload; + }); + if (isEventPayload) { + const output = {}; + const memberName = Object.keys(memberSchemas)[0]; + const eventMemberSchema = memberSchemas[memberName]; + if (eventMemberSchema.isBlobSchema()) { + output[memberName] = bytes; + } + else { + output[memberName] = this.read(memberSchemas[memberName], bytes); + } + return output; + } + const xmlString = (this.serdeContext?.utf8Encoder ?? utilUtf8.toUtf8)(bytes); + const parsedObject = this.parseXml(xmlString); + return this.readSchema(schema$1, key ? parsedObject[key] : parsedObject); } - //validate length - if (accountId.length < 1 || accountId.length > 63) { - throw AWS.util.error( - new Error(), - {code: 'ValidationError', message: 'AccountId length should be between 1 to 63 characters, inclusive.'} - ); + readSchema(_schema, value) { + const ns = schema.NormalizedSchema.of(_schema); + if (ns.isUnitSchema()) { + return; + } + const traits = ns.getMergedTraits(); + if (ns.isListSchema() && !Array.isArray(value)) { + return this.readSchema(ns, [value]); + } + if (value == null) { + return value; + } + if (typeof value === "object") { + const sparse = !!traits.sparse; + const flat = !!traits.xmlFlattened; + if (ns.isListSchema()) { + const listValue = ns.getValueSchema(); + const buffer = []; + const sourceKey = listValue.getMergedTraits().xmlName ?? "member"; + const source = flat ? value : (value[0] ?? value)[sourceKey]; + const sourceArray = Array.isArray(source) ? source : [source]; + for (const v of sourceArray) { + if (v != null || sparse) { + buffer.push(this.readSchema(listValue, v)); + } + } + return buffer; + } + const buffer = {}; + if (ns.isMapSchema()) { + const keyNs = ns.getKeySchema(); + const memberNs = ns.getValueSchema(); + let entries; + if (flat) { + entries = Array.isArray(value) ? value : [value]; + } + else { + entries = Array.isArray(value.entry) ? value.entry : [value.entry]; + } + const keyProperty = keyNs.getMergedTraits().xmlName ?? "key"; + const valueProperty = memberNs.getMergedTraits().xmlName ?? "value"; + for (const entry of entries) { + const key = entry[keyProperty]; + const value = entry[valueProperty]; + if (value != null || sparse) { + buffer[key] = this.readSchema(memberNs, value); + } + } + return buffer; + } + if (ns.isStructSchema()) { + for (const [memberName, memberSchema] of ns.structIterator()) { + const memberTraits = memberSchema.getMergedTraits(); + const xmlObjectKey = !memberTraits.httpPayload + ? memberSchema.getMemberTraits().xmlName ?? memberName + : memberTraits.xmlName ?? memberSchema.getName(); + if (value[xmlObjectKey] != null) { + buffer[memberName] = this.readSchema(memberSchema, value[xmlObjectKey]); + } + } + return buffer; + } + if (ns.isDocumentSchema()) { + return value; + } + throw new Error(`@aws-sdk/core/protocols - xml deserializer unhandled schema type for ${ns.getName(true)}`); + } + if (ns.isListSchema()) { + return []; + } + if (ns.isMapSchema() || ns.isStructSchema()) { + return {}; + } + return this.stringDeserializer.read(ns, value); } - //validate pattern - var hostPattern = /^[a-zA-Z0-9]{1}$|^[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9]$/; - if (!hostPattern.test(accountId)) { - throw AWS.util.error(new Error(), - {code: 'ValidationError', message: 'AccountId should be hostname compatible. AccountId: ' + accountId}); + parseXml(xml) { + if (xml.length) { + let parsedObj; + try { + parsedObj = xmlBuilder.parseXML(xml); + } + catch (e) { + if (e && typeof e === "object") { + Object.defineProperty(e, "$responseBodyText", { + value: xml, + }); + } + throw e; + } + const textNodeName = "#text"; + const key = Object.keys(parsedObj)[0]; + const parsedObjToReturn = parsedObj[key]; + if (parsedObjToReturn[textNodeName]) { + parsedObjToReturn[key] = parsedObjToReturn[textNodeName]; + delete parsedObjToReturn[textNodeName]; + } + return smithyClient.getValueFromTextNode(parsedObjToReturn); + } + return {}; } - } -}); - - -/***/ }), - -/***/ 1511: -/***/ (function(module) { - -module.exports = {"version":2,"waiters":{"InstanceExists":{"delay":5,"maxAttempts":40,"operation":"DescribeInstances","acceptors":[{"matcher":"path","expected":true,"argument":"length(Reservations[]) > `0`","state":"success"},{"matcher":"error","expected":"InvalidInstanceID.NotFound","state":"retry"}]},"BundleTaskComplete":{"delay":15,"operation":"DescribeBundleTasks","maxAttempts":40,"acceptors":[{"expected":"complete","matcher":"pathAll","state":"success","argument":"BundleTasks[].State"},{"expected":"failed","matcher":"pathAny","state":"failure","argument":"BundleTasks[].State"}]},"ConversionTaskCancelled":{"delay":15,"operation":"DescribeConversionTasks","maxAttempts":40,"acceptors":[{"expected":"cancelled","matcher":"pathAll","state":"success","argument":"ConversionTasks[].State"}]},"ConversionTaskCompleted":{"delay":15,"operation":"DescribeConversionTasks","maxAttempts":40,"acceptors":[{"expected":"completed","matcher":"pathAll","state":"success","argument":"ConversionTasks[].State"},{"expected":"cancelled","matcher":"pathAny","state":"failure","argument":"ConversionTasks[].State"},{"expected":"cancelling","matcher":"pathAny","state":"failure","argument":"ConversionTasks[].State"}]},"ConversionTaskDeleted":{"delay":15,"operation":"DescribeConversionTasks","maxAttempts":40,"acceptors":[{"expected":"deleted","matcher":"pathAll","state":"success","argument":"ConversionTasks[].State"}]},"CustomerGatewayAvailable":{"delay":15,"operation":"DescribeCustomerGateways","maxAttempts":40,"acceptors":[{"expected":"available","matcher":"pathAll","state":"success","argument":"CustomerGateways[].State"},{"expected":"deleted","matcher":"pathAny","state":"failure","argument":"CustomerGateways[].State"},{"expected":"deleting","matcher":"pathAny","state":"failure","argument":"CustomerGateways[].State"}]},"ExportTaskCancelled":{"delay":15,"operation":"DescribeExportTasks","maxAttempts":40,"acceptors":[{"expected":"cancelled","matcher":"pathAll","state":"success","argument":"ExportTasks[].State"}]},"ExportTaskCompleted":{"delay":15,"operation":"DescribeExportTasks","maxAttempts":40,"acceptors":[{"expected":"completed","matcher":"pathAll","state":"success","argument":"ExportTasks[].State"}]},"ImageExists":{"operation":"DescribeImages","maxAttempts":40,"delay":15,"acceptors":[{"matcher":"path","expected":true,"argument":"length(Images[]) > `0`","state":"success"},{"matcher":"error","expected":"InvalidAMIID.NotFound","state":"retry"}]},"ImageAvailable":{"operation":"DescribeImages","maxAttempts":40,"delay":15,"acceptors":[{"state":"success","matcher":"pathAll","argument":"Images[].State","expected":"available"},{"state":"failure","matcher":"pathAny","argument":"Images[].State","expected":"failed"}]},"InstanceRunning":{"delay":15,"operation":"DescribeInstances","maxAttempts":40,"acceptors":[{"expected":"running","matcher":"pathAll","state":"success","argument":"Reservations[].Instances[].State.Name"},{"expected":"shutting-down","matcher":"pathAny","state":"failure","argument":"Reservations[].Instances[].State.Name"},{"expected":"terminated","matcher":"pathAny","state":"failure","argument":"Reservations[].Instances[].State.Name"},{"expected":"stopping","matcher":"pathAny","state":"failure","argument":"Reservations[].Instances[].State.Name"},{"matcher":"error","expected":"InvalidInstanceID.NotFound","state":"retry"}]},"InstanceStatusOk":{"operation":"DescribeInstanceStatus","maxAttempts":40,"delay":15,"acceptors":[{"state":"success","matcher":"pathAll","argument":"InstanceStatuses[].InstanceStatus.Status","expected":"ok"},{"matcher":"error","expected":"InvalidInstanceID.NotFound","state":"retry"}]},"InstanceStopped":{"delay":15,"operation":"DescribeInstances","maxAttempts":40,"acceptors":[{"expected":"stopped","matcher":"pathAll","state":"success","argument":"Reservations[].Instances[].State.Name"},{"expected":"pending","matcher":"pathAny","state":"failure","argument":"Reservations[].Instances[].State.Name"},{"expected":"terminated","matcher":"pathAny","state":"failure","argument":"Reservations[].Instances[].State.Name"}]},"InstanceTerminated":{"delay":15,"operation":"DescribeInstances","maxAttempts":40,"acceptors":[{"expected":"terminated","matcher":"pathAll","state":"success","argument":"Reservations[].Instances[].State.Name"},{"expected":"pending","matcher":"pathAny","state":"failure","argument":"Reservations[].Instances[].State.Name"},{"expected":"stopping","matcher":"pathAny","state":"failure","argument":"Reservations[].Instances[].State.Name"}]},"KeyPairExists":{"operation":"DescribeKeyPairs","delay":5,"maxAttempts":6,"acceptors":[{"expected":true,"matcher":"path","state":"success","argument":"length(KeyPairs[].KeyName) > `0`"},{"expected":"InvalidKeyPair.NotFound","matcher":"error","state":"retry"}]},"NatGatewayAvailable":{"operation":"DescribeNatGateways","delay":15,"maxAttempts":40,"acceptors":[{"state":"success","matcher":"pathAll","argument":"NatGateways[].State","expected":"available"},{"state":"failure","matcher":"pathAny","argument":"NatGateways[].State","expected":"failed"},{"state":"failure","matcher":"pathAny","argument":"NatGateways[].State","expected":"deleting"},{"state":"failure","matcher":"pathAny","argument":"NatGateways[].State","expected":"deleted"},{"state":"retry","matcher":"error","expected":"NatGatewayNotFound"}]},"NetworkInterfaceAvailable":{"operation":"DescribeNetworkInterfaces","delay":20,"maxAttempts":10,"acceptors":[{"expected":"available","matcher":"pathAll","state":"success","argument":"NetworkInterfaces[].Status"},{"expected":"InvalidNetworkInterfaceID.NotFound","matcher":"error","state":"failure"}]},"PasswordDataAvailable":{"operation":"GetPasswordData","maxAttempts":40,"delay":15,"acceptors":[{"state":"success","matcher":"path","argument":"length(PasswordData) > `0`","expected":true}]},"SnapshotCompleted":{"delay":15,"operation":"DescribeSnapshots","maxAttempts":40,"acceptors":[{"expected":"completed","matcher":"pathAll","state":"success","argument":"Snapshots[].State"}]},"SecurityGroupExists":{"operation":"DescribeSecurityGroups","delay":5,"maxAttempts":6,"acceptors":[{"expected":true,"matcher":"path","state":"success","argument":"length(SecurityGroups[].GroupId) > `0`"},{"expected":"InvalidGroupNotFound","matcher":"error","state":"retry"}]},"SpotInstanceRequestFulfilled":{"operation":"DescribeSpotInstanceRequests","maxAttempts":40,"delay":15,"acceptors":[{"state":"success","matcher":"pathAll","argument":"SpotInstanceRequests[].Status.Code","expected":"fulfilled"},{"state":"success","matcher":"pathAll","argument":"SpotInstanceRequests[].Status.Code","expected":"request-canceled-and-instance-running"},{"state":"failure","matcher":"pathAny","argument":"SpotInstanceRequests[].Status.Code","expected":"schedule-expired"},{"state":"failure","matcher":"pathAny","argument":"SpotInstanceRequests[].Status.Code","expected":"canceled-before-fulfillment"},{"state":"failure","matcher":"pathAny","argument":"SpotInstanceRequests[].Status.Code","expected":"bad-parameters"},{"state":"failure","matcher":"pathAny","argument":"SpotInstanceRequests[].Status.Code","expected":"system-error"},{"state":"retry","matcher":"error","expected":"InvalidSpotInstanceRequestID.NotFound"}]},"SubnetAvailable":{"delay":15,"operation":"DescribeSubnets","maxAttempts":40,"acceptors":[{"expected":"available","matcher":"pathAll","state":"success","argument":"Subnets[].State"}]},"SystemStatusOk":{"operation":"DescribeInstanceStatus","maxAttempts":40,"delay":15,"acceptors":[{"state":"success","matcher":"pathAll","argument":"InstanceStatuses[].SystemStatus.Status","expected":"ok"}]},"VolumeAvailable":{"delay":15,"operation":"DescribeVolumes","maxAttempts":40,"acceptors":[{"expected":"available","matcher":"pathAll","state":"success","argument":"Volumes[].State"},{"expected":"deleted","matcher":"pathAny","state":"failure","argument":"Volumes[].State"}]},"VolumeDeleted":{"delay":15,"operation":"DescribeVolumes","maxAttempts":40,"acceptors":[{"expected":"deleted","matcher":"pathAll","state":"success","argument":"Volumes[].State"},{"matcher":"error","expected":"InvalidVolume.NotFound","state":"success"}]},"VolumeInUse":{"delay":15,"operation":"DescribeVolumes","maxAttempts":40,"acceptors":[{"expected":"in-use","matcher":"pathAll","state":"success","argument":"Volumes[].State"},{"expected":"deleted","matcher":"pathAny","state":"failure","argument":"Volumes[].State"}]},"VpcAvailable":{"delay":15,"operation":"DescribeVpcs","maxAttempts":40,"acceptors":[{"expected":"available","matcher":"pathAll","state":"success","argument":"Vpcs[].State"}]},"VpcExists":{"operation":"DescribeVpcs","delay":1,"maxAttempts":5,"acceptors":[{"matcher":"status","expected":200,"state":"success"},{"matcher":"error","expected":"InvalidVpcID.NotFound","state":"retry"}]},"VpnConnectionAvailable":{"delay":15,"operation":"DescribeVpnConnections","maxAttempts":40,"acceptors":[{"expected":"available","matcher":"pathAll","state":"success","argument":"VpnConnections[].State"},{"expected":"deleting","matcher":"pathAny","state":"failure","argument":"VpnConnections[].State"},{"expected":"deleted","matcher":"pathAny","state":"failure","argument":"VpnConnections[].State"}]},"VpnConnectionDeleted":{"delay":15,"operation":"DescribeVpnConnections","maxAttempts":40,"acceptors":[{"expected":"deleted","matcher":"pathAll","state":"success","argument":"VpnConnections[].State"},{"expected":"pending","matcher":"pathAny","state":"failure","argument":"VpnConnections[].State"}]},"VpcPeeringConnectionExists":{"delay":15,"operation":"DescribeVpcPeeringConnections","maxAttempts":40,"acceptors":[{"matcher":"status","expected":200,"state":"success"},{"matcher":"error","expected":"InvalidVpcPeeringConnectionID.NotFound","state":"retry"}]},"VpcPeeringConnectionDeleted":{"delay":15,"operation":"DescribeVpcPeeringConnections","maxAttempts":40,"acceptors":[{"expected":"deleted","matcher":"pathAll","state":"success","argument":"VpcPeeringConnections[].Status.Code"},{"matcher":"error","expected":"InvalidVpcPeeringConnectionID.NotFound","state":"success"}]}}}; - -/***/ }), +} -/***/ 1514: -/***/ (function(__unusedmodule, exports) { - -// Generated by CoffeeScript 1.12.7 -(function() { - exports.defaults = { - "0.1": { - explicitCharkey: false, - trim: true, - normalize: true, - normalizeTags: false, - attrkey: "@", - charkey: "#", - explicitArray: false, - ignoreAttrs: false, - mergeAttrs: false, - explicitRoot: false, - validator: null, - xmlns: false, - explicitChildren: false, - childkey: '@@', - charsAsChildren: false, - includeWhiteChars: false, - async: false, - strict: true, - attrNameProcessors: null, - attrValueProcessors: null, - tagNameProcessors: null, - valueProcessors: null, - emptyTag: '' - }, - "0.2": { - explicitCharkey: false, - trim: false, - normalize: false, - normalizeTags: false, - attrkey: "$", - charkey: "_", - explicitArray: true, - ignoreAttrs: false, - mergeAttrs: false, - explicitRoot: true, - validator: null, - xmlns: false, - explicitChildren: false, - preserveChildrenOrder: false, - childkey: '$$', - charsAsChildren: false, - includeWhiteChars: false, - async: false, - strict: true, - attrNameProcessors: null, - attrValueProcessors: null, - tagNameProcessors: null, - valueProcessors: null, - rootName: 'root', - xmldec: { - 'version': '1.0', - 'encoding': 'UTF-8', - 'standalone': true - }, - doctype: null, - renderOpts: { - 'pretty': true, - 'indent': ' ', - 'newline': '\n' - }, - headless: false, - chunkSize: 10000, - emptyTag: '', - cdata: false +class QueryShapeSerializer extends SerdeContextConfig { + settings; + buffer; + constructor(settings) { + super(); + this.settings = settings; } - }; - -}).call(this); - - -/***/ }), - -/***/ 1520: -/***/ (function(module) { + write(schema$1, value, prefix = "") { + if (this.buffer === undefined) { + this.buffer = ""; + } + const ns = schema.NormalizedSchema.of(schema$1); + if (prefix && !prefix.endsWith(".")) { + prefix += "."; + } + if (ns.isBlobSchema()) { + if (typeof value === "string" || value instanceof Uint8Array) { + this.writeKey(prefix); + this.writeValue((this.serdeContext?.base64Encoder ?? utilBase64.toBase64)(value)); + } + } + else if (ns.isBooleanSchema() || ns.isNumericSchema() || ns.isStringSchema()) { + if (value != null) { + this.writeKey(prefix); + this.writeValue(String(value)); + } + else if (ns.isIdempotencyToken()) { + this.writeKey(prefix); + this.writeValue(serde.generateIdempotencyToken()); + } + } + else if (ns.isBigIntegerSchema()) { + if (value != null) { + this.writeKey(prefix); + this.writeValue(String(value)); + } + } + else if (ns.isBigDecimalSchema()) { + if (value != null) { + this.writeKey(prefix); + this.writeValue(value instanceof serde.NumericValue ? value.string : String(value)); + } + } + else if (ns.isTimestampSchema()) { + if (value instanceof Date) { + this.writeKey(prefix); + const format = protocols.determineTimestampFormat(ns, this.settings); + switch (format) { + case 5: + this.writeValue(value.toISOString().replace(".000Z", "Z")); + break; + case 6: + this.writeValue(smithyClient.dateToUtcString(value)); + break; + case 7: + this.writeValue(String(value.getTime() / 1000)); + break; + } + } + } + else if (ns.isDocumentSchema()) { + throw new Error(`@aws-sdk/core/protocols - QuerySerializer unsupported document type ${ns.getName(true)}`); + } + else if (ns.isListSchema()) { + if (Array.isArray(value)) { + if (value.length === 0) { + if (this.settings.serializeEmptyLists) { + this.writeKey(prefix); + this.writeValue(""); + } + } + else { + const member = ns.getValueSchema(); + const flat = this.settings.flattenLists || ns.getMergedTraits().xmlFlattened; + let i = 1; + for (const item of value) { + if (item == null) { + continue; + } + const suffix = this.getKey("member", member.getMergedTraits().xmlName); + const key = flat ? `${prefix}${i}` : `${prefix}${suffix}.${i}`; + this.write(member, item, key); + ++i; + } + } + } + } + else if (ns.isMapSchema()) { + if (value && typeof value === "object") { + const keySchema = ns.getKeySchema(); + const memberSchema = ns.getValueSchema(); + const flat = ns.getMergedTraits().xmlFlattened; + let i = 1; + for (const [k, v] of Object.entries(value)) { + if (v == null) { + continue; + } + const keySuffix = this.getKey("key", keySchema.getMergedTraits().xmlName); + const key = flat ? `${prefix}${i}.${keySuffix}` : `${prefix}entry.${i}.${keySuffix}`; + const valueSuffix = this.getKey("value", memberSchema.getMergedTraits().xmlName); + const valueKey = flat ? `${prefix}${i}.${valueSuffix}` : `${prefix}entry.${i}.${valueSuffix}`; + this.write(keySchema, k, key); + this.write(memberSchema, v, valueKey); + ++i; + } + } + } + else if (ns.isStructSchema()) { + if (value && typeof value === "object") { + for (const [memberName, member] of ns.structIterator()) { + if (value[memberName] == null && !member.isIdempotencyToken()) { + continue; + } + const suffix = this.getKey(memberName, member.getMergedTraits().xmlName); + const key = `${prefix}${suffix}`; + this.write(member, value[memberName], key); + } + } + } + else if (ns.isUnitSchema()) ; + else { + throw new Error(`@aws-sdk/core/protocols - QuerySerializer unrecognized schema type ${ns.getName(true)}`); + } + } + flush() { + if (this.buffer === undefined) { + throw new Error("@aws-sdk/core/protocols - QuerySerializer cannot flush with nothing written to buffer."); + } + const str = this.buffer; + delete this.buffer; + return str; + } + getKey(memberName, xmlName) { + const key = xmlName ?? memberName; + if (this.settings.capitalizeKeys) { + return key[0].toUpperCase() + key.slice(1); + } + return key; + } + writeKey(key) { + if (key.endsWith(".")) { + key = key.slice(0, key.length - 1); + } + this.buffer += `&${protocols.extendedEncodeURIComponent(key)}=`; + } + writeValue(value) { + this.buffer += protocols.extendedEncodeURIComponent(value); + } +} -module.exports = {"pagination":{"ListCloudFrontOriginAccessIdentities":{"input_token":"Marker","output_token":"CloudFrontOriginAccessIdentityList.NextMarker","limit_key":"MaxItems","more_results":"CloudFrontOriginAccessIdentityList.IsTruncated","result_key":"CloudFrontOriginAccessIdentityList.Items"},"ListDistributions":{"input_token":"Marker","output_token":"DistributionList.NextMarker","limit_key":"MaxItems","more_results":"DistributionList.IsTruncated","result_key":"DistributionList.Items"},"ListInvalidations":{"input_token":"Marker","output_token":"InvalidationList.NextMarker","limit_key":"MaxItems","more_results":"InvalidationList.IsTruncated","result_key":"InvalidationList.Items"},"ListStreamingDistributions":{"input_token":"Marker","output_token":"StreamingDistributionList.NextMarker","limit_key":"MaxItems","more_results":"StreamingDistributionList.IsTruncated","result_key":"StreamingDistributionList.Items"}}}; - -/***/ }), +class AwsQueryProtocol extends protocols.RpcProtocol { + options; + serializer; + deserializer; + mixin = new ProtocolLib(); + constructor(options) { + super({ + defaultNamespace: options.defaultNamespace, + }); + this.options = options; + const settings = { + timestampFormat: { + useTrait: true, + default: 5, + }, + httpBindings: false, + xmlNamespace: options.xmlNamespace, + serviceNamespace: options.defaultNamespace, + serializeEmptyLists: true, + }; + this.serializer = new QueryShapeSerializer(settings); + this.deserializer = new XmlShapeDeserializer(settings); + } + getShapeId() { + return "aws.protocols#awsQuery"; + } + setSerdeContext(serdeContext) { + this.serializer.setSerdeContext(serdeContext); + this.deserializer.setSerdeContext(serdeContext); + } + getPayloadCodec() { + throw new Error("AWSQuery protocol has no payload codec."); + } + async serializeRequest(operationSchema, input, context) { + const request = await super.serializeRequest(operationSchema, input, context); + if (!request.path.endsWith("/")) { + request.path += "/"; + } + Object.assign(request.headers, { + "content-type": `application/x-www-form-urlencoded`, + }); + if (schema.deref(operationSchema.input) === "unit" || !request.body) { + request.body = ""; + } + const action = operationSchema.name.split("#")[1] ?? operationSchema.name; + request.body = `Action=${action}&Version=${this.options.version}` + request.body; + if (request.body.endsWith("&")) { + request.body = request.body.slice(-1); + } + return request; + } + async deserializeResponse(operationSchema, context, response) { + const deserializer = this.deserializer; + const ns = schema.NormalizedSchema.of(operationSchema.output); + const dataObject = {}; + if (response.statusCode >= 300) { + const bytes = await protocols.collectBody(response.body, context); + if (bytes.byteLength > 0) { + Object.assign(dataObject, await deserializer.read(15, bytes)); + } + await this.handleError(operationSchema, context, response, dataObject, this.deserializeMetadata(response)); + } + for (const header in response.headers) { + const value = response.headers[header]; + delete response.headers[header]; + response.headers[header.toLowerCase()] = value; + } + const shortName = operationSchema.name.split("#")[1] ?? operationSchema.name; + const awsQueryResultKey = ns.isStructSchema() && this.useNestedResult() ? shortName + "Result" : undefined; + const bytes = await protocols.collectBody(response.body, context); + if (bytes.byteLength > 0) { + Object.assign(dataObject, await deserializer.read(ns, bytes, awsQueryResultKey)); + } + const output = { + $metadata: this.deserializeMetadata(response), + ...dataObject, + }; + return output; + } + useNestedResult() { + return true; + } + async handleError(operationSchema, context, response, dataObject, metadata) { + const errorIdentifier = this.loadQueryErrorCode(response, dataObject) ?? "Unknown"; + const errorData = this.loadQueryError(dataObject); + const message = this.loadQueryErrorMessage(dataObject); + errorData.message = message; + errorData.Error = { + Type: errorData.Type, + Code: errorData.Code, + Message: message, + }; + const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, errorData, metadata, (registry, errorName) => { + try { + return registry.getSchema(errorName); + } + catch (e) { + return registry.find((schema$1) => schema.NormalizedSchema.of(schema$1).getMergedTraits().awsQueryError?.[0] === errorName); + } + }); + const ns = schema.NormalizedSchema.of(errorSchema); + const ErrorCtor = schema.TypeRegistry.for(errorSchema[1]).getErrorCtor(errorSchema) ?? Error; + const exception = new ErrorCtor(message); + const output = { + Error: errorData.Error, + }; + for (const [name, member] of ns.structIterator()) { + const target = member.getMergedTraits().xmlName ?? name; + const value = errorData[target] ?? dataObject[target]; + output[name] = this.deserializer.readSchema(member, value); + } + throw this.mixin.decorateServiceException(Object.assign(exception, errorMetadata, { + $fault: ns.getMergedTraits().error, + message, + }, output), dataObject); + } + loadQueryErrorCode(output, data) { + const code = (data.Errors?.[0]?.Error ?? data.Errors?.Error ?? data.Error)?.Code; + if (code !== undefined) { + return code; + } + if (output.statusCode == 404) { + return "NotFound"; + } + } + loadQueryError(data) { + return data.Errors?.[0]?.Error ?? data.Errors?.Error ?? data.Error; + } + loadQueryErrorMessage(data) { + const errorData = this.loadQueryError(data); + return errorData?.message ?? errorData?.Message ?? data.message ?? data.Message ?? "Unknown"; + } + getDefaultContentType() { + return "application/x-www-form-urlencoded"; + } +} -/***/ 1527: -/***/ (function(module) { +class AwsEc2QueryProtocol extends AwsQueryProtocol { + options; + constructor(options) { + super(options); + this.options = options; + const ec2Settings = { + capitalizeKeys: true, + flattenLists: true, + serializeEmptyLists: false, + }; + Object.assign(this.serializer.settings, ec2Settings); + } + useNestedResult() { + return false; + } +} -module.exports = {"pagination":{"ListGraphs":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListInvitations":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListMembers":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"}}}; +const parseXmlBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => { + if (encoded.length) { + let parsedObj; + try { + parsedObj = xmlBuilder.parseXML(encoded); + } + catch (e) { + if (e && typeof e === "object") { + Object.defineProperty(e, "$responseBodyText", { + value: encoded, + }); + } + throw e; + } + const textNodeName = "#text"; + const key = Object.keys(parsedObj)[0]; + const parsedObjToReturn = parsedObj[key]; + if (parsedObjToReturn[textNodeName]) { + parsedObjToReturn[key] = parsedObjToReturn[textNodeName]; + delete parsedObjToReturn[textNodeName]; + } + return smithyClient.getValueFromTextNode(parsedObjToReturn); + } + return {}; +}); +const parseXmlErrorBody = async (errorBody, context) => { + const value = await parseXmlBody(errorBody, context); + if (value.Error) { + value.Error.message = value.Error.message ?? value.Error.Message; + } + return value; +}; +const loadRestXmlErrorCode = (output, data) => { + if (data?.Error?.Code !== undefined) { + return data.Error.Code; + } + if (data?.Code !== undefined) { + return data.Code; + } + if (output.statusCode == 404) { + return "NotFound"; + } +}; -/***/ }), +class XmlShapeSerializer extends SerdeContextConfig { + settings; + stringBuffer; + byteBuffer; + buffer; + constructor(settings) { + super(); + this.settings = settings; + } + write(schema$1, value) { + const ns = schema.NormalizedSchema.of(schema$1); + if (ns.isStringSchema() && typeof value === "string") { + this.stringBuffer = value; + } + else if (ns.isBlobSchema()) { + this.byteBuffer = + "byteLength" in value + ? value + : (this.serdeContext?.base64Decoder ?? utilBase64.fromBase64)(value); + } + else { + this.buffer = this.writeStruct(ns, value, undefined); + const traits = ns.getMergedTraits(); + if (traits.httpPayload && !traits.xmlName) { + this.buffer.withName(ns.getName()); + } + } + } + flush() { + if (this.byteBuffer !== undefined) { + const bytes = this.byteBuffer; + delete this.byteBuffer; + return bytes; + } + if (this.stringBuffer !== undefined) { + const str = this.stringBuffer; + delete this.stringBuffer; + return str; + } + const buffer = this.buffer; + if (this.settings.xmlNamespace) { + if (!buffer?.attributes?.["xmlns"]) { + buffer.addAttribute("xmlns", this.settings.xmlNamespace); + } + } + delete this.buffer; + return buffer.toString(); + } + writeStruct(ns, value, parentXmlns) { + const traits = ns.getMergedTraits(); + const name = ns.isMemberSchema() && !traits.httpPayload + ? ns.getMemberTraits().xmlName ?? ns.getMemberName() + : traits.xmlName ?? ns.getName(); + if (!name || !ns.isStructSchema()) { + throw new Error(`@aws-sdk/core/protocols - xml serializer, cannot write struct with empty name or non-struct, schema=${ns.getName(true)}.`); + } + const structXmlNode = xmlBuilder.XmlNode.of(name); + const [xmlnsAttr, xmlns] = this.getXmlnsAttribute(ns, parentXmlns); + for (const [memberName, memberSchema] of ns.structIterator()) { + const val = value[memberName]; + if (val != null || memberSchema.isIdempotencyToken()) { + if (memberSchema.getMergedTraits().xmlAttribute) { + structXmlNode.addAttribute(memberSchema.getMergedTraits().xmlName ?? memberName, this.writeSimple(memberSchema, val)); + continue; + } + if (memberSchema.isListSchema()) { + this.writeList(memberSchema, val, structXmlNode, xmlns); + } + else if (memberSchema.isMapSchema()) { + this.writeMap(memberSchema, val, structXmlNode, xmlns); + } + else if (memberSchema.isStructSchema()) { + structXmlNode.addChildNode(this.writeStruct(memberSchema, val, xmlns)); + } + else { + const memberNode = xmlBuilder.XmlNode.of(memberSchema.getMergedTraits().xmlName ?? memberSchema.getMemberName()); + this.writeSimpleInto(memberSchema, val, memberNode, xmlns); + structXmlNode.addChildNode(memberNode); + } + } + } + if (xmlns) { + structXmlNode.addAttribute(xmlnsAttr, xmlns); + } + return structXmlNode; + } + writeList(listMember, array, container, parentXmlns) { + if (!listMember.isMemberSchema()) { + throw new Error(`@aws-sdk/core/protocols - xml serializer, cannot write non-member list: ${listMember.getName(true)}`); + } + const listTraits = listMember.getMergedTraits(); + const listValueSchema = listMember.getValueSchema(); + const listValueTraits = listValueSchema.getMergedTraits(); + const sparse = !!listValueTraits.sparse; + const flat = !!listTraits.xmlFlattened; + const [xmlnsAttr, xmlns] = this.getXmlnsAttribute(listMember, parentXmlns); + const writeItem = (container, value) => { + if (listValueSchema.isListSchema()) { + this.writeList(listValueSchema, Array.isArray(value) ? value : [value], container, xmlns); + } + else if (listValueSchema.isMapSchema()) { + this.writeMap(listValueSchema, value, container, xmlns); + } + else if (listValueSchema.isStructSchema()) { + const struct = this.writeStruct(listValueSchema, value, xmlns); + container.addChildNode(struct.withName(flat ? listTraits.xmlName ?? listMember.getMemberName() : listValueTraits.xmlName ?? "member")); + } + else { + const listItemNode = xmlBuilder.XmlNode.of(flat ? listTraits.xmlName ?? listMember.getMemberName() : listValueTraits.xmlName ?? "member"); + this.writeSimpleInto(listValueSchema, value, listItemNode, xmlns); + container.addChildNode(listItemNode); + } + }; + if (flat) { + for (const value of array) { + if (sparse || value != null) { + writeItem(container, value); + } + } + } + else { + const listNode = xmlBuilder.XmlNode.of(listTraits.xmlName ?? listMember.getMemberName()); + if (xmlns) { + listNode.addAttribute(xmlnsAttr, xmlns); + } + for (const value of array) { + if (sparse || value != null) { + writeItem(listNode, value); + } + } + container.addChildNode(listNode); + } + } + writeMap(mapMember, map, container, parentXmlns, containerIsMap = false) { + if (!mapMember.isMemberSchema()) { + throw new Error(`@aws-sdk/core/protocols - xml serializer, cannot write non-member map: ${mapMember.getName(true)}`); + } + const mapTraits = mapMember.getMergedTraits(); + const mapKeySchema = mapMember.getKeySchema(); + const mapKeyTraits = mapKeySchema.getMergedTraits(); + const keyTag = mapKeyTraits.xmlName ?? "key"; + const mapValueSchema = mapMember.getValueSchema(); + const mapValueTraits = mapValueSchema.getMergedTraits(); + const valueTag = mapValueTraits.xmlName ?? "value"; + const sparse = !!mapValueTraits.sparse; + const flat = !!mapTraits.xmlFlattened; + const [xmlnsAttr, xmlns] = this.getXmlnsAttribute(mapMember, parentXmlns); + const addKeyValue = (entry, key, val) => { + const keyNode = xmlBuilder.XmlNode.of(keyTag, key); + const [keyXmlnsAttr, keyXmlns] = this.getXmlnsAttribute(mapKeySchema, xmlns); + if (keyXmlns) { + keyNode.addAttribute(keyXmlnsAttr, keyXmlns); + } + entry.addChildNode(keyNode); + let valueNode = xmlBuilder.XmlNode.of(valueTag); + if (mapValueSchema.isListSchema()) { + this.writeList(mapValueSchema, val, valueNode, xmlns); + } + else if (mapValueSchema.isMapSchema()) { + this.writeMap(mapValueSchema, val, valueNode, xmlns, true); + } + else if (mapValueSchema.isStructSchema()) { + valueNode = this.writeStruct(mapValueSchema, val, xmlns); + } + else { + this.writeSimpleInto(mapValueSchema, val, valueNode, xmlns); + } + entry.addChildNode(valueNode); + }; + if (flat) { + for (const [key, val] of Object.entries(map)) { + if (sparse || val != null) { + const entry = xmlBuilder.XmlNode.of(mapTraits.xmlName ?? mapMember.getMemberName()); + addKeyValue(entry, key, val); + container.addChildNode(entry); + } + } + } + else { + let mapNode; + if (!containerIsMap) { + mapNode = xmlBuilder.XmlNode.of(mapTraits.xmlName ?? mapMember.getMemberName()); + if (xmlns) { + mapNode.addAttribute(xmlnsAttr, xmlns); + } + container.addChildNode(mapNode); + } + for (const [key, val] of Object.entries(map)) { + if (sparse || val != null) { + const entry = xmlBuilder.XmlNode.of("entry"); + addKeyValue(entry, key, val); + (containerIsMap ? container : mapNode).addChildNode(entry); + } + } + } + } + writeSimple(_schema, value) { + if (null === value) { + throw new Error("@aws-sdk/core/protocols - (XML serializer) cannot write null value."); + } + const ns = schema.NormalizedSchema.of(_schema); + let nodeContents = null; + if (value && typeof value === "object") { + if (ns.isBlobSchema()) { + nodeContents = (this.serdeContext?.base64Encoder ?? utilBase64.toBase64)(value); + } + else if (ns.isTimestampSchema() && value instanceof Date) { + const format = protocols.determineTimestampFormat(ns, this.settings); + switch (format) { + case 5: + nodeContents = value.toISOString().replace(".000Z", "Z"); + break; + case 6: + nodeContents = smithyClient.dateToUtcString(value); + break; + case 7: + nodeContents = String(value.getTime() / 1000); + break; + default: + console.warn("Missing timestamp format, using http date", value); + nodeContents = smithyClient.dateToUtcString(value); + break; + } + } + else if (ns.isBigDecimalSchema() && value) { + if (value instanceof serde.NumericValue) { + return value.string; + } + return String(value); + } + else if (ns.isMapSchema() || ns.isListSchema()) { + throw new Error("@aws-sdk/core/protocols - xml serializer, cannot call _write() on List/Map schema, call writeList or writeMap() instead."); + } + else { + throw new Error(`@aws-sdk/core/protocols - xml serializer, unhandled schema type for object value and schema: ${ns.getName(true)}`); + } + } + if (ns.isBooleanSchema() || ns.isNumericSchema() || ns.isBigIntegerSchema() || ns.isBigDecimalSchema()) { + nodeContents = String(value); + } + if (ns.isStringSchema()) { + if (value === undefined && ns.isIdempotencyToken()) { + nodeContents = serde.generateIdempotencyToken(); + } + else { + nodeContents = String(value); + } + } + if (nodeContents === null) { + throw new Error(`Unhandled schema-value pair ${ns.getName(true)}=${value}`); + } + return nodeContents; + } + writeSimpleInto(_schema, value, into, parentXmlns) { + const nodeContents = this.writeSimple(_schema, value); + const ns = schema.NormalizedSchema.of(_schema); + const content = new xmlBuilder.XmlText(nodeContents); + const [xmlnsAttr, xmlns] = this.getXmlnsAttribute(ns, parentXmlns); + if (xmlns) { + into.addAttribute(xmlnsAttr, xmlns); + } + into.addChildNode(content); + } + getXmlnsAttribute(ns, parentXmlns) { + const traits = ns.getMergedTraits(); + const [prefix, xmlns] = traits.xmlNamespace ?? []; + if (xmlns && xmlns !== parentXmlns) { + return [prefix ? `xmlns:${prefix}` : "xmlns", xmlns]; + } + return [void 0, void 0]; + } +} -/***/ 1529: -/***/ (function(module) { +class XmlCodec extends SerdeContextConfig { + settings; + constructor(settings) { + super(); + this.settings = settings; + } + createSerializer() { + const serializer = new XmlShapeSerializer(this.settings); + serializer.setSerdeContext(this.serdeContext); + return serializer; + } + createDeserializer() { + const deserializer = new XmlShapeDeserializer(this.settings); + deserializer.setSerdeContext(this.serdeContext); + return deserializer; + } +} -module.exports = {"pagination":{}}; +class AwsRestXmlProtocol extends protocols.HttpBindingProtocol { + codec; + serializer; + deserializer; + mixin = new ProtocolLib(); + constructor(options) { + super(options); + const settings = { + timestampFormat: { + useTrait: true, + default: 5, + }, + httpBindings: true, + xmlNamespace: options.xmlNamespace, + serviceNamespace: options.defaultNamespace, + }; + this.codec = new XmlCodec(settings); + this.serializer = new protocols.HttpInterceptingShapeSerializer(this.codec.createSerializer(), settings); + this.deserializer = new protocols.HttpInterceptingShapeDeserializer(this.codec.createDeserializer(), settings); + } + getPayloadCodec() { + return this.codec; + } + getShapeId() { + return "aws.protocols#restXml"; + } + async serializeRequest(operationSchema, input, context) { + const request = await super.serializeRequest(operationSchema, input, context); + const inputSchema = schema.NormalizedSchema.of(operationSchema.input); + if (!request.headers["content-type"]) { + const contentType = this.mixin.resolveRestContentType(this.getDefaultContentType(), inputSchema); + if (contentType) { + request.headers["content-type"] = contentType; + } + } + if (request.headers["content-type"] === this.getDefaultContentType()) { + if (typeof request.body === "string") { + request.body = '' + request.body; + } + } + return request; + } + async deserializeResponse(operationSchema, context, response) { + return super.deserializeResponse(operationSchema, context, response); + } + async handleError(operationSchema, context, response, dataObject, metadata) { + const errorIdentifier = loadRestXmlErrorCode(response, dataObject) ?? "Unknown"; + const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, dataObject, metadata); + const ns = schema.NormalizedSchema.of(errorSchema); + const message = dataObject.Error?.message ?? dataObject.Error?.Message ?? dataObject.message ?? dataObject.Message ?? "Unknown"; + const ErrorCtor = schema.TypeRegistry.for(errorSchema[1]).getErrorCtor(errorSchema) ?? Error; + const exception = new ErrorCtor(message); + await this.deserializeHttpMessage(errorSchema, context, response, dataObject); + const output = {}; + for (const [name, member] of ns.structIterator()) { + const target = member.getMergedTraits().xmlName ?? name; + const value = dataObject.Error?.[target] ?? dataObject[target]; + output[name] = this.codec.createDeserializer().readSchema(member, value); + } + throw this.mixin.decorateServiceException(Object.assign(exception, errorMetadata, { + $fault: ns.getMergedTraits().error, + message, + }, output), dataObject); + } + getDefaultContentType() { + return "application/xml"; + } +} -/***/ }), +exports.AwsEc2QueryProtocol = AwsEc2QueryProtocol; +exports.AwsJson1_0Protocol = AwsJson1_0Protocol; +exports.AwsJson1_1Protocol = AwsJson1_1Protocol; +exports.AwsJsonRpcProtocol = AwsJsonRpcProtocol; +exports.AwsQueryProtocol = AwsQueryProtocol; +exports.AwsRestJsonProtocol = AwsRestJsonProtocol; +exports.AwsRestXmlProtocol = AwsRestXmlProtocol; +exports.AwsSmithyRpcV2CborProtocol = AwsSmithyRpcV2CborProtocol; +exports.JsonCodec = JsonCodec; +exports.JsonShapeDeserializer = JsonShapeDeserializer; +exports.JsonShapeSerializer = JsonShapeSerializer; +exports.XmlCodec = XmlCodec; +exports.XmlShapeDeserializer = XmlShapeDeserializer; +exports.XmlShapeSerializer = XmlShapeSerializer; +exports._toBool = _toBool; +exports._toNum = _toNum; +exports._toStr = _toStr; +exports.awsExpectUnion = awsExpectUnion; +exports.loadRestJsonErrorCode = loadRestJsonErrorCode; +exports.loadRestXmlErrorCode = loadRestXmlErrorCode; +exports.parseJsonBody = parseJsonBody; +exports.parseJsonErrorBody = parseJsonErrorBody; +exports.parseXmlBody = parseXmlBody; +exports.parseXmlErrorBody = parseXmlErrorBody; + + +/***/ }), + +/***/ 5606: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -/***/ 1530: -/***/ (function(module, __unusedexports, __webpack_require__) { +"use strict"; -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; -apiLoader.services['computeoptimizer'] = {}; -AWS.ComputeOptimizer = Service.defineService('computeoptimizer', ['2019-11-01']); -Object.defineProperty(apiLoader.services['computeoptimizer'], '2019-11-01', { - get: function get() { - var model = __webpack_require__(3165); - model.paginators = __webpack_require__(9693).pagination; - return model; - }, - enumerable: true, - configurable: true -}); +var client = __nccwpck_require__(5152); +var propertyProvider = __nccwpck_require__(8857); + +const ENV_KEY = "AWS_ACCESS_KEY_ID"; +const ENV_SECRET = "AWS_SECRET_ACCESS_KEY"; +const ENV_SESSION = "AWS_SESSION_TOKEN"; +const ENV_EXPIRATION = "AWS_CREDENTIAL_EXPIRATION"; +const ENV_CREDENTIAL_SCOPE = "AWS_CREDENTIAL_SCOPE"; +const ENV_ACCOUNT_ID = "AWS_ACCOUNT_ID"; +const fromEnv = (init) => async () => { + init?.logger?.debug("@aws-sdk/credential-provider-env - fromEnv"); + const accessKeyId = process.env[ENV_KEY]; + const secretAccessKey = process.env[ENV_SECRET]; + const sessionToken = process.env[ENV_SESSION]; + const expiry = process.env[ENV_EXPIRATION]; + const credentialScope = process.env[ENV_CREDENTIAL_SCOPE]; + const accountId = process.env[ENV_ACCOUNT_ID]; + if (accessKeyId && secretAccessKey) { + const credentials = { + accessKeyId, + secretAccessKey, + ...(sessionToken && { sessionToken }), + ...(expiry && { expiration: new Date(expiry) }), + ...(credentialScope && { credentialScope }), + ...(accountId && { accountId }), + }; + client.setCredentialFeature(credentials, "CREDENTIALS_ENV_VARS", "g"); + return credentials; + } + throw new propertyProvider.CredentialsProviderError("Unable to find environment variable credentials.", { logger: init?.logger }); +}; -module.exports = AWS.ComputeOptimizer; +exports.ENV_ACCOUNT_ID = ENV_ACCOUNT_ID; +exports.ENV_CREDENTIAL_SCOPE = ENV_CREDENTIAL_SCOPE; +exports.ENV_EXPIRATION = ENV_EXPIRATION; +exports.ENV_KEY = ENV_KEY; +exports.ENV_SECRET = ENV_SECRET; +exports.ENV_SESSION = ENV_SESSION; +exports.fromEnv = fromEnv; /***/ }), -/***/ 1531: -/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) { - -__webpack_require__(4281); +/***/ 5861: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { +"use strict"; -/***/ }), - -/***/ 1536: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; -apiLoader.services['lexmodelbuildingservice'] = {}; -AWS.LexModelBuildingService = Service.defineService('lexmodelbuildingservice', ['2017-04-19']); -Object.defineProperty(apiLoader.services['lexmodelbuildingservice'], '2017-04-19', { - get: function get() { - var model = __webpack_require__(5614); - model.paginators = __webpack_require__(2120).pagination; - return model; - }, - enumerable: true, - configurable: true -}); +var credentialProviderEnv = __nccwpck_require__(5606); +var propertyProvider = __nccwpck_require__(8857); +var sharedIniFileLoader = __nccwpck_require__(4964); -module.exports = AWS.LexModelBuildingService; +const ENV_IMDS_DISABLED = "AWS_EC2_METADATA_DISABLED"; +const remoteProvider = async (init) => { + const { ENV_CMDS_FULL_URI, ENV_CMDS_RELATIVE_URI, fromContainerMetadata, fromInstanceMetadata } = await __nccwpck_require__.e(/* import() */ 566).then(__nccwpck_require__.t.bind(__nccwpck_require__, 566, 19)); + if (process.env[ENV_CMDS_RELATIVE_URI] || process.env[ENV_CMDS_FULL_URI]) { + init.logger?.debug("@aws-sdk/credential-provider-node - remoteProvider::fromHttp/fromContainerMetadata"); + const { fromHttp } = await __nccwpck_require__.e(/* import() */ 605).then(__nccwpck_require__.bind(__nccwpck_require__, 8605)); + return propertyProvider.chain(fromHttp(init), fromContainerMetadata(init)); + } + if (process.env[ENV_IMDS_DISABLED] && process.env[ENV_IMDS_DISABLED] !== "false") { + return async () => { + throw new propertyProvider.CredentialsProviderError("EC2 Instance Metadata Service access disabled", { logger: init.logger }); + }; + } + init.logger?.debug("@aws-sdk/credential-provider-node - remoteProvider::fromInstanceMetadata"); + return fromInstanceMetadata(init); +}; +function memoizeChain(providers, treatAsExpired) { + const chain = internalCreateChain(providers); + let activeLock; + let passiveLock; + let credentials; + const provider = async (options) => { + if (options?.forceRefresh) { + return await chain(options); + } + if (credentials?.expiration) { + if (credentials?.expiration?.getTime() < Date.now()) { + credentials = undefined; + } + } + if (activeLock) { + await activeLock; + } + else if (!credentials || treatAsExpired?.(credentials)) { + if (credentials) { + if (!passiveLock) { + passiveLock = chain(options).then((c) => { + credentials = c; + passiveLock = undefined; + }); + } + } + else { + activeLock = chain(options).then((c) => { + credentials = c; + activeLock = undefined; + }); + return provider(options); + } + } + return credentials; + }; + return provider; +} +const internalCreateChain = (providers) => async (awsIdentityProperties) => { + let lastProviderError; + for (const provider of providers) { + try { + return await provider(awsIdentityProperties); + } + catch (err) { + lastProviderError = err; + if (err?.tryNextLink) { + continue; + } + throw err; + } + } + throw lastProviderError; +}; -/***/ }), +let multipleCredentialSourceWarningEmitted = false; +const defaultProvider = (init = {}) => memoizeChain([ + async () => { + const profile = init.profile ?? process.env[sharedIniFileLoader.ENV_PROFILE]; + if (profile) { + const envStaticCredentialsAreSet = process.env[credentialProviderEnv.ENV_KEY] && process.env[credentialProviderEnv.ENV_SECRET]; + if (envStaticCredentialsAreSet) { + if (!multipleCredentialSourceWarningEmitted) { + const warnFn = init.logger?.warn && init.logger?.constructor?.name !== "NoOpLogger" + ? init.logger.warn.bind(init.logger) + : console.warn; + warnFn(`@aws-sdk/credential-provider-node - defaultProvider::fromEnv WARNING: + Multiple credential sources detected: + Both AWS_PROFILE and the pair AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY static credentials are set. + This SDK will proceed with the AWS_PROFILE value. + + However, a future version may change this behavior to prefer the ENV static credentials. + Please ensure that your environment only sets either the AWS_PROFILE or the + AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY pair. +`); + multipleCredentialSourceWarningEmitted = true; + } + } + throw new propertyProvider.CredentialsProviderError("AWS_PROFILE is set, skipping fromEnv provider.", { + logger: init.logger, + tryNextLink: true, + }); + } + init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromEnv"); + return credentialProviderEnv.fromEnv(init)(); + }, + async (awsIdentityProperties) => { + init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromSSO"); + const { ssoStartUrl, ssoAccountId, ssoRegion, ssoRoleName, ssoSession } = init; + if (!ssoStartUrl && !ssoAccountId && !ssoRegion && !ssoRoleName && !ssoSession) { + throw new propertyProvider.CredentialsProviderError("Skipping SSO provider in default chain (inputs do not include SSO fields).", { logger: init.logger }); + } + const { fromSSO } = await __nccwpck_require__.e(/* import() */ 998).then(__nccwpck_require__.t.bind(__nccwpck_require__, 998, 19)); + return fromSSO(init)(awsIdentityProperties); + }, + async (awsIdentityProperties) => { + init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromIni"); + const { fromIni } = await __nccwpck_require__.e(/* import() */ 869).then(__nccwpck_require__.t.bind(__nccwpck_require__, 5869, 19)); + return fromIni(init)(awsIdentityProperties); + }, + async (awsIdentityProperties) => { + init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromProcess"); + const { fromProcess } = await __nccwpck_require__.e(/* import() */ 360).then(__nccwpck_require__.t.bind(__nccwpck_require__, 5360, 19)); + return fromProcess(init)(awsIdentityProperties); + }, + async (awsIdentityProperties) => { + init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromTokenFile"); + const { fromTokenFile } = await __nccwpck_require__.e(/* import() */ 956).then(__nccwpck_require__.t.bind(__nccwpck_require__, 9956, 23)); + return fromTokenFile(init)(awsIdentityProperties); + }, + async () => { + init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::remoteProvider"); + return (await remoteProvider(init))(); + }, + async () => { + throw new propertyProvider.CredentialsProviderError("Could not load credentials from any providers", { + tryNextLink: false, + logger: init.logger, + }); + }, +], credentialsTreatedAsExpired); +const credentialsWillNeedRefresh = (credentials) => credentials?.expiration !== undefined; +const credentialsTreatedAsExpired = (credentials) => credentials?.expiration !== undefined && credentials.expiration.getTime() - Date.now() < 300000; -/***/ 1561: -/***/ (function(module) { +exports.credentialsTreatedAsExpired = credentialsTreatedAsExpired; +exports.credentialsWillNeedRefresh = credentialsWillNeedRefresh; +exports.defaultProvider = defaultProvider; -module.exports = {"pagination":{"GetExecutionHistory":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken","result_key":"events"},"ListActivities":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken","result_key":"activities"},"ListExecutions":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken","result_key":"executions"},"ListStateMachines":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken","result_key":"stateMachines"}}}; /***/ }), -/***/ 1583: -/***/ (function(module, __unusedexports, __webpack_require__) { +/***/ 2590: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -var memoizedProperty = __webpack_require__(153).memoizedProperty; +"use strict"; -function memoize(name, value, factory, nameTr) { - memoizedProperty(this, nameTr(name), function() { - return factory(name, value); - }); -} -function Collection(iterable, options, factory, nameTr, callback) { - nameTr = nameTr || String; - var self = this; +var protocolHttp = __nccwpck_require__(2356); - for (var id in iterable) { - if (Object.prototype.hasOwnProperty.call(iterable, id)) { - memoize.call(self, id, iterable[id], factory, nameTr); - if (callback) callback(id, iterable[id]); - } - } +function resolveHostHeaderConfig(input) { + return input; } +const hostHeaderMiddleware = (options) => (next) => async (args) => { + if (!protocolHttp.HttpRequest.isInstance(args.request)) + return next(args); + const { request } = args; + const { handlerProtocol = "" } = options.requestHandler.metadata || {}; + if (handlerProtocol.indexOf("h2") >= 0 && !request.headers[":authority"]) { + delete request.headers["host"]; + request.headers[":authority"] = request.hostname + (request.port ? ":" + request.port : ""); + } + else if (!request.headers["host"]) { + let host = request.hostname; + if (request.port != null) + host += `:${request.port}`; + request.headers["host"] = host; + } + return next(args); +}; +const hostHeaderMiddlewareOptions = { + name: "hostHeaderMiddleware", + step: "build", + priority: "low", + tags: ["HOST"], + override: true, +}; +const getHostHeaderPlugin = (options) => ({ + applyToStack: (clientStack) => { + clientStack.add(hostHeaderMiddleware(options), hostHeaderMiddlewareOptions); + }, +}); -/** - * @api private - */ -module.exports = Collection; +exports.getHostHeaderPlugin = getHostHeaderPlugin; +exports.hostHeaderMiddleware = hostHeaderMiddleware; +exports.hostHeaderMiddlewareOptions = hostHeaderMiddlewareOptions; +exports.resolveHostHeaderConfig = resolveHostHeaderConfig; /***/ }), -/***/ 1592: -/***/ (function(module, __unusedexports, __webpack_require__) { +/***/ 5242: +/***/ ((__unused_webpack_module, exports) => { -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +"use strict"; -apiLoader.services['serverlessapplicationrepository'] = {}; -AWS.ServerlessApplicationRepository = Service.defineService('serverlessapplicationrepository', ['2017-09-08']); -Object.defineProperty(apiLoader.services['serverlessapplicationrepository'], '2017-09-08', { - get: function get() { - var model = __webpack_require__(3252); - model.paginators = __webpack_require__(3080).pagination; - return model; - }, - enumerable: true, - configurable: true + +const loggerMiddleware = () => (next, context) => async (args) => { + try { + const response = await next(args); + const { clientName, commandName, logger, dynamoDbDocumentClientOptions = {} } = context; + const { overrideInputFilterSensitiveLog, overrideOutputFilterSensitiveLog } = dynamoDbDocumentClientOptions; + const inputFilterSensitiveLog = overrideInputFilterSensitiveLog ?? context.inputFilterSensitiveLog; + const outputFilterSensitiveLog = overrideOutputFilterSensitiveLog ?? context.outputFilterSensitiveLog; + const { $metadata, ...outputWithoutMetadata } = response.output; + logger?.info?.({ + clientName, + commandName, + input: inputFilterSensitiveLog(args.input), + output: outputFilterSensitiveLog(outputWithoutMetadata), + metadata: $metadata, + }); + return response; + } + catch (error) { + const { clientName, commandName, logger, dynamoDbDocumentClientOptions = {} } = context; + const { overrideInputFilterSensitiveLog } = dynamoDbDocumentClientOptions; + const inputFilterSensitiveLog = overrideInputFilterSensitiveLog ?? context.inputFilterSensitiveLog; + logger?.error?.({ + clientName, + commandName, + input: inputFilterSensitiveLog(args.input), + error, + metadata: error.$metadata, + }); + throw error; + } +}; +const loggerMiddlewareOptions = { + name: "loggerMiddleware", + tags: ["LOGGER"], + step: "initialize", + override: true, +}; +const getLoggerPlugin = (options) => ({ + applyToStack: (clientStack) => { + clientStack.add(loggerMiddleware(), loggerMiddlewareOptions); + }, }); -module.exports = AWS.ServerlessApplicationRepository; +exports.getLoggerPlugin = getLoggerPlugin; +exports.loggerMiddleware = loggerMiddleware; +exports.loggerMiddlewareOptions = loggerMiddlewareOptions; /***/ }), -/***/ 1595: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2017-07-25","endpointPrefix":"api.elastic-inference","jsonVersion":"1.1","protocol":"rest-json","serviceAbbreviation":"Amazon Elastic Inference","serviceFullName":"Amazon Elastic Inference","serviceId":"Elastic Inference","signatureVersion":"v4","signingName":"elastic-inference","uid":"elastic-inference-2017-07-25"},"operations":{"DescribeAcceleratorOfferings":{"http":{"requestUri":"/describe-accelerator-offerings"},"input":{"type":"structure","required":["locationType"],"members":{"locationType":{},"acceleratorTypes":{"type":"list","member":{}}}},"output":{"type":"structure","members":{"acceleratorTypeOfferings":{"type":"list","member":{"type":"structure","members":{"acceleratorType":{},"locationType":{},"location":{}}}}}}},"DescribeAcceleratorTypes":{"http":{"method":"GET","requestUri":"/describe-accelerator-types"},"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"acceleratorTypes":{"type":"list","member":{"type":"structure","members":{"acceleratorTypeName":{},"memoryInfo":{"type":"structure","members":{"sizeInMiB":{"type":"integer"}}},"throughputInfo":{"type":"list","member":{"type":"structure","members":{"key":{},"value":{"type":"integer"}}}}}}}}}},"DescribeAccelerators":{"http":{"requestUri":"/describe-accelerators"},"input":{"type":"structure","members":{"acceleratorIds":{"type":"list","member":{}},"filters":{"type":"list","member":{"type":"structure","members":{"name":{},"values":{"type":"list","member":{}}}}},"maxResults":{"type":"integer"},"nextToken":{}}},"output":{"type":"structure","members":{"acceleratorSet":{"type":"list","member":{"type":"structure","members":{"acceleratorHealth":{"type":"structure","members":{"status":{}}},"acceleratorType":{},"acceleratorId":{},"availabilityZone":{},"attachedResource":{}}}},"nextToken":{}}}},"ListTagsForResource":{"http":{"method":"GET","requestUri":"/tags/{resourceArn}"},"input":{"type":"structure","required":["resourceArn"],"members":{"resourceArn":{"location":"uri","locationName":"resourceArn"}}},"output":{"type":"structure","members":{"tags":{"shape":"S13"}}}},"TagResource":{"http":{"requestUri":"/tags/{resourceArn}"},"input":{"type":"structure","required":["resourceArn","tags"],"members":{"resourceArn":{"location":"uri","locationName":"resourceArn"},"tags":{"shape":"S13"}}},"output":{"type":"structure","members":{}}},"UntagResource":{"http":{"method":"DELETE","requestUri":"/tags/{resourceArn}"},"input":{"type":"structure","required":["resourceArn","tagKeys"],"members":{"resourceArn":{"location":"uri","locationName":"resourceArn"},"tagKeys":{"location":"querystring","locationName":"tagKeys","type":"list","member":{}}}},"output":{"type":"structure","members":{}}}},"shapes":{"S13":{"type":"map","key":{},"value":{}}}}; +/***/ 1568: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -/***/ }), +"use strict"; -/***/ 1599: -/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) { -var AWS = __webpack_require__(395); +var recursionDetectionMiddleware = __nccwpck_require__(2521); -AWS.util.update(AWS.MachineLearning.prototype, { - /** - * @api private - */ - setupRequestListeners: function setupRequestListeners(request) { - if (request.operation === 'predict') { - request.addListener('build', this.buildEndpoint); - } - }, +const recursionDetectionMiddlewareOptions = { + step: "build", + tags: ["RECURSION_DETECTION"], + name: "recursionDetectionMiddleware", + override: true, + priority: "low", +}; - /** - * Updates request endpoint from PredictEndpoint - * @api private - */ - buildEndpoint: function buildEndpoint(request) { - var url = request.params.PredictEndpoint; - if (url) { - request.httpRequest.endpoint = new AWS.Endpoint(url); - } - } +const getRecursionDetectionPlugin = (options) => ({ + applyToStack: (clientStack) => { + clientStack.add(recursionDetectionMiddleware.recursionDetectionMiddleware(), recursionDetectionMiddlewareOptions); + }, +}); +exports.getRecursionDetectionPlugin = getRecursionDetectionPlugin; +Object.keys(recursionDetectionMiddleware).forEach(function (k) { + if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, { + enumerable: true, + get: function () { return recursionDetectionMiddleware[k]; } + }); }); /***/ }), -/***/ 1602: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['translate'] = {}; -AWS.Translate = Service.defineService('translate', ['2017-07-01']); -Object.defineProperty(apiLoader.services['translate'], '2017-07-01', { - get: function get() { - var model = __webpack_require__(5452); - model.paginators = __webpack_require__(324).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.Translate; - +/***/ 2521: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -/***/ }), +"use strict"; -/***/ 1626: -/***/ (function(module) { +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.recursionDetectionMiddleware = void 0; +const lambda_invoke_store_1 = __nccwpck_require__(9320); +const protocol_http_1 = __nccwpck_require__(2356); +const TRACE_ID_HEADER_NAME = "X-Amzn-Trace-Id"; +const ENV_LAMBDA_FUNCTION_NAME = "AWS_LAMBDA_FUNCTION_NAME"; +const ENV_TRACE_ID = "_X_AMZN_TRACE_ID"; +const recursionDetectionMiddleware = () => (next) => async (args) => { + const { request } = args; + if (!protocol_http_1.HttpRequest.isInstance(request)) { + return next(args); + } + const traceIdHeader = Object.keys(request.headers ?? {}).find((h) => h.toLowerCase() === TRACE_ID_HEADER_NAME.toLowerCase()) ?? + TRACE_ID_HEADER_NAME; + if (request.headers.hasOwnProperty(traceIdHeader)) { + return next(args); + } + const functionName = process.env[ENV_LAMBDA_FUNCTION_NAME]; + const traceIdFromEnv = process.env[ENV_TRACE_ID]; + const invokeStore = await lambda_invoke_store_1.InvokeStore.getInstanceAsync(); + const traceIdFromInvokeStore = invokeStore?.getXRayTraceId(); + const traceId = traceIdFromInvokeStore ?? traceIdFromEnv; + const nonEmptyString = (str) => typeof str === "string" && str.length > 0; + if (nonEmptyString(functionName) && nonEmptyString(traceId)) { + request.headers[TRACE_ID_HEADER_NAME] = traceId; + } + return next({ + ...args, + request, + }); +}; +exports.recursionDetectionMiddleware = recursionDetectionMiddleware; -module.exports = {"pagination":{"GetQueryResults":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"ListDataCatalogs":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"DataCatalogsSummary"},"ListDatabases":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"DatabaseList"},"ListNamedQueries":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"ListQueryExecutions":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"ListTableMetadata":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"TableMetadataList"},"ListTagsForResource":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Tags"},"ListWorkGroups":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"}}}; /***/ }), -/***/ 1627: -/***/ (function(module) { +/***/ 2959: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -module.exports = {"version":2,"waiters":{"CacheClusterAvailable":{"acceptors":[{"argument":"CacheClusters[].CacheClusterStatus","expected":"available","matcher":"pathAll","state":"success"},{"argument":"CacheClusters[].CacheClusterStatus","expected":"deleted","matcher":"pathAny","state":"failure"},{"argument":"CacheClusters[].CacheClusterStatus","expected":"deleting","matcher":"pathAny","state":"failure"},{"argument":"CacheClusters[].CacheClusterStatus","expected":"incompatible-network","matcher":"pathAny","state":"failure"},{"argument":"CacheClusters[].CacheClusterStatus","expected":"restore-failed","matcher":"pathAny","state":"failure"}],"delay":15,"description":"Wait until ElastiCache cluster is available.","maxAttempts":40,"operation":"DescribeCacheClusters"},"CacheClusterDeleted":{"acceptors":[{"argument":"CacheClusters[].CacheClusterStatus","expected":"deleted","matcher":"pathAll","state":"success"},{"expected":"CacheClusterNotFound","matcher":"error","state":"success"},{"argument":"CacheClusters[].CacheClusterStatus","expected":"available","matcher":"pathAny","state":"failure"},{"argument":"CacheClusters[].CacheClusterStatus","expected":"creating","matcher":"pathAny","state":"failure"},{"argument":"CacheClusters[].CacheClusterStatus","expected":"incompatible-network","matcher":"pathAny","state":"failure"},{"argument":"CacheClusters[].CacheClusterStatus","expected":"modifying","matcher":"pathAny","state":"failure"},{"argument":"CacheClusters[].CacheClusterStatus","expected":"restore-failed","matcher":"pathAny","state":"failure"},{"argument":"CacheClusters[].CacheClusterStatus","expected":"snapshotting","matcher":"pathAny","state":"failure"}],"delay":15,"description":"Wait until ElastiCache cluster is deleted.","maxAttempts":40,"operation":"DescribeCacheClusters"},"ReplicationGroupAvailable":{"acceptors":[{"argument":"ReplicationGroups[].Status","expected":"available","matcher":"pathAll","state":"success"},{"argument":"ReplicationGroups[].Status","expected":"deleted","matcher":"pathAny","state":"failure"}],"delay":15,"description":"Wait until ElastiCache replication group is available.","maxAttempts":40,"operation":"DescribeReplicationGroups"},"ReplicationGroupDeleted":{"acceptors":[{"argument":"ReplicationGroups[].Status","expected":"deleted","matcher":"pathAll","state":"success"},{"argument":"ReplicationGroups[].Status","expected":"available","matcher":"pathAny","state":"failure"},{"expected":"ReplicationGroupNotFoundFault","matcher":"error","state":"success"}],"delay":15,"description":"Wait until ElastiCache replication group is deleted.","maxAttempts":40,"operation":"DescribeReplicationGroups"}}}; - -/***/ }), +"use strict"; -/***/ 1632: -/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) { -var AWS = __webpack_require__(395); +var core = __nccwpck_require__(402); +var utilEndpoints = __nccwpck_require__(3068); +var protocolHttp = __nccwpck_require__(2356); +var core$1 = __nccwpck_require__(8704); -/** - * @api private - */ -var service = null; - -/** - * @api private - */ -var api = { - signatureVersion: 'v4', - signingName: 'rds-db', - operations: {} -}; - -/** - * @api private - */ -var requiredAuthTokenOptions = { - region: 'string', - hostname: 'string', - port: 'number', - username: 'string' -}; - -/** - * A signer object can be used to generate an auth token to a database. - */ -AWS.RDS.Signer = AWS.util.inherit({ - /** - * Creates a signer object can be used to generate an auth token. - * - * @option options credentials [AWS.Credentials] the AWS credentials - * to sign requests with. Uses the default credential provider chain - * if not specified. - * @option options hostname [String] the hostname of the database to connect to. - * @option options port [Number] the port number the database is listening on. - * @option options region [String] the region the database is located in. - * @option options username [String] the username to login as. - * @example Passing in options to constructor - * var signer = new AWS.RDS.Signer({ - * credentials: new AWS.SharedIniFileCredentials({profile: 'default'}), - * region: 'us-east-1', - * hostname: 'db.us-east-1.rds.amazonaws.com', - * port: 8000, - * username: 'name' - * }); - */ - constructor: function Signer(options) { - this.options = options || {}; - }, +const DEFAULT_UA_APP_ID = undefined; +function isValidUserAgentAppId(appId) { + if (appId === undefined) { + return true; + } + return typeof appId === "string" && appId.length <= 50; +} +function resolveUserAgentConfig(input) { + const normalizedAppIdProvider = core.normalizeProvider(input.userAgentAppId ?? DEFAULT_UA_APP_ID); + const { customUserAgent } = input; + return Object.assign(input, { + customUserAgent: typeof customUserAgent === "string" ? [[customUserAgent]] : customUserAgent, + userAgentAppId: async () => { + const appId = await normalizedAppIdProvider(); + if (!isValidUserAgentAppId(appId)) { + const logger = input.logger?.constructor?.name === "NoOpLogger" || !input.logger ? console : input.logger; + if (typeof appId !== "string") { + logger?.warn("userAgentAppId must be a string or undefined."); + } + else if (appId.length > 50) { + logger?.warn("The provided userAgentAppId exceeds the maximum length of 50 characters."); + } + } + return appId; + }, + }); +} - /** - * @api private - * Strips the protocol from a url. - */ - convertUrlToAuthToken: function convertUrlToAuthToken(url) { - // we are always using https as the protocol - var protocol = 'https://'; - if (url.indexOf(protocol) === 0) { - return url.substring(protocol.length); +const ACCOUNT_ID_ENDPOINT_REGEX = /\d{12}\.ddb/; +async function checkFeatures(context, config, args) { + const request = args.request; + if (request?.headers?.["smithy-protocol"] === "rpc-v2-cbor") { + core$1.setFeature(context, "PROTOCOL_RPC_V2_CBOR", "M"); + } + if (typeof config.retryStrategy === "function") { + const retryStrategy = await config.retryStrategy(); + if (typeof retryStrategy.acquireInitialRetryToken === "function") { + if (retryStrategy.constructor?.name?.includes("Adaptive")) { + core$1.setFeature(context, "RETRY_MODE_ADAPTIVE", "F"); + } + else { + core$1.setFeature(context, "RETRY_MODE_STANDARD", "E"); + } } - }, - - /** - * @overload getAuthToken(options = {}, [callback]) - * Generate an auth token to a database. - * @note You must ensure that you have static or previously resolved - * credentials if you call this method synchronously (with no callback), - * otherwise it may not properly sign the request. If you cannot guarantee - * this (you are using an asynchronous credential provider, i.e., EC2 - * IAM roles), you should always call this method with an asynchronous - * callback. - * - * @param options [map] The fields to use when generating an auth token. - * Any options specified here will be merged on top of any options passed - * to AWS.RDS.Signer: - * - * * **credentials** (AWS.Credentials) — the AWS credentials - * to sign requests with. Uses the default credential provider chain - * if not specified. - * * **hostname** (String) — the hostname of the database to connect to. - * * **port** (Number) — the port number the database is listening on. - * * **region** (String) — the region the database is located in. - * * **username** (String) — the username to login as. - * @return [String] if called synchronously (with no callback), returns the - * auth token. - * @return [null] nothing is returned if a callback is provided. - * @callback callback function (err, token) - * If a callback is supplied, it is called when an auth token has been generated. - * @param err [Error] the error object returned from the signer. - * @param token [String] the auth token. - * - * @example Generating an auth token synchronously - * var signer = new AWS.RDS.Signer({ - * // configure options - * region: 'us-east-1', - * username: 'default', - * hostname: 'db.us-east-1.amazonaws.com', - * port: 8000 - * }); - * var token = signer.getAuthToken({ - * // these options are merged with those defined when creating the signer, overriding in the case of a duplicate option - * // credentials are not specified here or when creating the signer, so default credential provider will be used - * username: 'test' // overriding username - * }); - * @example Generating an auth token asynchronously - * var signer = new AWS.RDS.Signer({ - * // configure options - * region: 'us-east-1', - * username: 'default', - * hostname: 'db.us-east-1.amazonaws.com', - * port: 8000 - * }); - * signer.getAuthToken({ - * // these options are merged with those defined when creating the signer, overriding in the case of a duplicate option - * // credentials are not specified here or when creating the signer, so default credential provider will be used - * username: 'test' // overriding username - * }, function(err, token) { - * if (err) { - * // handle error - * } else { - * // use token - * } - * }); - * - */ - getAuthToken: function getAuthToken(options, callback) { - if (typeof options === 'function' && callback === undefined) { - callback = options; - options = {}; - } - var self = this; - var hasCallback = typeof callback === 'function'; - // merge options with existing options - options = AWS.util.merge(this.options, options); - // validate options - var optionsValidation = this.validateAuthTokenOptions(options); - if (optionsValidation !== true) { - if (hasCallback) { - return callback(optionsValidation, null); - } - throw optionsValidation; - } - - // 15 minutes - var expires = 900; - // create service to generate a request from - var serviceOptions = { - region: options.region, - endpoint: new AWS.Endpoint(options.hostname + ':' + options.port), - paramValidation: false, - signatureVersion: 'v4' - }; - if (options.credentials) { - serviceOptions.credentials = options.credentials; + else { + core$1.setFeature(context, "RETRY_MODE_LEGACY", "D"); } - service = new AWS.Service(serviceOptions); - // ensure the SDK is using sigv4 signing (config is not enough) - service.api = api; - - var request = service.makeRequest(); - // add listeners to request to properly build auth token - this.modifyRequestForAuthToken(request, options); - - if (hasCallback) { - request.presign(expires, function(err, url) { - if (url) { - url = self.convertUrlToAuthToken(url); - } - callback(err, url); - }); - } else { - var url = request.presign(expires); - return this.convertUrlToAuthToken(url); + } + if (typeof config.accountIdEndpointMode === "function") { + const endpointV2 = context.endpointV2; + if (String(endpointV2?.url?.hostname).match(ACCOUNT_ID_ENDPOINT_REGEX)) { + core$1.setFeature(context, "ACCOUNT_ID_ENDPOINT", "O"); } - }, - - /** - * @api private - * Modifies a request to allow the presigner to generate an auth token. - */ - modifyRequestForAuthToken: function modifyRequestForAuthToken(request, options) { - request.on('build', request.buildAsGet); - var httpRequest = request.httpRequest; - httpRequest.body = AWS.util.queryParamsToString({ - Action: 'connect', - DBUser: options.username - }); - }, + switch (await config.accountIdEndpointMode?.()) { + case "disabled": + core$1.setFeature(context, "ACCOUNT_ID_MODE_DISABLED", "Q"); + break; + case "preferred": + core$1.setFeature(context, "ACCOUNT_ID_MODE_PREFERRED", "P"); + break; + case "required": + core$1.setFeature(context, "ACCOUNT_ID_MODE_REQUIRED", "R"); + break; + } + } + const identity = context.__smithy_context?.selectedHttpAuthScheme?.identity; + if (identity?.$source) { + const credentials = identity; + if (credentials.accountId) { + core$1.setFeature(context, "RESOLVED_ACCOUNT_ID", "T"); + } + for (const [key, value] of Object.entries(credentials.$source ?? {})) { + core$1.setFeature(context, key, value); + } + } +} - /** - * @api private - * Validates that the options passed in contain all the keys with values of the correct type that - * are needed to generate an auth token. - */ - validateAuthTokenOptions: function validateAuthTokenOptions(options) { - // iterate over all keys in options - var message = ''; - options = options || {}; - for (var key in requiredAuthTokenOptions) { - if (!Object.prototype.hasOwnProperty.call(requiredAuthTokenOptions, key)) { - continue; +const USER_AGENT = "user-agent"; +const X_AMZ_USER_AGENT = "x-amz-user-agent"; +const SPACE = " "; +const UA_NAME_SEPARATOR = "/"; +const UA_NAME_ESCAPE_REGEX = /[^!$%&'*+\-.^_`|~\w]/g; +const UA_VALUE_ESCAPE_REGEX = /[^!$%&'*+\-.^_`|~\w#]/g; +const UA_ESCAPE_CHAR = "-"; + +const BYTE_LIMIT = 1024; +function encodeFeatures(features) { + let buffer = ""; + for (const key in features) { + const val = features[key]; + if (buffer.length + val.length + 1 <= BYTE_LIMIT) { + if (buffer.length) { + buffer += "," + val; } - if (typeof options[key] !== requiredAuthTokenOptions[key]) { - message += 'option \'' + key + '\' should have been type \'' + requiredAuthTokenOptions[key] + '\', was \'' + typeof options[key] + '\'.\n'; + else { + buffer += val; } + continue; } - if (message.length) { - return AWS.util.error(new Error(), { - code: 'InvalidParameter', - message: message - }); + break; + } + return buffer; +} + +const userAgentMiddleware = (options) => (next, context) => async (args) => { + const { request } = args; + if (!protocolHttp.HttpRequest.isInstance(request)) { + return next(args); + } + const { headers } = request; + const userAgent = context?.userAgent?.map(escapeUserAgent) || []; + const defaultUserAgent = (await options.defaultUserAgentProvider()).map(escapeUserAgent); + await checkFeatures(context, options, args); + const awsContext = context; + defaultUserAgent.push(`m/${encodeFeatures(Object.assign({}, context.__smithy_context?.features, awsContext.__aws_sdk_context?.features))}`); + const customUserAgent = options?.customUserAgent?.map(escapeUserAgent) || []; + const appId = await options.userAgentAppId(); + if (appId) { + defaultUserAgent.push(escapeUserAgent([`app`, `${appId}`])); + } + const prefix = utilEndpoints.getUserAgentPrefix(); + const sdkUserAgentValue = (prefix ? [prefix] : []) + .concat([...defaultUserAgent, ...userAgent, ...customUserAgent]) + .join(SPACE); + const normalUAValue = [ + ...defaultUserAgent.filter((section) => section.startsWith("aws-sdk-")), + ...customUserAgent, + ].join(SPACE); + if (options.runtime !== "browser") { + if (normalUAValue) { + headers[X_AMZ_USER_AGENT] = headers[X_AMZ_USER_AGENT] + ? `${headers[USER_AGENT]} ${normalUAValue}` + : normalUAValue; } - return true; + headers[USER_AGENT] = sdkUserAgentValue; } + else { + headers[X_AMZ_USER_AGENT] = sdkUserAgentValue; + } + return next({ + ...args, + request, + }); +}; +const escapeUserAgent = (userAgentPair) => { + const name = userAgentPair[0] + .split(UA_NAME_SEPARATOR) + .map((part) => part.replace(UA_NAME_ESCAPE_REGEX, UA_ESCAPE_CHAR)) + .join(UA_NAME_SEPARATOR); + const version = userAgentPair[1]?.replace(UA_VALUE_ESCAPE_REGEX, UA_ESCAPE_CHAR); + const prefixSeparatorIndex = name.indexOf(UA_NAME_SEPARATOR); + const prefix = name.substring(0, prefixSeparatorIndex); + let uaName = name.substring(prefixSeparatorIndex + 1); + if (prefix === "api") { + uaName = uaName.toLowerCase(); + } + return [prefix, uaName, version] + .filter((item) => item && item.length > 0) + .reduce((acc, item, index) => { + switch (index) { + case 0: + return item; + case 1: + return `${acc}/${item}`; + default: + return `${acc}#${item}`; + } + }, ""); +}; +const getUserAgentMiddlewareOptions = { + name: "getUserAgentMiddleware", + step: "build", + priority: "low", + tags: ["SET_USER_AGENT", "USER_AGENT"], + override: true, +}; +const getUserAgentPlugin = (config) => ({ + applyToStack: (clientStack) => { + clientStack.add(userAgentMiddleware(config), getUserAgentMiddlewareOptions); + }, }); +exports.DEFAULT_UA_APP_ID = DEFAULT_UA_APP_ID; +exports.getUserAgentMiddlewareOptions = getUserAgentMiddlewareOptions; +exports.getUserAgentPlugin = getUserAgentPlugin; +exports.resolveUserAgentConfig = resolveUserAgentConfig; +exports.userAgentMiddleware = userAgentMiddleware; -/***/ }), - -/***/ 1636: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2019-01-02","endpointPrefix":"qldb","jsonVersion":"1.0","protocol":"rest-json","serviceAbbreviation":"QLDB","serviceFullName":"Amazon QLDB","serviceId":"QLDB","signatureVersion":"v4","signingName":"qldb","uid":"qldb-2019-01-02"},"operations":{"CancelJournalKinesisStream":{"http":{"method":"DELETE","requestUri":"/ledgers/{name}/journal-kinesis-streams/{streamId}"},"input":{"type":"structure","required":["LedgerName","StreamId"],"members":{"LedgerName":{"location":"uri","locationName":"name"},"StreamId":{"location":"uri","locationName":"streamId"}}},"output":{"type":"structure","members":{"StreamId":{}}}},"CreateLedger":{"http":{"requestUri":"/ledgers"},"input":{"type":"structure","required":["Name","PermissionsMode"],"members":{"Name":{},"Tags":{"shape":"S6"},"PermissionsMode":{},"DeletionProtection":{"type":"boolean"}}},"output":{"type":"structure","members":{"Name":{},"Arn":{},"State":{},"CreationDateTime":{"type":"timestamp"},"DeletionProtection":{"type":"boolean"}}}},"DeleteLedger":{"http":{"method":"DELETE","requestUri":"/ledgers/{name}"},"input":{"type":"structure","required":["Name"],"members":{"Name":{"location":"uri","locationName":"name"}}}},"DescribeJournalKinesisStream":{"http":{"method":"GET","requestUri":"/ledgers/{name}/journal-kinesis-streams/{streamId}"},"input":{"type":"structure","required":["LedgerName","StreamId"],"members":{"LedgerName":{"location":"uri","locationName":"name"},"StreamId":{"location":"uri","locationName":"streamId"}}},"output":{"type":"structure","members":{"Stream":{"shape":"Si"}}}},"DescribeJournalS3Export":{"http":{"method":"GET","requestUri":"/ledgers/{name}/journal-s3-exports/{exportId}"},"input":{"type":"structure","required":["Name","ExportId"],"members":{"Name":{"location":"uri","locationName":"name"},"ExportId":{"location":"uri","locationName":"exportId"}}},"output":{"type":"structure","required":["ExportDescription"],"members":{"ExportDescription":{"shape":"Sq"}}}},"DescribeLedger":{"http":{"method":"GET","requestUri":"/ledgers/{name}"},"input":{"type":"structure","required":["Name"],"members":{"Name":{"location":"uri","locationName":"name"}}},"output":{"type":"structure","members":{"Name":{},"Arn":{},"State":{},"CreationDateTime":{"type":"timestamp"},"DeletionProtection":{"type":"boolean"}}}},"ExportJournalToS3":{"http":{"requestUri":"/ledgers/{name}/journal-s3-exports"},"input":{"type":"structure","required":["Name","InclusiveStartTime","ExclusiveEndTime","S3ExportConfiguration","RoleArn"],"members":{"Name":{"location":"uri","locationName":"name"},"InclusiveStartTime":{"type":"timestamp"},"ExclusiveEndTime":{"type":"timestamp"},"S3ExportConfiguration":{"shape":"Ss"},"RoleArn":{}}},"output":{"type":"structure","required":["ExportId"],"members":{"ExportId":{}}}},"GetBlock":{"http":{"requestUri":"/ledgers/{name}/block"},"input":{"type":"structure","required":["Name","BlockAddress"],"members":{"Name":{"location":"uri","locationName":"name"},"BlockAddress":{"shape":"S12"},"DigestTipAddress":{"shape":"S12"}}},"output":{"type":"structure","required":["Block"],"members":{"Block":{"shape":"S12"},"Proof":{"shape":"S12"}}}},"GetDigest":{"http":{"requestUri":"/ledgers/{name}/digest"},"input":{"type":"structure","required":["Name"],"members":{"Name":{"location":"uri","locationName":"name"}}},"output":{"type":"structure","required":["Digest","DigestTipAddress"],"members":{"Digest":{"type":"blob"},"DigestTipAddress":{"shape":"S12"}}}},"GetRevision":{"http":{"requestUri":"/ledgers/{name}/revision"},"input":{"type":"structure","required":["Name","BlockAddress","DocumentId"],"members":{"Name":{"location":"uri","locationName":"name"},"BlockAddress":{"shape":"S12"},"DocumentId":{},"DigestTipAddress":{"shape":"S12"}}},"output":{"type":"structure","required":["Revision"],"members":{"Proof":{"shape":"S12"},"Revision":{"shape":"S12"}}}},"ListJournalKinesisStreamsForLedger":{"http":{"method":"GET","requestUri":"/ledgers/{name}/journal-kinesis-streams"},"input":{"type":"structure","required":["LedgerName"],"members":{"LedgerName":{"location":"uri","locationName":"name"},"MaxResults":{"location":"querystring","locationName":"max_results","type":"integer"},"NextToken":{"location":"querystring","locationName":"next_token"}}},"output":{"type":"structure","members":{"Streams":{"type":"list","member":{"shape":"Si"}},"NextToken":{}}}},"ListJournalS3Exports":{"http":{"method":"GET","requestUri":"/journal-s3-exports"},"input":{"type":"structure","members":{"MaxResults":{"location":"querystring","locationName":"max_results","type":"integer"},"NextToken":{"location":"querystring","locationName":"next_token"}}},"output":{"type":"structure","members":{"JournalS3Exports":{"shape":"S1h"},"NextToken":{}}}},"ListJournalS3ExportsForLedger":{"http":{"method":"GET","requestUri":"/ledgers/{name}/journal-s3-exports"},"input":{"type":"structure","required":["Name"],"members":{"Name":{"location":"uri","locationName":"name"},"MaxResults":{"location":"querystring","locationName":"max_results","type":"integer"},"NextToken":{"location":"querystring","locationName":"next_token"}}},"output":{"type":"structure","members":{"JournalS3Exports":{"shape":"S1h"},"NextToken":{}}}},"ListLedgers":{"http":{"method":"GET","requestUri":"/ledgers"},"input":{"type":"structure","members":{"MaxResults":{"location":"querystring","locationName":"max_results","type":"integer"},"NextToken":{"location":"querystring","locationName":"next_token"}}},"output":{"type":"structure","members":{"Ledgers":{"type":"list","member":{"type":"structure","members":{"Name":{},"State":{},"CreationDateTime":{"type":"timestamp"}}}},"NextToken":{}}}},"ListTagsForResource":{"http":{"method":"GET","requestUri":"/tags/{resourceArn}"},"input":{"type":"structure","required":["ResourceArn"],"members":{"ResourceArn":{"location":"uri","locationName":"resourceArn"}}},"output":{"type":"structure","members":{"Tags":{"shape":"S6"}}}},"StreamJournalToKinesis":{"http":{"requestUri":"/ledgers/{name}/journal-kinesis-streams"},"input":{"type":"structure","required":["LedgerName","RoleArn","InclusiveStartTime","KinesisConfiguration","StreamName"],"members":{"LedgerName":{"location":"uri","locationName":"name"},"RoleArn":{},"Tags":{"shape":"S6"},"InclusiveStartTime":{"type":"timestamp"},"ExclusiveEndTime":{"type":"timestamp"},"KinesisConfiguration":{"shape":"Sk"},"StreamName":{}}},"output":{"type":"structure","members":{"StreamId":{}}}},"TagResource":{"http":{"requestUri":"/tags/{resourceArn}"},"input":{"type":"structure","required":["ResourceArn","Tags"],"members":{"ResourceArn":{"location":"uri","locationName":"resourceArn"},"Tags":{"shape":"S6"}}},"output":{"type":"structure","members":{}}},"UntagResource":{"http":{"method":"DELETE","requestUri":"/tags/{resourceArn}"},"input":{"type":"structure","required":["ResourceArn","TagKeys"],"members":{"ResourceArn":{"location":"uri","locationName":"resourceArn"},"TagKeys":{"location":"querystring","locationName":"tagKeys","type":"list","member":{}}}},"output":{"type":"structure","members":{}}},"UpdateLedger":{"http":{"method":"PATCH","requestUri":"/ledgers/{name}"},"input":{"type":"structure","required":["Name"],"members":{"Name":{"location":"uri","locationName":"name"},"DeletionProtection":{"type":"boolean"}}},"output":{"type":"structure","members":{"Name":{},"Arn":{},"State":{},"CreationDateTime":{"type":"timestamp"},"DeletionProtection":{"type":"boolean"}}}}},"shapes":{"S6":{"type":"map","key":{},"value":{}},"Si":{"type":"structure","required":["LedgerName","RoleArn","StreamId","Status","KinesisConfiguration","StreamName"],"members":{"LedgerName":{},"CreationTime":{"type":"timestamp"},"InclusiveStartTime":{"type":"timestamp"},"ExclusiveEndTime":{"type":"timestamp"},"RoleArn":{},"StreamId":{},"Arn":{},"Status":{},"KinesisConfiguration":{"shape":"Sk"},"ErrorCause":{},"StreamName":{}}},"Sk":{"type":"structure","required":["StreamArn"],"members":{"StreamArn":{},"AggregationEnabled":{"type":"boolean"}}},"Sq":{"type":"structure","required":["LedgerName","ExportId","ExportCreationTime","Status","InclusiveStartTime","ExclusiveEndTime","S3ExportConfiguration","RoleArn"],"members":{"LedgerName":{},"ExportId":{},"ExportCreationTime":{"type":"timestamp"},"Status":{},"InclusiveStartTime":{"type":"timestamp"},"ExclusiveEndTime":{"type":"timestamp"},"S3ExportConfiguration":{"shape":"Ss"},"RoleArn":{}}},"Ss":{"type":"structure","required":["Bucket","Prefix","EncryptionConfiguration"],"members":{"Bucket":{},"Prefix":{},"EncryptionConfiguration":{"type":"structure","required":["ObjectEncryptionType"],"members":{"ObjectEncryptionType":{},"KmsKeyArn":{}}}}},"S12":{"type":"structure","members":{"IonText":{"type":"string","sensitive":true}},"sensitive":true},"S1h":{"type":"list","member":{"shape":"Sq"}}}}; /***/ }), -/***/ 1647: -/***/ (function(module, __unusedexports, __webpack_require__) { +/***/ 6463: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -var AWS = __webpack_require__(395), - url = AWS.util.url, - crypto = AWS.util.crypto.lib, - base64Encode = AWS.util.base64.encode, - inherit = AWS.util.inherit; - -var queryEncode = function (string) { - var replacements = { - '+': '-', - '=': '_', - '/': '~' - }; - return string.replace(/[\+=\/]/g, function (match) { - return replacements[match]; - }); -}; +"use strict"; -var signPolicy = function (policy, privateKey) { - var sign = crypto.createSign('RSA-SHA1'); - sign.write(policy); - return queryEncode(sign.sign(privateKey, 'base64')); -}; -var signWithCannedPolicy = function (url, expires, keyPairId, privateKey) { - var policy = JSON.stringify({ - Statement: [ - { - Resource: url, - Condition: { DateLessThan: { 'AWS:EpochTime': expires } } - } - ] - }); +var configResolver = __nccwpck_require__(9316); +var stsRegionDefaultResolver = __nccwpck_require__(5779); +const getAwsRegionExtensionConfiguration = (runtimeConfig) => { return { - Expires: expires, - 'Key-Pair-Id': keyPairId, - Signature: signPolicy(policy.toString(), privateKey) + setRegion(region) { + runtimeConfig.region = region; + }, + region() { + return runtimeConfig.region; + }, }; }; - -var signWithCustomPolicy = function (policy, keyPairId, privateKey) { - policy = policy.replace(/\s/mg, ''); - +const resolveAwsRegionExtensionConfiguration = (awsRegionExtensionConfiguration) => { return { - Policy: queryEncode(base64Encode(policy)), - 'Key-Pair-Id': keyPairId, - Signature: signPolicy(policy, privateKey) + region: awsRegionExtensionConfiguration.region(), }; }; -var determineScheme = function (url) { - var parts = url.split('://'); - if (parts.length < 2) { - throw new Error('Invalid URL.'); - } +Object.defineProperty(exports, "NODE_REGION_CONFIG_FILE_OPTIONS", ({ + enumerable: true, + get: function () { return configResolver.NODE_REGION_CONFIG_FILE_OPTIONS; } +})); +Object.defineProperty(exports, "NODE_REGION_CONFIG_OPTIONS", ({ + enumerable: true, + get: function () { return configResolver.NODE_REGION_CONFIG_OPTIONS; } +})); +Object.defineProperty(exports, "REGION_ENV_NAME", ({ + enumerable: true, + get: function () { return configResolver.REGION_ENV_NAME; } +})); +Object.defineProperty(exports, "REGION_INI_NAME", ({ + enumerable: true, + get: function () { return configResolver.REGION_INI_NAME; } +})); +Object.defineProperty(exports, "resolveRegionConfig", ({ + enumerable: true, + get: function () { return configResolver.resolveRegionConfig; } +})); +exports.getAwsRegionExtensionConfiguration = getAwsRegionExtensionConfiguration; +exports.resolveAwsRegionExtensionConfiguration = resolveAwsRegionExtensionConfiguration; +Object.keys(stsRegionDefaultResolver).forEach(function (k) { + if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, { + enumerable: true, + get: function () { return stsRegionDefaultResolver[k]; } + }); +}); - return parts[0].replace('*', ''); -}; -var getRtmpUrl = function (rtmpUrl) { - var parsed = url.parse(rtmpUrl); - return parsed.path.replace(/^\//, '') + (parsed.hash || ''); -}; +/***/ }), -var getResource = function (url) { - switch (determineScheme(url)) { - case 'http': - case 'https': - return url; - case 'rtmp': - return getRtmpUrl(url); - default: - throw new Error('Invalid URI scheme. Scheme must be one of' - + ' http, https, or rtmp'); - } -}; +/***/ 5779: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -var handleError = function (err, callback) { - if (!callback || typeof callback !== 'function') { - throw err; - } +"use strict"; - callback(err); +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.warning = void 0; +exports.stsRegionDefaultResolver = stsRegionDefaultResolver; +const config_resolver_1 = __nccwpck_require__(9316); +const node_config_provider_1 = __nccwpck_require__(5704); +function stsRegionDefaultResolver(loaderConfig = {}) { + return (0, node_config_provider_1.loadConfig)({ + ...config_resolver_1.NODE_REGION_CONFIG_OPTIONS, + async default() { + if (!exports.warning.silence) { + console.warn("@aws-sdk - WARN - default STS region of us-east-1 used. See @aws-sdk/credential-providers README and set a region explicitly."); + } + return "us-east-1"; + }, + }, { ...config_resolver_1.NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }); +} +exports.warning = { + silence: false, }; -var handleSuccess = function (result, callback) { - if (!callback || typeof callback !== 'function') { - return result; - } - callback(null, result); -}; +/***/ }), -AWS.CloudFront.Signer = inherit({ - /** - * A signer object can be used to generate signed URLs and cookies for granting - * access to content on restricted CloudFront distributions. - * - * @see http://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/PrivateContent.html - * - * @param keyPairId [String] (Required) The ID of the CloudFront key pair - * being used. - * @param privateKey [String] (Required) A private key in RSA format. - */ - constructor: function Signer(keyPairId, privateKey) { - if (keyPairId === void 0 || privateKey === void 0) { - throw new Error('A key pair ID and private key are required'); - } +/***/ 3068: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - this.keyPairId = keyPairId; - this.privateKey = privateKey; - }, +"use strict"; - /** - * Create a signed Amazon CloudFront Cookie. - * - * @param options [Object] The options to create a signed cookie. - * @option options url [String] The URL to which the signature will grant - * access. Required unless you pass in a full - * policy. - * @option options expires [Number] A Unix UTC timestamp indicating when the - * signature should expire. Required unless you - * pass in a full policy. - * @option options policy [String] A CloudFront JSON policy. Required unless - * you pass in a url and an expiry time. - * - * @param cb [Function] if a callback is provided, this function will - * pass the hash as the second parameter (after the error parameter) to - * the callback function. - * - * @return [Object] if called synchronously (with no callback), returns the - * signed cookie parameters. - * @return [null] nothing is returned if a callback is provided. - */ - getSignedCookie: function (options, cb) { - var signatureHash = 'policy' in options - ? signWithCustomPolicy(options.policy, this.keyPairId, this.privateKey) - : signWithCannedPolicy(options.url, options.expires, this.keyPairId, this.privateKey); - var cookieHash = {}; - for (var key in signatureHash) { - if (Object.prototype.hasOwnProperty.call(signatureHash, key)) { - cookieHash['CloudFront-' + key] = signatureHash[key]; +var utilEndpoints = __nccwpck_require__(9674); +var urlParser = __nccwpck_require__(4494); + +const isVirtualHostableS3Bucket = (value, allowSubDomains = false) => { + if (allowSubDomains) { + for (const label of value.split(".")) { + if (!isVirtualHostableS3Bucket(label)) { + return false; } } + return true; + } + if (!utilEndpoints.isValidHostLabel(value)) { + return false; + } + if (value.length < 3 || value.length > 63) { + return false; + } + if (value !== value.toLowerCase()) { + return false; + } + if (utilEndpoints.isIpAddress(value)) { + return false; + } + return true; +}; - return handleSuccess(cookieHash, cb); - }, - - /** - * Create a signed Amazon CloudFront URL. - * - * Keep in mind that URLs meant for use in media/flash players may have - * different requirements for URL formats (e.g. some require that the - * extension be removed, some require the file name to be prefixed - * - mp4:, some require you to add "/cfx/st" into your URL). - * - * @param options [Object] The options to create a signed URL. - * @option options url [String] The URL to which the signature will grant - * access. Any query params included with - * the URL should be encoded. Required. - * @option options expires [Number] A Unix UTC timestamp indicating when the - * signature should expire. Required unless you - * pass in a full policy. - * @option options policy [String] A CloudFront JSON policy. Required unless - * you pass in a url and an expiry time. - * - * @param cb [Function] if a callback is provided, this function will - * pass the URL as the second parameter (after the error parameter) to - * the callback function. - * - * @return [String] if called synchronously (with no callback), returns the - * signed URL. - * @return [null] nothing is returned if a callback is provided. - */ - getSignedUrl: function (options, cb) { - try { - var resource = getResource(options.url); - } catch (err) { - return handleError(err, cb); - } +const ARN_DELIMITER = ":"; +const RESOURCE_DELIMITER = "/"; +const parseArn = (value) => { + const segments = value.split(ARN_DELIMITER); + if (segments.length < 6) + return null; + const [arn, partition, service, region, accountId, ...resourcePath] = segments; + if (arn !== "arn" || partition === "" || service === "" || resourcePath.join(ARN_DELIMITER) === "") + return null; + const resourceId = resourcePath.map((resource) => resource.split(RESOURCE_DELIMITER)).flat(); + return { + partition, + service, + region, + accountId, + resourceId, + }; +}; - var parsedUrl = url.parse(options.url, true), - signatureHash = Object.prototype.hasOwnProperty.call(options, 'policy') - ? signWithCustomPolicy(options.policy, this.keyPairId, this.privateKey) - : signWithCannedPolicy(resource, options.expires, this.keyPairId, this.privateKey); +var partitions = [ + { + id: "aws", + outputs: { + dnsSuffix: "amazonaws.com", + dualStackDnsSuffix: "api.aws", + implicitGlobalRegion: "us-east-1", + name: "aws", + supportsDualStack: true, + supportsFIPS: true + }, + regionRegex: "^(us|eu|ap|sa|ca|me|af|il|mx)\\-\\w+\\-\\d+$", + regions: { + "af-south-1": { + description: "Africa (Cape Town)" + }, + "ap-east-1": { + description: "Asia Pacific (Hong Kong)" + }, + "ap-east-2": { + description: "Asia Pacific (Taipei)" + }, + "ap-northeast-1": { + description: "Asia Pacific (Tokyo)" + }, + "ap-northeast-2": { + description: "Asia Pacific (Seoul)" + }, + "ap-northeast-3": { + description: "Asia Pacific (Osaka)" + }, + "ap-south-1": { + description: "Asia Pacific (Mumbai)" + }, + "ap-south-2": { + description: "Asia Pacific (Hyderabad)" + }, + "ap-southeast-1": { + description: "Asia Pacific (Singapore)" + }, + "ap-southeast-2": { + description: "Asia Pacific (Sydney)" + }, + "ap-southeast-3": { + description: "Asia Pacific (Jakarta)" + }, + "ap-southeast-4": { + description: "Asia Pacific (Melbourne)" + }, + "ap-southeast-5": { + description: "Asia Pacific (Malaysia)" + }, + "ap-southeast-6": { + description: "Asia Pacific (New Zealand)" + }, + "ap-southeast-7": { + description: "Asia Pacific (Thailand)" + }, + "aws-global": { + description: "aws global region" + }, + "ca-central-1": { + description: "Canada (Central)" + }, + "ca-west-1": { + description: "Canada West (Calgary)" + }, + "eu-central-1": { + description: "Europe (Frankfurt)" + }, + "eu-central-2": { + description: "Europe (Zurich)" + }, + "eu-north-1": { + description: "Europe (Stockholm)" + }, + "eu-south-1": { + description: "Europe (Milan)" + }, + "eu-south-2": { + description: "Europe (Spain)" + }, + "eu-west-1": { + description: "Europe (Ireland)" + }, + "eu-west-2": { + description: "Europe (London)" + }, + "eu-west-3": { + description: "Europe (Paris)" + }, + "il-central-1": { + description: "Israel (Tel Aviv)" + }, + "me-central-1": { + description: "Middle East (UAE)" + }, + "me-south-1": { + description: "Middle East (Bahrain)" + }, + "mx-central-1": { + description: "Mexico (Central)" + }, + "sa-east-1": { + description: "South America (Sao Paulo)" + }, + "us-east-1": { + description: "US East (N. Virginia)" + }, + "us-east-2": { + description: "US East (Ohio)" + }, + "us-west-1": { + description: "US West (N. California)" + }, + "us-west-2": { + description: "US West (Oregon)" + } + } + }, + { + id: "aws-cn", + outputs: { + dnsSuffix: "amazonaws.com.cn", + dualStackDnsSuffix: "api.amazonwebservices.com.cn", + implicitGlobalRegion: "cn-northwest-1", + name: "aws-cn", + supportsDualStack: true, + supportsFIPS: true + }, + regionRegex: "^cn\\-\\w+\\-\\d+$", + regions: { + "aws-cn-global": { + description: "aws-cn global region" + }, + "cn-north-1": { + description: "China (Beijing)" + }, + "cn-northwest-1": { + description: "China (Ningxia)" + } + } + }, + { + id: "aws-eusc", + outputs: { + dnsSuffix: "amazonaws.eu", + dualStackDnsSuffix: "api.amazonwebservices.eu", + implicitGlobalRegion: "eusc-de-east-1", + name: "aws-eusc", + supportsDualStack: true, + supportsFIPS: true + }, + regionRegex: "^eusc\\-(de)\\-\\w+\\-\\d+$", + regions: { + "eusc-de-east-1": { + description: "EU (Germany)" + } + } + }, + { + id: "aws-iso", + outputs: { + dnsSuffix: "c2s.ic.gov", + dualStackDnsSuffix: "api.aws.ic.gov", + implicitGlobalRegion: "us-iso-east-1", + name: "aws-iso", + supportsDualStack: true, + supportsFIPS: true + }, + regionRegex: "^us\\-iso\\-\\w+\\-\\d+$", + regions: { + "aws-iso-global": { + description: "aws-iso global region" + }, + "us-iso-east-1": { + description: "US ISO East" + }, + "us-iso-west-1": { + description: "US ISO WEST" + } + } + }, + { + id: "aws-iso-b", + outputs: { + dnsSuffix: "sc2s.sgov.gov", + dualStackDnsSuffix: "api.aws.scloud", + implicitGlobalRegion: "us-isob-east-1", + name: "aws-iso-b", + supportsDualStack: true, + supportsFIPS: true + }, + regionRegex: "^us\\-isob\\-\\w+\\-\\d+$", + regions: { + "aws-iso-b-global": { + description: "aws-iso-b global region" + }, + "us-isob-east-1": { + description: "US ISOB East (Ohio)" + }, + "us-isob-west-1": { + description: "US ISOB West" + } + } + }, + { + id: "aws-iso-e", + outputs: { + dnsSuffix: "cloud.adc-e.uk", + dualStackDnsSuffix: "api.cloud-aws.adc-e.uk", + implicitGlobalRegion: "eu-isoe-west-1", + name: "aws-iso-e", + supportsDualStack: true, + supportsFIPS: true + }, + regionRegex: "^eu\\-isoe\\-\\w+\\-\\d+$", + regions: { + "aws-iso-e-global": { + description: "aws-iso-e global region" + }, + "eu-isoe-west-1": { + description: "EU ISOE West" + } + } + }, + { + id: "aws-iso-f", + outputs: { + dnsSuffix: "csp.hci.ic.gov", + dualStackDnsSuffix: "api.aws.hci.ic.gov", + implicitGlobalRegion: "us-isof-south-1", + name: "aws-iso-f", + supportsDualStack: true, + supportsFIPS: true + }, + regionRegex: "^us\\-isof\\-\\w+\\-\\d+$", + regions: { + "aws-iso-f-global": { + description: "aws-iso-f global region" + }, + "us-isof-east-1": { + description: "US ISOF EAST" + }, + "us-isof-south-1": { + description: "US ISOF SOUTH" + } + } + }, + { + id: "aws-us-gov", + outputs: { + dnsSuffix: "amazonaws.com", + dualStackDnsSuffix: "api.aws", + implicitGlobalRegion: "us-gov-west-1", + name: "aws-us-gov", + supportsDualStack: true, + supportsFIPS: true + }, + regionRegex: "^us\\-gov\\-\\w+\\-\\d+$", + regions: { + "aws-us-gov-global": { + description: "aws-us-gov global region" + }, + "us-gov-east-1": { + description: "AWS GovCloud (US-East)" + }, + "us-gov-west-1": { + description: "AWS GovCloud (US-West)" + } + } + } +]; +var version = "1.1"; +var partitionsInfo = { + partitions: partitions, + version: version +}; - parsedUrl.search = null; - for (var key in signatureHash) { - if (Object.prototype.hasOwnProperty.call(signatureHash, key)) { - parsedUrl.query[key] = signatureHash[key]; +let selectedPartitionsInfo = partitionsInfo; +let selectedUserAgentPrefix = ""; +const partition = (value) => { + const { partitions } = selectedPartitionsInfo; + for (const partition of partitions) { + const { regions, outputs } = partition; + for (const [region, regionData] of Object.entries(regions)) { + if (region === value) { + return { + ...outputs, + ...regionData, + }; } } - - try { - var signedUrl = determineScheme(options.url) === 'rtmp' - ? getRtmpUrl(url.format(parsedUrl)) - : url.format(parsedUrl); - } catch (err) { - return handleError(err, cb); + } + for (const partition of partitions) { + const { regionRegex, outputs } = partition; + if (new RegExp(regionRegex).test(value)) { + return { + ...outputs, + }; } + } + const DEFAULT_PARTITION = partitions.find((partition) => partition.id === "aws"); + if (!DEFAULT_PARTITION) { + throw new Error("Provided region was not found in the partition array or regex," + + " and default partition with id 'aws' doesn't exist."); + } + return { + ...DEFAULT_PARTITION.outputs, + }; +}; +const setPartitionInfo = (partitionsInfo, userAgentPrefix = "") => { + selectedPartitionsInfo = partitionsInfo; + selectedUserAgentPrefix = userAgentPrefix; +}; +const useDefaultPartitionInfo = () => { + setPartitionInfo(partitionsInfo, ""); +}; +const getUserAgentPrefix = () => selectedUserAgentPrefix; - return handleSuccess(signedUrl, cb); +const awsEndpointFunctions = { + isVirtualHostableS3Bucket: isVirtualHostableS3Bucket, + parseArn: parseArn, + partition: partition, +}; +utilEndpoints.customEndpointFunctions.aws = awsEndpointFunctions; + +const resolveDefaultAwsRegionalEndpointsConfig = (input) => { + if (typeof input.endpointProvider !== "function") { + throw new Error("@aws-sdk/util-endpoint - endpointProvider and endpoint missing in config for this client."); + } + const { endpoint } = input; + if (endpoint === undefined) { + input.endpoint = async () => { + return toEndpointV1(input.endpointProvider({ + Region: typeof input.region === "function" ? await input.region() : input.region, + UseDualStack: typeof input.useDualstackEndpoint === "function" + ? await input.useDualstackEndpoint() + : input.useDualstackEndpoint, + UseFIPS: typeof input.useFipsEndpoint === "function" ? await input.useFipsEndpoint() : input.useFipsEndpoint, + Endpoint: undefined, + }, { logger: input.logger })); + }; } -}); + return input; +}; +const toEndpointV1 = (endpoint) => urlParser.parseUrl(endpoint.url); -/** - * @api private - */ -module.exports = AWS.CloudFront.Signer; +Object.defineProperty(exports, "EndpointError", ({ + enumerable: true, + get: function () { return utilEndpoints.EndpointError; } +})); +Object.defineProperty(exports, "isIpAddress", ({ + enumerable: true, + get: function () { return utilEndpoints.isIpAddress; } +})); +Object.defineProperty(exports, "resolveEndpoint", ({ + enumerable: true, + get: function () { return utilEndpoints.resolveEndpoint; } +})); +exports.awsEndpointFunctions = awsEndpointFunctions; +exports.getUserAgentPrefix = getUserAgentPrefix; +exports.partition = partition; +exports.resolveDefaultAwsRegionalEndpointsConfig = resolveDefaultAwsRegionalEndpointsConfig; +exports.setPartitionInfo = setPartitionInfo; +exports.toEndpointV1 = toEndpointV1; +exports.useDefaultPartitionInfo = useDefaultPartitionInfo; /***/ }), /***/ 1656: -/***/ (function(module) { +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -module.exports = {"pagination":{"ListAcceptedPortfolioShares":{"input_token":"PageToken","output_token":"NextPageToken","limit_key":"PageSize"},"ListBudgetsForResource":{"input_token":"PageToken","output_token":"NextPageToken","limit_key":"PageSize"},"ListConstraintsForPortfolio":{"input_token":"PageToken","output_token":"NextPageToken","limit_key":"PageSize"},"ListLaunchPaths":{"input_token":"PageToken","output_token":"NextPageToken","limit_key":"PageSize"},"ListOrganizationPortfolioAccess":{"input_token":"PageToken","output_token":"NextPageToken","limit_key":"PageSize"},"ListPortfolioAccess":{"input_token":"PageToken","output_token":"NextPageToken","limit_key":"PageSize"},"ListPortfolios":{"input_token":"PageToken","output_token":"NextPageToken","limit_key":"PageSize"},"ListPortfoliosForProduct":{"input_token":"PageToken","output_token":"NextPageToken","limit_key":"PageSize"},"ListPrincipalsForPortfolio":{"input_token":"PageToken","output_token":"NextPageToken","limit_key":"PageSize"},"ListProvisioningArtifactsForServiceAction":{"input_token":"PageToken","output_token":"NextPageToken","limit_key":"PageSize"},"ListResourcesForTagOption":{"input_token":"PageToken","output_token":"PageToken","limit_key":"PageSize"},"ListServiceActions":{"input_token":"PageToken","output_token":"NextPageToken","limit_key":"PageSize"},"ListServiceActionsForProvisioningArtifact":{"input_token":"PageToken","output_token":"NextPageToken","limit_key":"PageSize"},"ListTagOptions":{"input_token":"PageToken","output_token":"PageToken","limit_key":"PageSize"},"SearchProducts":{"input_token":"PageToken","output_token":"NextPageToken","limit_key":"PageSize"},"SearchProductsAsAdmin":{"input_token":"PageToken","output_token":"NextPageToken","limit_key":"PageSize"},"SearchProvisionedProducts":{"input_token":"PageToken","output_token":"NextPageToken","limit_key":"PageSize"}}}; +"use strict"; -/***/ }), -/***/ 1657: -/***/ (function(module) { +var os = __nccwpck_require__(857); +var process = __nccwpck_require__(932); +var middlewareUserAgent = __nccwpck_require__(2959); -module.exports = {"pagination":{}}; +const crtAvailability = { + isCrtAvailable: false, +}; -/***/ }), +const isCrtAvailable = () => { + if (crtAvailability.isCrtAvailable) { + return ["md/crt-avail"]; + } + return null; +}; + +const createDefaultUserAgentProvider = ({ serviceId, clientVersion }) => { + return async (config) => { + const sections = [ + ["aws-sdk-js", clientVersion], + ["ua", "2.1"], + [`os/${os.platform()}`, os.release()], + ["lang/js"], + ["md/nodejs", `${process.versions.node}`], + ]; + const crtAvailable = isCrtAvailable(); + if (crtAvailable) { + sections.push(crtAvailable); + } + if (serviceId) { + sections.push([`api/${serviceId}`, clientVersion]); + } + if (process.env.AWS_EXECUTION_ENV) { + sections.push([`exec-env/${process.env.AWS_EXECUTION_ENV}`]); + } + const appId = await config?.userAgentAppId?.(); + const resolvedUserAgent = appId ? [...sections, [`app/${appId}`]] : [...sections]; + return resolvedUserAgent; + }; +}; +const defaultUserAgent = createDefaultUserAgentProvider; + +const UA_APP_ID_ENV_NAME = "AWS_SDK_UA_APP_ID"; +const UA_APP_ID_INI_NAME = "sdk_ua_app_id"; +const UA_APP_ID_INI_NAME_DEPRECATED = "sdk-ua-app-id"; +const NODE_APP_ID_CONFIG_OPTIONS = { + environmentVariableSelector: (env) => env[UA_APP_ID_ENV_NAME], + configFileSelector: (profile) => profile[UA_APP_ID_INI_NAME] ?? profile[UA_APP_ID_INI_NAME_DEPRECATED], + default: middlewareUserAgent.DEFAULT_UA_APP_ID, +}; -/***/ 1659: -/***/ (function(module) { +exports.NODE_APP_ID_CONFIG_OPTIONS = NODE_APP_ID_CONFIG_OPTIONS; +exports.UA_APP_ID_ENV_NAME = UA_APP_ID_ENV_NAME; +exports.UA_APP_ID_INI_NAME = UA_APP_ID_INI_NAME; +exports.createDefaultUserAgentProvider = createDefaultUserAgentProvider; +exports.crtAvailability = crtAvailability; +exports.defaultUserAgent = defaultUserAgent; -module.exports = {"version":"2.0","metadata":{"apiVersion":"2016-11-25","endpointPrefix":"cloudfront","globalEndpoint":"cloudfront.amazonaws.com","protocol":"rest-xml","serviceAbbreviation":"CloudFront","serviceFullName":"Amazon CloudFront","serviceId":"CloudFront","signatureVersion":"v4","uid":"cloudfront-2016-11-25"},"operations":{"CreateCloudFrontOriginAccessIdentity":{"http":{"requestUri":"/2016-11-25/origin-access-identity/cloudfront","responseCode":201},"input":{"type":"structure","required":["CloudFrontOriginAccessIdentityConfig"],"members":{"CloudFrontOriginAccessIdentityConfig":{"shape":"S2","locationName":"CloudFrontOriginAccessIdentityConfig","xmlNamespace":{"uri":"http://cloudfront.amazonaws.com/doc/2016-11-25/"}}},"payload":"CloudFrontOriginAccessIdentityConfig"},"output":{"type":"structure","members":{"CloudFrontOriginAccessIdentity":{"shape":"S5"},"Location":{"location":"header","locationName":"Location"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"CloudFrontOriginAccessIdentity"}},"CreateDistribution":{"http":{"requestUri":"/2016-11-25/distribution","responseCode":201},"input":{"type":"structure","required":["DistributionConfig"],"members":{"DistributionConfig":{"shape":"S7","locationName":"DistributionConfig","xmlNamespace":{"uri":"http://cloudfront.amazonaws.com/doc/2016-11-25/"}}},"payload":"DistributionConfig"},"output":{"type":"structure","members":{"Distribution":{"shape":"S1s"},"Location":{"location":"header","locationName":"Location"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"Distribution"}},"CreateDistributionWithTags":{"http":{"requestUri":"/2016-11-25/distribution?WithTags","responseCode":201},"input":{"type":"structure","required":["DistributionConfigWithTags"],"members":{"DistributionConfigWithTags":{"locationName":"DistributionConfigWithTags","xmlNamespace":{"uri":"http://cloudfront.amazonaws.com/doc/2016-11-25/"},"type":"structure","required":["DistributionConfig","Tags"],"members":{"DistributionConfig":{"shape":"S7"},"Tags":{"shape":"S21"}}}},"payload":"DistributionConfigWithTags"},"output":{"type":"structure","members":{"Distribution":{"shape":"S1s"},"Location":{"location":"header","locationName":"Location"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"Distribution"}},"CreateInvalidation":{"http":{"requestUri":"/2016-11-25/distribution/{DistributionId}/invalidation","responseCode":201},"input":{"type":"structure","required":["DistributionId","InvalidationBatch"],"members":{"DistributionId":{"location":"uri","locationName":"DistributionId"},"InvalidationBatch":{"shape":"S28","locationName":"InvalidationBatch","xmlNamespace":{"uri":"http://cloudfront.amazonaws.com/doc/2016-11-25/"}}},"payload":"InvalidationBatch"},"output":{"type":"structure","members":{"Location":{"location":"header","locationName":"Location"},"Invalidation":{"shape":"S2c"}},"payload":"Invalidation"}},"CreateStreamingDistribution":{"http":{"requestUri":"/2016-11-25/streaming-distribution","responseCode":201},"input":{"type":"structure","required":["StreamingDistributionConfig"],"members":{"StreamingDistributionConfig":{"shape":"S2e","locationName":"StreamingDistributionConfig","xmlNamespace":{"uri":"http://cloudfront.amazonaws.com/doc/2016-11-25/"}}},"payload":"StreamingDistributionConfig"},"output":{"type":"structure","members":{"StreamingDistribution":{"shape":"S2i"},"Location":{"location":"header","locationName":"Location"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"StreamingDistribution"}},"CreateStreamingDistributionWithTags":{"http":{"requestUri":"/2016-11-25/streaming-distribution?WithTags","responseCode":201},"input":{"type":"structure","required":["StreamingDistributionConfigWithTags"],"members":{"StreamingDistributionConfigWithTags":{"locationName":"StreamingDistributionConfigWithTags","xmlNamespace":{"uri":"http://cloudfront.amazonaws.com/doc/2016-11-25/"},"type":"structure","required":["StreamingDistributionConfig","Tags"],"members":{"StreamingDistributionConfig":{"shape":"S2e"},"Tags":{"shape":"S21"}}}},"payload":"StreamingDistributionConfigWithTags"},"output":{"type":"structure","members":{"StreamingDistribution":{"shape":"S2i"},"Location":{"location":"header","locationName":"Location"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"StreamingDistribution"}},"DeleteCloudFrontOriginAccessIdentity":{"http":{"method":"DELETE","requestUri":"/2016-11-25/origin-access-identity/cloudfront/{Id}","responseCode":204},"input":{"type":"structure","required":["Id"],"members":{"Id":{"location":"uri","locationName":"Id"},"IfMatch":{"location":"header","locationName":"If-Match"}}}},"DeleteDistribution":{"http":{"method":"DELETE","requestUri":"/2016-11-25/distribution/{Id}","responseCode":204},"input":{"type":"structure","required":["Id"],"members":{"Id":{"location":"uri","locationName":"Id"},"IfMatch":{"location":"header","locationName":"If-Match"}}}},"DeleteStreamingDistribution":{"http":{"method":"DELETE","requestUri":"/2016-11-25/streaming-distribution/{Id}","responseCode":204},"input":{"type":"structure","required":["Id"],"members":{"Id":{"location":"uri","locationName":"Id"},"IfMatch":{"location":"header","locationName":"If-Match"}}}},"GetCloudFrontOriginAccessIdentity":{"http":{"method":"GET","requestUri":"/2016-11-25/origin-access-identity/cloudfront/{Id}"},"input":{"type":"structure","required":["Id"],"members":{"Id":{"location":"uri","locationName":"Id"}}},"output":{"type":"structure","members":{"CloudFrontOriginAccessIdentity":{"shape":"S5"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"CloudFrontOriginAccessIdentity"}},"GetCloudFrontOriginAccessIdentityConfig":{"http":{"method":"GET","requestUri":"/2016-11-25/origin-access-identity/cloudfront/{Id}/config"},"input":{"type":"structure","required":["Id"],"members":{"Id":{"location":"uri","locationName":"Id"}}},"output":{"type":"structure","members":{"CloudFrontOriginAccessIdentityConfig":{"shape":"S2"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"CloudFrontOriginAccessIdentityConfig"}},"GetDistribution":{"http":{"method":"GET","requestUri":"/2016-11-25/distribution/{Id}"},"input":{"type":"structure","required":["Id"],"members":{"Id":{"location":"uri","locationName":"Id"}}},"output":{"type":"structure","members":{"Distribution":{"shape":"S1s"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"Distribution"}},"GetDistributionConfig":{"http":{"method":"GET","requestUri":"/2016-11-25/distribution/{Id}/config"},"input":{"type":"structure","required":["Id"],"members":{"Id":{"location":"uri","locationName":"Id"}}},"output":{"type":"structure","members":{"DistributionConfig":{"shape":"S7"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"DistributionConfig"}},"GetInvalidation":{"http":{"method":"GET","requestUri":"/2016-11-25/distribution/{DistributionId}/invalidation/{Id}"},"input":{"type":"structure","required":["DistributionId","Id"],"members":{"DistributionId":{"location":"uri","locationName":"DistributionId"},"Id":{"location":"uri","locationName":"Id"}}},"output":{"type":"structure","members":{"Invalidation":{"shape":"S2c"}},"payload":"Invalidation"}},"GetStreamingDistribution":{"http":{"method":"GET","requestUri":"/2016-11-25/streaming-distribution/{Id}"},"input":{"type":"structure","required":["Id"],"members":{"Id":{"location":"uri","locationName":"Id"}}},"output":{"type":"structure","members":{"StreamingDistribution":{"shape":"S2i"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"StreamingDistribution"}},"GetStreamingDistributionConfig":{"http":{"method":"GET","requestUri":"/2016-11-25/streaming-distribution/{Id}/config"},"input":{"type":"structure","required":["Id"],"members":{"Id":{"location":"uri","locationName":"Id"}}},"output":{"type":"structure","members":{"StreamingDistributionConfig":{"shape":"S2e"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"StreamingDistributionConfig"}},"ListCloudFrontOriginAccessIdentities":{"http":{"method":"GET","requestUri":"/2016-11-25/origin-access-identity/cloudfront"},"input":{"type":"structure","members":{"Marker":{"location":"querystring","locationName":"Marker"},"MaxItems":{"location":"querystring","locationName":"MaxItems"}}},"output":{"type":"structure","members":{"CloudFrontOriginAccessIdentityList":{"type":"structure","required":["Marker","MaxItems","IsTruncated","Quantity"],"members":{"Marker":{},"NextMarker":{},"MaxItems":{"type":"integer"},"IsTruncated":{"type":"boolean"},"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"CloudFrontOriginAccessIdentitySummary","type":"structure","required":["Id","S3CanonicalUserId","Comment"],"members":{"Id":{},"S3CanonicalUserId":{},"Comment":{}}}}}}},"payload":"CloudFrontOriginAccessIdentityList"}},"ListDistributions":{"http":{"method":"GET","requestUri":"/2016-11-25/distribution"},"input":{"type":"structure","members":{"Marker":{"location":"querystring","locationName":"Marker"},"MaxItems":{"location":"querystring","locationName":"MaxItems"}}},"output":{"type":"structure","members":{"DistributionList":{"shape":"S3a"}},"payload":"DistributionList"}},"ListDistributionsByWebACLId":{"http":{"method":"GET","requestUri":"/2016-11-25/distributionsByWebACLId/{WebACLId}"},"input":{"type":"structure","required":["WebACLId"],"members":{"Marker":{"location":"querystring","locationName":"Marker"},"MaxItems":{"location":"querystring","locationName":"MaxItems"},"WebACLId":{"location":"uri","locationName":"WebACLId"}}},"output":{"type":"structure","members":{"DistributionList":{"shape":"S3a"}},"payload":"DistributionList"}},"ListInvalidations":{"http":{"method":"GET","requestUri":"/2016-11-25/distribution/{DistributionId}/invalidation"},"input":{"type":"structure","required":["DistributionId"],"members":{"DistributionId":{"location":"uri","locationName":"DistributionId"},"Marker":{"location":"querystring","locationName":"Marker"},"MaxItems":{"location":"querystring","locationName":"MaxItems"}}},"output":{"type":"structure","members":{"InvalidationList":{"type":"structure","required":["Marker","MaxItems","IsTruncated","Quantity"],"members":{"Marker":{},"NextMarker":{},"MaxItems":{"type":"integer"},"IsTruncated":{"type":"boolean"},"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"InvalidationSummary","type":"structure","required":["Id","CreateTime","Status"],"members":{"Id":{},"CreateTime":{"type":"timestamp"},"Status":{}}}}}}},"payload":"InvalidationList"}},"ListStreamingDistributions":{"http":{"method":"GET","requestUri":"/2016-11-25/streaming-distribution"},"input":{"type":"structure","members":{"Marker":{"location":"querystring","locationName":"Marker"},"MaxItems":{"location":"querystring","locationName":"MaxItems"}}},"output":{"type":"structure","members":{"StreamingDistributionList":{"type":"structure","required":["Marker","MaxItems","IsTruncated","Quantity"],"members":{"Marker":{},"NextMarker":{},"MaxItems":{"type":"integer"},"IsTruncated":{"type":"boolean"},"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"StreamingDistributionSummary","type":"structure","required":["Id","ARN","Status","LastModifiedTime","DomainName","S3Origin","Aliases","TrustedSigners","Comment","PriceClass","Enabled"],"members":{"Id":{},"ARN":{},"Status":{},"LastModifiedTime":{"type":"timestamp"},"DomainName":{},"S3Origin":{"shape":"S2f"},"Aliases":{"shape":"S8"},"TrustedSigners":{"shape":"Sy"},"Comment":{},"PriceClass":{},"Enabled":{"type":"boolean"}}}}}}},"payload":"StreamingDistributionList"}},"ListTagsForResource":{"http":{"method":"GET","requestUri":"/2016-11-25/tagging"},"input":{"type":"structure","required":["Resource"],"members":{"Resource":{"location":"querystring","locationName":"Resource"}}},"output":{"type":"structure","required":["Tags"],"members":{"Tags":{"shape":"S21"}},"payload":"Tags"}},"TagResource":{"http":{"requestUri":"/2016-11-25/tagging?Operation=Tag","responseCode":204},"input":{"type":"structure","required":["Resource","Tags"],"members":{"Resource":{"location":"querystring","locationName":"Resource"},"Tags":{"shape":"S21","locationName":"Tags","xmlNamespace":{"uri":"http://cloudfront.amazonaws.com/doc/2016-11-25/"}}},"payload":"Tags"}},"UntagResource":{"http":{"requestUri":"/2016-11-25/tagging?Operation=Untag","responseCode":204},"input":{"type":"structure","required":["Resource","TagKeys"],"members":{"Resource":{"location":"querystring","locationName":"Resource"},"TagKeys":{"locationName":"TagKeys","xmlNamespace":{"uri":"http://cloudfront.amazonaws.com/doc/2016-11-25/"},"type":"structure","members":{"Items":{"type":"list","member":{"locationName":"Key"}}}}},"payload":"TagKeys"}},"UpdateCloudFrontOriginAccessIdentity":{"http":{"method":"PUT","requestUri":"/2016-11-25/origin-access-identity/cloudfront/{Id}/config"},"input":{"type":"structure","required":["CloudFrontOriginAccessIdentityConfig","Id"],"members":{"CloudFrontOriginAccessIdentityConfig":{"shape":"S2","locationName":"CloudFrontOriginAccessIdentityConfig","xmlNamespace":{"uri":"http://cloudfront.amazonaws.com/doc/2016-11-25/"}},"Id":{"location":"uri","locationName":"Id"},"IfMatch":{"location":"header","locationName":"If-Match"}},"payload":"CloudFrontOriginAccessIdentityConfig"},"output":{"type":"structure","members":{"CloudFrontOriginAccessIdentity":{"shape":"S5"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"CloudFrontOriginAccessIdentity"}},"UpdateDistribution":{"http":{"method":"PUT","requestUri":"/2016-11-25/distribution/{Id}/config"},"input":{"type":"structure","required":["DistributionConfig","Id"],"members":{"DistributionConfig":{"shape":"S7","locationName":"DistributionConfig","xmlNamespace":{"uri":"http://cloudfront.amazonaws.com/doc/2016-11-25/"}},"Id":{"location":"uri","locationName":"Id"},"IfMatch":{"location":"header","locationName":"If-Match"}},"payload":"DistributionConfig"},"output":{"type":"structure","members":{"Distribution":{"shape":"S1s"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"Distribution"}},"UpdateStreamingDistribution":{"http":{"method":"PUT","requestUri":"/2016-11-25/streaming-distribution/{Id}/config"},"input":{"type":"structure","required":["StreamingDistributionConfig","Id"],"members":{"StreamingDistributionConfig":{"shape":"S2e","locationName":"StreamingDistributionConfig","xmlNamespace":{"uri":"http://cloudfront.amazonaws.com/doc/2016-11-25/"}},"Id":{"location":"uri","locationName":"Id"},"IfMatch":{"location":"header","locationName":"If-Match"}},"payload":"StreamingDistributionConfig"},"output":{"type":"structure","members":{"StreamingDistribution":{"shape":"S2i"},"ETag":{"location":"header","locationName":"ETag"}},"payload":"StreamingDistribution"}}},"shapes":{"S2":{"type":"structure","required":["CallerReference","Comment"],"members":{"CallerReference":{},"Comment":{}}},"S5":{"type":"structure","required":["Id","S3CanonicalUserId"],"members":{"Id":{},"S3CanonicalUserId":{},"CloudFrontOriginAccessIdentityConfig":{"shape":"S2"}}},"S7":{"type":"structure","required":["CallerReference","Origins","DefaultCacheBehavior","Comment","Enabled"],"members":{"CallerReference":{},"Aliases":{"shape":"S8"},"DefaultRootObject":{},"Origins":{"shape":"Sb"},"DefaultCacheBehavior":{"shape":"Sn"},"CacheBehaviors":{"shape":"S1a"},"CustomErrorResponses":{"shape":"S1d"},"Comment":{},"Logging":{"type":"structure","required":["Enabled","IncludeCookies","Bucket","Prefix"],"members":{"Enabled":{"type":"boolean"},"IncludeCookies":{"type":"boolean"},"Bucket":{},"Prefix":{}}},"PriceClass":{},"Enabled":{"type":"boolean"},"ViewerCertificate":{"shape":"S1i"},"Restrictions":{"shape":"S1m"},"WebACLId":{},"HttpVersion":{},"IsIPV6Enabled":{"type":"boolean"}}},"S8":{"type":"structure","required":["Quantity"],"members":{"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"CNAME"}}}},"Sb":{"type":"structure","required":["Quantity"],"members":{"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"Origin","type":"structure","required":["Id","DomainName"],"members":{"Id":{},"DomainName":{},"OriginPath":{},"CustomHeaders":{"type":"structure","required":["Quantity"],"members":{"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"OriginCustomHeader","type":"structure","required":["HeaderName","HeaderValue"],"members":{"HeaderName":{},"HeaderValue":{}}}}}},"S3OriginConfig":{"type":"structure","required":["OriginAccessIdentity"],"members":{"OriginAccessIdentity":{}}},"CustomOriginConfig":{"type":"structure","required":["HTTPPort","HTTPSPort","OriginProtocolPolicy"],"members":{"HTTPPort":{"type":"integer"},"HTTPSPort":{"type":"integer"},"OriginProtocolPolicy":{},"OriginSslProtocols":{"type":"structure","required":["Quantity","Items"],"members":{"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"SslProtocol"}}}}}}}}}}},"Sn":{"type":"structure","required":["TargetOriginId","ForwardedValues","TrustedSigners","ViewerProtocolPolicy","MinTTL"],"members":{"TargetOriginId":{},"ForwardedValues":{"shape":"So"},"TrustedSigners":{"shape":"Sy"},"ViewerProtocolPolicy":{},"MinTTL":{"type":"long"},"AllowedMethods":{"shape":"S12"},"SmoothStreaming":{"type":"boolean"},"DefaultTTL":{"type":"long"},"MaxTTL":{"type":"long"},"Compress":{"type":"boolean"},"LambdaFunctionAssociations":{"shape":"S16"}}},"So":{"type":"structure","required":["QueryString","Cookies"],"members":{"QueryString":{"type":"boolean"},"Cookies":{"type":"structure","required":["Forward"],"members":{"Forward":{},"WhitelistedNames":{"type":"structure","required":["Quantity"],"members":{"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"Name"}}}}}},"Headers":{"type":"structure","required":["Quantity"],"members":{"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"Name"}}}},"QueryStringCacheKeys":{"type":"structure","required":["Quantity"],"members":{"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"Name"}}}}}},"Sy":{"type":"structure","required":["Enabled","Quantity"],"members":{"Enabled":{"type":"boolean"},"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"AwsAccountNumber"}}}},"S12":{"type":"structure","required":["Quantity","Items"],"members":{"Quantity":{"type":"integer"},"Items":{"shape":"S13"},"CachedMethods":{"type":"structure","required":["Quantity","Items"],"members":{"Quantity":{"type":"integer"},"Items":{"shape":"S13"}}}}},"S13":{"type":"list","member":{"locationName":"Method"}},"S16":{"type":"structure","required":["Quantity"],"members":{"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"LambdaFunctionAssociation","type":"structure","members":{"LambdaFunctionARN":{},"EventType":{}}}}}},"S1a":{"type":"structure","required":["Quantity"],"members":{"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"CacheBehavior","type":"structure","required":["PathPattern","TargetOriginId","ForwardedValues","TrustedSigners","ViewerProtocolPolicy","MinTTL"],"members":{"PathPattern":{},"TargetOriginId":{},"ForwardedValues":{"shape":"So"},"TrustedSigners":{"shape":"Sy"},"ViewerProtocolPolicy":{},"MinTTL":{"type":"long"},"AllowedMethods":{"shape":"S12"},"SmoothStreaming":{"type":"boolean"},"DefaultTTL":{"type":"long"},"MaxTTL":{"type":"long"},"Compress":{"type":"boolean"},"LambdaFunctionAssociations":{"shape":"S16"}}}}}},"S1d":{"type":"structure","required":["Quantity"],"members":{"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"CustomErrorResponse","type":"structure","required":["ErrorCode"],"members":{"ErrorCode":{"type":"integer"},"ResponsePagePath":{},"ResponseCode":{},"ErrorCachingMinTTL":{"type":"long"}}}}}},"S1i":{"type":"structure","members":{"CloudFrontDefaultCertificate":{"type":"boolean"},"IAMCertificateId":{},"ACMCertificateArn":{},"SSLSupportMethod":{},"MinimumProtocolVersion":{},"Certificate":{"deprecated":true},"CertificateSource":{"deprecated":true}}},"S1m":{"type":"structure","required":["GeoRestriction"],"members":{"GeoRestriction":{"type":"structure","required":["RestrictionType","Quantity"],"members":{"RestrictionType":{},"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"Location"}}}}}},"S1s":{"type":"structure","required":["Id","ARN","Status","LastModifiedTime","InProgressInvalidationBatches","DomainName","ActiveTrustedSigners","DistributionConfig"],"members":{"Id":{},"ARN":{},"Status":{},"LastModifiedTime":{"type":"timestamp"},"InProgressInvalidationBatches":{"type":"integer"},"DomainName":{},"ActiveTrustedSigners":{"shape":"S1u"},"DistributionConfig":{"shape":"S7"}}},"S1u":{"type":"structure","required":["Enabled","Quantity"],"members":{"Enabled":{"type":"boolean"},"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"Signer","type":"structure","members":{"AwsAccountNumber":{},"KeyPairIds":{"type":"structure","required":["Quantity"],"members":{"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"KeyPairId"}}}}}}}}},"S21":{"type":"structure","members":{"Items":{"type":"list","member":{"locationName":"Tag","type":"structure","required":["Key"],"members":{"Key":{},"Value":{}}}}}},"S28":{"type":"structure","required":["Paths","CallerReference"],"members":{"Paths":{"type":"structure","required":["Quantity"],"members":{"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"Path"}}}},"CallerReference":{}}},"S2c":{"type":"structure","required":["Id","Status","CreateTime","InvalidationBatch"],"members":{"Id":{},"Status":{},"CreateTime":{"type":"timestamp"},"InvalidationBatch":{"shape":"S28"}}},"S2e":{"type":"structure","required":["CallerReference","S3Origin","Comment","TrustedSigners","Enabled"],"members":{"CallerReference":{},"S3Origin":{"shape":"S2f"},"Aliases":{"shape":"S8"},"Comment":{},"Logging":{"type":"structure","required":["Enabled","Bucket","Prefix"],"members":{"Enabled":{"type":"boolean"},"Bucket":{},"Prefix":{}}},"TrustedSigners":{"shape":"Sy"},"PriceClass":{},"Enabled":{"type":"boolean"}}},"S2f":{"type":"structure","required":["DomainName","OriginAccessIdentity"],"members":{"DomainName":{},"OriginAccessIdentity":{}}},"S2i":{"type":"structure","required":["Id","ARN","Status","DomainName","ActiveTrustedSigners","StreamingDistributionConfig"],"members":{"Id":{},"ARN":{},"Status":{},"LastModifiedTime":{"type":"timestamp"},"DomainName":{},"ActiveTrustedSigners":{"shape":"S1u"},"StreamingDistributionConfig":{"shape":"S2e"}}},"S3a":{"type":"structure","required":["Marker","MaxItems","IsTruncated","Quantity"],"members":{"Marker":{},"NextMarker":{},"MaxItems":{"type":"integer"},"IsTruncated":{"type":"boolean"},"Quantity":{"type":"integer"},"Items":{"type":"list","member":{"locationName":"DistributionSummary","type":"structure","required":["Id","ARN","Status","LastModifiedTime","DomainName","Aliases","Origins","DefaultCacheBehavior","CacheBehaviors","CustomErrorResponses","Comment","PriceClass","Enabled","ViewerCertificate","Restrictions","WebACLId","HttpVersion","IsIPV6Enabled"],"members":{"Id":{},"ARN":{},"Status":{},"LastModifiedTime":{"type":"timestamp"},"DomainName":{},"Aliases":{"shape":"S8"},"Origins":{"shape":"Sb"},"DefaultCacheBehavior":{"shape":"Sn"},"CacheBehaviors":{"shape":"S1a"},"CustomErrorResponses":{"shape":"S1d"},"Comment":{},"PriceClass":{},"Enabled":{"type":"boolean"},"ViewerCertificate":{"shape":"S1i"},"Restrictions":{"shape":"S1m"},"WebACLId":{},"HttpVersion":{},"IsIPV6Enabled":{"type":"boolean"}}}}}}}}; /***/ }), -/***/ 1661: -/***/ (function(module, __unusedexports, __webpack_require__) { +/***/ 4274: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + -var eventMessageChunker = __webpack_require__(625).eventMessageChunker; -var parseEvent = __webpack_require__(4657).parseEvent; +var xmlParser = __nccwpck_require__(3343); -function createEventStream(body, parser, model) { - var eventMessages = eventMessageChunker(body); +function escapeAttribute(value) { + return value.replace(/&/g, "&").replace(//g, ">").replace(/"/g, """); +} - var events = []; +function escapeElement(value) { + return value + .replace(/&/g, "&") + .replace(/"/g, """) + .replace(/'/g, "'") + .replace(//g, ">") + .replace(/\r/g, " ") + .replace(/\n/g, " ") + .replace(/\u0085/g, "…") + .replace(/\u2028/, "
"); +} - for (var i = 0; i < eventMessages.length; i++) { - events.push(parseEvent(parser, eventMessages[i], model)); +class XmlText { + value; + constructor(value) { + this.value = value; + } + toString() { + return escapeElement("" + this.value); } +} - return events; +class XmlNode { + name; + children; + attributes = {}; + static of(name, childText, withName) { + const node = new XmlNode(name); + if (childText !== undefined) { + node.addChildNode(new XmlText(childText)); + } + if (withName !== undefined) { + node.withName(withName); + } + return node; + } + constructor(name, children = []) { + this.name = name; + this.children = children; + } + withName(name) { + this.name = name; + return this; + } + addAttribute(name, value) { + this.attributes[name] = value; + return this; + } + addChildNode(child) { + this.children.push(child); + return this; + } + removeAttribute(name) { + delete this.attributes[name]; + return this; + } + n(name) { + this.name = name; + return this; + } + c(child) { + this.children.push(child); + return this; + } + a(name, value) { + if (value != null) { + this.attributes[name] = value; + } + return this; + } + cc(input, field, withName = field) { + if (input[field] != null) { + const node = XmlNode.of(field, input[field]).withName(withName); + this.c(node); + } + } + l(input, listName, memberName, valueProvider) { + if (input[listName] != null) { + const nodes = valueProvider(); + nodes.map((node) => { + node.withName(memberName); + this.c(node); + }); + } + } + lc(input, listName, memberName, valueProvider) { + if (input[listName] != null) { + const nodes = valueProvider(); + const containerNode = new XmlNode(memberName); + nodes.map((node) => { + containerNode.c(node); + }); + this.c(containerNode); + } + } + toString() { + const hasChildren = Boolean(this.children.length); + let xmlText = `<${this.name}`; + const attributes = this.attributes; + for (const attributeName of Object.keys(attributes)) { + const attribute = attributes[attributeName]; + if (attribute != null) { + xmlText += ` ${attributeName}="${escapeAttribute("" + attribute)}"`; + } + } + return (xmlText += !hasChildren ? "/>" : `>${this.children.map((c) => c.toString()).join("")}`); + } } -/** - * @api private - */ -module.exports = { - createEventStream: createEventStream -}; +Object.defineProperty(exports, "parseXML", ({ + enumerable: true, + get: function () { return xmlParser.parseXML; } +})); +exports.XmlNode = XmlNode; +exports.XmlText = XmlText; /***/ }), -/***/ 1669: -/***/ (function(module) { - -module.exports = require("util"); +/***/ 3343: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -/***/ }), +"use strict"; -/***/ 1677: -/***/ (function(module) { +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.parseXML = parseXML; +const fast_xml_parser_1 = __nccwpck_require__(591); +const parser = new fast_xml_parser_1.XMLParser({ + attributeNamePrefix: "", + htmlEntities: true, + ignoreAttributes: false, + ignoreDeclaration: true, + parseTagValue: false, + trimValues: false, + tagValueProcessor: (_, val) => (val.trim() === "" && val.includes("\n") ? "" : undefined), +}); +parser.addEntity("#xD", "\r"); +parser.addEntity("#10", "\n"); +function parseXML(xmlString) { + return parser.parse(xmlString, true); +} -module.exports = {"pagination":{"ListHealthChecks":{"input_token":"Marker","limit_key":"MaxItems","more_results":"IsTruncated","output_token":"NextMarker","result_key":"HealthChecks"},"ListHostedZones":{"input_token":"Marker","limit_key":"MaxItems","more_results":"IsTruncated","output_token":"NextMarker","result_key":"HostedZones"},"ListQueryLoggingConfigs":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"QueryLoggingConfigs"},"ListResourceRecordSets":{"input_token":["StartRecordName","StartRecordType","StartRecordIdentifier"],"limit_key":"MaxItems","more_results":"IsTruncated","output_token":["NextRecordName","NextRecordType","NextRecordIdentifier"],"result_key":"ResourceRecordSets"}}}; /***/ }), -/***/ 1694: -/***/ (function(module) { +/***/ 9320: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -module.exports = {"acm":{"name":"ACM","cors":true},"apigateway":{"name":"APIGateway","cors":true},"applicationautoscaling":{"prefix":"application-autoscaling","name":"ApplicationAutoScaling","cors":true},"appstream":{"name":"AppStream"},"autoscaling":{"name":"AutoScaling","cors":true},"batch":{"name":"Batch"},"budgets":{"name":"Budgets"},"clouddirectory":{"name":"CloudDirectory","versions":["2016-05-10*"]},"cloudformation":{"name":"CloudFormation","cors":true},"cloudfront":{"name":"CloudFront","versions":["2013-05-12*","2013-11-11*","2014-05-31*","2014-10-21*","2014-11-06*","2015-04-17*","2015-07-27*","2015-09-17*","2016-01-13*","2016-01-28*","2016-08-01*","2016-08-20*","2016-09-07*","2016-09-29*","2016-11-25*","2017-03-25*","2017-10-30*","2018-06-18*","2018-11-05*","2019-03-26*"],"cors":true},"cloudhsm":{"name":"CloudHSM","cors":true},"cloudsearch":{"name":"CloudSearch"},"cloudsearchdomain":{"name":"CloudSearchDomain"},"cloudtrail":{"name":"CloudTrail","cors":true},"cloudwatch":{"prefix":"monitoring","name":"CloudWatch","cors":true},"cloudwatchevents":{"prefix":"events","name":"CloudWatchEvents","versions":["2014-02-03*"],"cors":true},"cloudwatchlogs":{"prefix":"logs","name":"CloudWatchLogs","cors":true},"codebuild":{"name":"CodeBuild","cors":true},"codecommit":{"name":"CodeCommit","cors":true},"codedeploy":{"name":"CodeDeploy","cors":true},"codepipeline":{"name":"CodePipeline","cors":true},"cognitoidentity":{"prefix":"cognito-identity","name":"CognitoIdentity","cors":true},"cognitoidentityserviceprovider":{"prefix":"cognito-idp","name":"CognitoIdentityServiceProvider","cors":true},"cognitosync":{"prefix":"cognito-sync","name":"CognitoSync","cors":true},"configservice":{"prefix":"config","name":"ConfigService","cors":true},"cur":{"name":"CUR","cors":true},"datapipeline":{"name":"DataPipeline"},"devicefarm":{"name":"DeviceFarm","cors":true},"directconnect":{"name":"DirectConnect","cors":true},"directoryservice":{"prefix":"ds","name":"DirectoryService"},"discovery":{"name":"Discovery"},"dms":{"name":"DMS"},"dynamodb":{"name":"DynamoDB","cors":true},"dynamodbstreams":{"prefix":"streams.dynamodb","name":"DynamoDBStreams","cors":true},"ec2":{"name":"EC2","versions":["2013-06-15*","2013-10-15*","2014-02-01*","2014-05-01*","2014-06-15*","2014-09-01*","2014-10-01*","2015-03-01*","2015-04-15*","2015-10-01*","2016-04-01*","2016-09-15*"],"cors":true},"ecr":{"name":"ECR","cors":true},"ecs":{"name":"ECS","cors":true},"efs":{"prefix":"elasticfilesystem","name":"EFS","cors":true},"elasticache":{"name":"ElastiCache","versions":["2012-11-15*","2014-03-24*","2014-07-15*","2014-09-30*"],"cors":true},"elasticbeanstalk":{"name":"ElasticBeanstalk","cors":true},"elb":{"prefix":"elasticloadbalancing","name":"ELB","cors":true},"elbv2":{"prefix":"elasticloadbalancingv2","name":"ELBv2","cors":true},"emr":{"prefix":"elasticmapreduce","name":"EMR","cors":true},"es":{"name":"ES"},"elastictranscoder":{"name":"ElasticTranscoder","cors":true},"firehose":{"name":"Firehose","cors":true},"gamelift":{"name":"GameLift","cors":true},"glacier":{"name":"Glacier"},"health":{"name":"Health"},"iam":{"name":"IAM","cors":true},"importexport":{"name":"ImportExport"},"inspector":{"name":"Inspector","versions":["2015-08-18*"],"cors":true},"iot":{"name":"Iot","cors":true},"iotdata":{"prefix":"iot-data","name":"IotData","cors":true},"kinesis":{"name":"Kinesis","cors":true},"kinesisanalytics":{"name":"KinesisAnalytics"},"kms":{"name":"KMS","cors":true},"lambda":{"name":"Lambda","cors":true},"lexruntime":{"prefix":"runtime.lex","name":"LexRuntime","cors":true},"lightsail":{"name":"Lightsail"},"machinelearning":{"name":"MachineLearning","cors":true},"marketplacecommerceanalytics":{"name":"MarketplaceCommerceAnalytics","cors":true},"marketplacemetering":{"prefix":"meteringmarketplace","name":"MarketplaceMetering"},"mturk":{"prefix":"mturk-requester","name":"MTurk","cors":true},"mobileanalytics":{"name":"MobileAnalytics","cors":true},"opsworks":{"name":"OpsWorks","cors":true},"opsworkscm":{"name":"OpsWorksCM"},"organizations":{"name":"Organizations"},"pinpoint":{"name":"Pinpoint"},"polly":{"name":"Polly","cors":true},"rds":{"name":"RDS","versions":["2014-09-01*"],"cors":true},"redshift":{"name":"Redshift","cors":true},"rekognition":{"name":"Rekognition","cors":true},"resourcegroupstaggingapi":{"name":"ResourceGroupsTaggingAPI"},"route53":{"name":"Route53","cors":true},"route53domains":{"name":"Route53Domains","cors":true},"s3":{"name":"S3","dualstackAvailable":true,"cors":true},"s3control":{"name":"S3Control","dualstackAvailable":true,"xmlNoDefaultLists":true},"servicecatalog":{"name":"ServiceCatalog","cors":true},"ses":{"prefix":"email","name":"SES","cors":true},"shield":{"name":"Shield"},"simpledb":{"prefix":"sdb","name":"SimpleDB"},"sms":{"name":"SMS"},"snowball":{"name":"Snowball"},"sns":{"name":"SNS","cors":true},"sqs":{"name":"SQS","cors":true},"ssm":{"name":"SSM","cors":true},"storagegateway":{"name":"StorageGateway","cors":true},"stepfunctions":{"prefix":"states","name":"StepFunctions"},"sts":{"name":"STS","cors":true},"support":{"name":"Support"},"swf":{"name":"SWF"},"xray":{"name":"XRay","cors":true},"waf":{"name":"WAF","cors":true},"wafregional":{"prefix":"waf-regional","name":"WAFRegional"},"workdocs":{"name":"WorkDocs","cors":true},"workspaces":{"name":"WorkSpaces"},"codestar":{"name":"CodeStar"},"lexmodelbuildingservice":{"prefix":"lex-models","name":"LexModelBuildingService","cors":true},"marketplaceentitlementservice":{"prefix":"entitlement.marketplace","name":"MarketplaceEntitlementService"},"athena":{"name":"Athena"},"greengrass":{"name":"Greengrass"},"dax":{"name":"DAX"},"migrationhub":{"prefix":"AWSMigrationHub","name":"MigrationHub"},"cloudhsmv2":{"name":"CloudHSMV2"},"glue":{"name":"Glue"},"mobile":{"name":"Mobile"},"pricing":{"name":"Pricing","cors":true},"costexplorer":{"prefix":"ce","name":"CostExplorer","cors":true},"mediaconvert":{"name":"MediaConvert"},"medialive":{"name":"MediaLive"},"mediapackage":{"name":"MediaPackage"},"mediastore":{"name":"MediaStore"},"mediastoredata":{"prefix":"mediastore-data","name":"MediaStoreData","cors":true},"appsync":{"name":"AppSync"},"guardduty":{"name":"GuardDuty"},"mq":{"name":"MQ"},"comprehend":{"name":"Comprehend","cors":true},"iotjobsdataplane":{"prefix":"iot-jobs-data","name":"IoTJobsDataPlane"},"kinesisvideoarchivedmedia":{"prefix":"kinesis-video-archived-media","name":"KinesisVideoArchivedMedia","cors":true},"kinesisvideomedia":{"prefix":"kinesis-video-media","name":"KinesisVideoMedia","cors":true},"kinesisvideo":{"name":"KinesisVideo","cors":true},"sagemakerruntime":{"prefix":"runtime.sagemaker","name":"SageMakerRuntime"},"sagemaker":{"name":"SageMaker"},"translate":{"name":"Translate","cors":true},"resourcegroups":{"prefix":"resource-groups","name":"ResourceGroups","cors":true},"alexaforbusiness":{"name":"AlexaForBusiness"},"cloud9":{"name":"Cloud9"},"serverlessapplicationrepository":{"prefix":"serverlessrepo","name":"ServerlessApplicationRepository"},"servicediscovery":{"name":"ServiceDiscovery"},"workmail":{"name":"WorkMail"},"autoscalingplans":{"prefix":"autoscaling-plans","name":"AutoScalingPlans"},"transcribeservice":{"prefix":"transcribe","name":"TranscribeService"},"connect":{"name":"Connect","cors":true},"acmpca":{"prefix":"acm-pca","name":"ACMPCA"},"fms":{"name":"FMS"},"secretsmanager":{"name":"SecretsManager","cors":true},"iotanalytics":{"name":"IoTAnalytics","cors":true},"iot1clickdevicesservice":{"prefix":"iot1click-devices","name":"IoT1ClickDevicesService"},"iot1clickprojects":{"prefix":"iot1click-projects","name":"IoT1ClickProjects"},"pi":{"name":"PI"},"neptune":{"name":"Neptune"},"mediatailor":{"name":"MediaTailor"},"eks":{"name":"EKS"},"macie":{"name":"Macie"},"dlm":{"name":"DLM"},"signer":{"name":"Signer"},"chime":{"name":"Chime"},"pinpointemail":{"prefix":"pinpoint-email","name":"PinpointEmail"},"ram":{"name":"RAM"},"route53resolver":{"name":"Route53Resolver"},"pinpointsmsvoice":{"prefix":"sms-voice","name":"PinpointSMSVoice"},"quicksight":{"name":"QuickSight"},"rdsdataservice":{"prefix":"rds-data","name":"RDSDataService"},"amplify":{"name":"Amplify"},"datasync":{"name":"DataSync"},"robomaker":{"name":"RoboMaker"},"transfer":{"name":"Transfer"},"globalaccelerator":{"name":"GlobalAccelerator"},"comprehendmedical":{"name":"ComprehendMedical","cors":true},"kinesisanalyticsv2":{"name":"KinesisAnalyticsV2"},"mediaconnect":{"name":"MediaConnect"},"fsx":{"name":"FSx"},"securityhub":{"name":"SecurityHub"},"appmesh":{"name":"AppMesh","versions":["2018-10-01*"]},"licensemanager":{"prefix":"license-manager","name":"LicenseManager"},"kafka":{"name":"Kafka"},"apigatewaymanagementapi":{"name":"ApiGatewayManagementApi"},"apigatewayv2":{"name":"ApiGatewayV2"},"docdb":{"name":"DocDB"},"backup":{"name":"Backup"},"worklink":{"name":"WorkLink"},"textract":{"name":"Textract"},"managedblockchain":{"name":"ManagedBlockchain"},"mediapackagevod":{"prefix":"mediapackage-vod","name":"MediaPackageVod"},"groundstation":{"name":"GroundStation"},"iotthingsgraph":{"name":"IoTThingsGraph"},"iotevents":{"name":"IoTEvents"},"ioteventsdata":{"prefix":"iotevents-data","name":"IoTEventsData"},"personalize":{"name":"Personalize","cors":true},"personalizeevents":{"prefix":"personalize-events","name":"PersonalizeEvents","cors":true},"personalizeruntime":{"prefix":"personalize-runtime","name":"PersonalizeRuntime","cors":true},"applicationinsights":{"prefix":"application-insights","name":"ApplicationInsights"},"servicequotas":{"prefix":"service-quotas","name":"ServiceQuotas"},"ec2instanceconnect":{"prefix":"ec2-instance-connect","name":"EC2InstanceConnect"},"eventbridge":{"name":"EventBridge"},"lakeformation":{"name":"LakeFormation"},"forecastservice":{"prefix":"forecast","name":"ForecastService","cors":true},"forecastqueryservice":{"prefix":"forecastquery","name":"ForecastQueryService","cors":true},"qldb":{"name":"QLDB"},"qldbsession":{"prefix":"qldb-session","name":"QLDBSession"},"workmailmessageflow":{"name":"WorkMailMessageFlow"},"codestarnotifications":{"prefix":"codestar-notifications","name":"CodeStarNotifications"},"savingsplans":{"name":"SavingsPlans"},"sso":{"name":"SSO"},"ssooidc":{"prefix":"sso-oidc","name":"SSOOIDC"},"marketplacecatalog":{"prefix":"marketplace-catalog","name":"MarketplaceCatalog"},"dataexchange":{"name":"DataExchange"},"sesv2":{"name":"SESV2"},"migrationhubconfig":{"prefix":"migrationhub-config","name":"MigrationHubConfig"},"connectparticipant":{"name":"ConnectParticipant"},"appconfig":{"name":"AppConfig"},"iotsecuretunneling":{"name":"IoTSecureTunneling"},"wafv2":{"name":"WAFV2"},"elasticinference":{"prefix":"elastic-inference","name":"ElasticInference"},"imagebuilder":{"name":"Imagebuilder"},"schemas":{"name":"Schemas"},"accessanalyzer":{"name":"AccessAnalyzer"},"codegurureviewer":{"prefix":"codeguru-reviewer","name":"CodeGuruReviewer"},"codeguruprofiler":{"name":"CodeGuruProfiler"},"computeoptimizer":{"prefix":"compute-optimizer","name":"ComputeOptimizer"},"frauddetector":{"name":"FraudDetector"},"kendra":{"name":"Kendra"},"networkmanager":{"name":"NetworkManager"},"outposts":{"name":"Outposts"},"augmentedairuntime":{"prefix":"sagemaker-a2i-runtime","name":"AugmentedAIRuntime"},"ebs":{"name":"EBS"},"kinesisvideosignalingchannels":{"prefix":"kinesis-video-signaling","name":"KinesisVideoSignalingChannels","cors":true},"detective":{"name":"Detective"},"codestarconnections":{"prefix":"codestar-connections","name":"CodeStarconnections"},"synthetics":{"name":"Synthetics"},"iotsitewise":{"name":"IoTSiteWise"},"macie2":{"name":"Macie2"},"codeartifact":{"name":"CodeArtifact"},"honeycode":{"name":"Honeycode"},"ivs":{"name":"IVS"}}; - -/***/ }), - -/***/ 1701: -/***/ (function(module, __unusedexports, __webpack_require__) { - -var util = __webpack_require__(395).util; -var dgram = __webpack_require__(6200); -var stringToBuffer = util.buffer.toBuffer; +"use strict"; -var MAX_MESSAGE_SIZE = 1024 * 8; // 8 KB -/** - * Publishes metrics via udp. - * @param {object} options Paramters for Publisher constructor - * @param {number} [options.port = 31000] Port number - * @param {string} [options.clientId = ''] Client Identifier - * @param {boolean} [options.enabled = false] enable sending metrics datagram - * @api private - */ -function Publisher(options) { - // handle configuration - options = options || {}; - this.enabled = options.enabled || false; - this.port = options.port || 31000; - this.clientId = options.clientId || ''; - this.address = options.host || '127.0.0.1'; - if (this.clientId.length > 255) { - // ClientId has a max length of 255 - this.clientId = this.clientId.substr(0, 255); +const PROTECTED_KEYS = { + REQUEST_ID: Symbol.for("_AWS_LAMBDA_REQUEST_ID"), + X_RAY_TRACE_ID: Symbol.for("_AWS_LAMBDA_X_RAY_TRACE_ID"), + TENANT_ID: Symbol.for("_AWS_LAMBDA_TENANT_ID"), +}; +const NO_GLOBAL_AWS_LAMBDA = ["true", "1"].includes(process.env?.AWS_LAMBDA_NODEJS_NO_GLOBAL_AWSLAMBDA ?? ""); +if (!NO_GLOBAL_AWS_LAMBDA) { + globalThis.awslambda = globalThis.awslambda || {}; +} +class InvokeStoreBase { + static PROTECTED_KEYS = PROTECTED_KEYS; + isProtectedKey(key) { + return Object.values(PROTECTED_KEYS).includes(key); + } + getRequestId() { + return this.get(PROTECTED_KEYS.REQUEST_ID) ?? "-"; + } + getXRayTraceId() { + return this.get(PROTECTED_KEYS.X_RAY_TRACE_ID); + } + getTenantId() { + return this.get(PROTECTED_KEYS.TENANT_ID); + } +} +class InvokeStoreSingle extends InvokeStoreBase { + currentContext; + getContext() { + return this.currentContext; + } + hasContext() { + return this.currentContext !== undefined; + } + get(key) { + return this.currentContext?.[key]; + } + set(key, value) { + if (this.isProtectedKey(key)) { + throw new Error(`Cannot modify protected Lambda context field: ${String(key)}`); + } + this.currentContext = this.currentContext || {}; + this.currentContext[key] = value; + } + run(context, fn) { + this.currentContext = context; + return fn(); + } +} +class InvokeStoreMulti extends InvokeStoreBase { + als; + static async create() { + const instance = new InvokeStoreMulti(); + const asyncHooks = await Promise.resolve(/* import() */).then(__nccwpck_require__.t.bind(__nccwpck_require__, 6698, 23)); + instance.als = new asyncHooks.AsyncLocalStorage(); + return instance; + } + getContext() { + return this.als.getStore(); + } + hasContext() { + return this.als.getStore() !== undefined; + } + get(key) { + return this.als.getStore()?.[key]; + } + set(key, value) { + if (this.isProtectedKey(key)) { + throw new Error(`Cannot modify protected Lambda context field: ${String(key)}`); + } + const store = this.als.getStore(); + if (!store) { + throw new Error("No context available"); + } + store[key] = value; + } + run(context, fn) { + return this.als.run(context, fn); } - this.messagesInFlight = 0; } +exports.InvokeStore = void 0; +(function (InvokeStore) { + let instance = null; + async function getInstanceAsync() { + if (!instance) { + instance = (async () => { + const isMulti = "AWS_LAMBDA_MAX_CONCURRENCY" in process.env; + const newInstance = isMulti + ? await InvokeStoreMulti.create() + : new InvokeStoreSingle(); + if (!NO_GLOBAL_AWS_LAMBDA && globalThis.awslambda?.InvokeStore) { + return globalThis.awslambda.InvokeStore; + } + else if (!NO_GLOBAL_AWS_LAMBDA && globalThis.awslambda) { + globalThis.awslambda.InvokeStore = newInstance; + return newInstance; + } + else { + return newInstance; + } + })(); + } + return instance; + } + InvokeStore.getInstanceAsync = getInstanceAsync; + InvokeStore._testing = process.env.AWS_LAMBDA_BENCHMARK_MODE === "1" + ? { + reset: () => { + instance = null; + if (globalThis.awslambda?.InvokeStore) { + delete globalThis.awslambda.InvokeStore; + } + globalThis.awslambda = { InvokeStore: undefined }; + }, + } + : undefined; +})(exports.InvokeStore || (exports.InvokeStore = {})); -Publisher.prototype.fieldsToTrim = { - UserAgent: 256, - SdkException: 128, - SdkExceptionMessage: 512, - AwsException: 128, - AwsExceptionMessage: 512, - FinalSdkException: 128, - FinalSdkExceptionMessage: 512, - FinalAwsException: 128, - FinalAwsExceptionMessage: 512 +exports.InvokeStoreBase = InvokeStoreBase; -}; -/** - * Trims fields that have a specified max length. - * @param {object} event ApiCall or ApiCallAttempt event. - * @returns {object} - * @api private - */ -Publisher.prototype.trimFields = function(event) { - var trimmableFields = Object.keys(this.fieldsToTrim); - for (var i = 0, iLen = trimmableFields.length; i < iLen; i++) { - var field = trimmableFields[i]; - if (event.hasOwnProperty(field)) { - var maxLength = this.fieldsToTrim[field]; - var value = event[field]; - if (value && value.length > maxLength) { - event[field] = value.substr(0, maxLength); - } - } - } - return event; -}; +/***/ }), -/** - * Handles ApiCall and ApiCallAttempt events. - * @param {Object} event apiCall or apiCallAttempt event. - * @api private - */ -Publisher.prototype.eventHandler = function(event) { - // set the clientId - event.ClientId = this.clientId; +/***/ 9316: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - this.trimFields(event); +"use strict"; - var message = stringToBuffer(JSON.stringify(event)); - if (!this.enabled || message.length > MAX_MESSAGE_SIZE) { - // drop the message if publisher not enabled or it is too large - return; - } - this.publishDatagram(message); +var utilConfigProvider = __nccwpck_require__(6716); +var utilMiddleware = __nccwpck_require__(6324); +var utilEndpoints = __nccwpck_require__(9674); + +const ENV_USE_DUALSTACK_ENDPOINT = "AWS_USE_DUALSTACK_ENDPOINT"; +const CONFIG_USE_DUALSTACK_ENDPOINT = "use_dualstack_endpoint"; +const DEFAULT_USE_DUALSTACK_ENDPOINT = false; +const NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS = { + environmentVariableSelector: (env) => utilConfigProvider.booleanSelector(env, ENV_USE_DUALSTACK_ENDPOINT, utilConfigProvider.SelectorType.ENV), + configFileSelector: (profile) => utilConfigProvider.booleanSelector(profile, CONFIG_USE_DUALSTACK_ENDPOINT, utilConfigProvider.SelectorType.CONFIG), + default: false, }; -/** - * Publishes message to an agent. - * @param {Buffer} message JSON message to send to agent. - * @api private - */ -Publisher.prototype.publishDatagram = function(message) { - var self = this; - var client = this.getClient(); +const ENV_USE_FIPS_ENDPOINT = "AWS_USE_FIPS_ENDPOINT"; +const CONFIG_USE_FIPS_ENDPOINT = "use_fips_endpoint"; +const DEFAULT_USE_FIPS_ENDPOINT = false; +const NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS = { + environmentVariableSelector: (env) => utilConfigProvider.booleanSelector(env, ENV_USE_FIPS_ENDPOINT, utilConfigProvider.SelectorType.ENV), + configFileSelector: (profile) => utilConfigProvider.booleanSelector(profile, CONFIG_USE_FIPS_ENDPOINT, utilConfigProvider.SelectorType.CONFIG), + default: false, +}; - this.messagesInFlight++; - this.client.send(message, 0, message.length, this.port, this.address, function(err, bytes) { - if (--self.messagesInFlight <= 0) { - // destroy existing client so the event loop isn't kept open - self.destroyClient(); - } +const resolveCustomEndpointsConfig = (input) => { + const { tls, endpoint, urlParser, useDualstackEndpoint } = input; + return Object.assign(input, { + tls: tls ?? true, + endpoint: utilMiddleware.normalizeProvider(typeof endpoint === "string" ? urlParser(endpoint) : endpoint), + isCustomEndpoint: true, + useDualstackEndpoint: utilMiddleware.normalizeProvider(useDualstackEndpoint ?? false), }); }; -/** - * Returns an existing udp socket, or creates one if it doesn't already exist. - * @api private - */ -Publisher.prototype.getClient = function() { - if (!this.client) { - this.client = dgram.createSocket('udp4'); +const getEndpointFromRegion = async (input) => { + const { tls = true } = input; + const region = await input.region(); + const dnsHostRegex = new RegExp(/^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]{0,61}[a-zA-Z0-9])$/); + if (!dnsHostRegex.test(region)) { + throw new Error("Invalid region in client config"); } - return this.client; -}; - -/** - * Destroys the udp socket. - * @api private - */ -Publisher.prototype.destroyClient = function() { - if (this.client) { - this.client.close(); - this.client = void 0; + const useDualstackEndpoint = await input.useDualstackEndpoint(); + const useFipsEndpoint = await input.useFipsEndpoint(); + const { hostname } = (await input.regionInfoProvider(region, { useDualstackEndpoint, useFipsEndpoint })) ?? {}; + if (!hostname) { + throw new Error("Cannot resolve hostname from client config"); } + return input.urlParser(`${tls ? "https:" : "http:"}//${hostname}`); }; -module.exports = { - Publisher: Publisher +const resolveEndpointsConfig = (input) => { + const useDualstackEndpoint = utilMiddleware.normalizeProvider(input.useDualstackEndpoint ?? false); + const { endpoint, useFipsEndpoint, urlParser, tls } = input; + return Object.assign(input, { + tls: tls ?? true, + endpoint: endpoint + ? utilMiddleware.normalizeProvider(typeof endpoint === "string" ? urlParser(endpoint) : endpoint) + : () => getEndpointFromRegion({ ...input, useDualstackEndpoint, useFipsEndpoint }), + isCustomEndpoint: !!endpoint, + useDualstackEndpoint, + }); }; +const REGION_ENV_NAME = "AWS_REGION"; +const REGION_INI_NAME = "region"; +const NODE_REGION_CONFIG_OPTIONS = { + environmentVariableSelector: (env) => env[REGION_ENV_NAME], + configFileSelector: (profile) => profile[REGION_INI_NAME], + default: () => { + throw new Error("Region is missing"); + }, +}; +const NODE_REGION_CONFIG_FILE_OPTIONS = { + preferredFile: "credentials", +}; -/***/ }), +const validRegions = new Set(); +const checkRegion = (region, check = utilEndpoints.isValidHostLabel) => { + if (!validRegions.has(region) && !check(region)) { + if (region === "*") { + console.warn(`@smithy/config-resolver WARN - Please use the caller region instead of "*". See "sigv4a" in https://github.com/aws/aws-sdk-js-v3/blob/main/supplemental-docs/CLIENTS.md.`); + } + else { + throw new Error(`Region not accepted: region="${region}" is not a valid hostname component.`); + } + } + else { + validRegions.add(region); + } +}; -/***/ 1711: -/***/ (function(module, __unusedexports, __webpack_require__) { +const isFipsRegion = (region) => typeof region === "string" && (region.startsWith("fips-") || region.endsWith("-fips")); + +const getRealRegion = (region) => isFipsRegion(region) + ? ["fips-aws-global", "aws-fips"].includes(region) + ? "us-east-1" + : region.replace(/fips-(dkr-|prod-)?|-fips/, "") + : region; + +const resolveRegionConfig = (input) => { + const { region, useFipsEndpoint } = input; + if (!region) { + throw new Error("Region is missing"); + } + return Object.assign(input, { + region: async () => { + const providedRegion = typeof region === "function" ? await region() : region; + const realRegion = getRealRegion(providedRegion); + checkRegion(realRegion); + return realRegion; + }, + useFipsEndpoint: async () => { + const providedRegion = typeof region === "string" ? region : await region(); + if (isFipsRegion(providedRegion)) { + return true; + } + return typeof useFipsEndpoint !== "function" ? Promise.resolve(!!useFipsEndpoint) : useFipsEndpoint(); + }, + }); +}; -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +const getHostnameFromVariants = (variants = [], { useFipsEndpoint, useDualstackEndpoint }) => variants.find(({ tags }) => useFipsEndpoint === tags.includes("fips") && useDualstackEndpoint === tags.includes("dualstack"))?.hostname; -apiLoader.services['glue'] = {}; -AWS.Glue = Service.defineService('glue', ['2017-03-31']); -Object.defineProperty(apiLoader.services['glue'], '2017-03-31', { - get: function get() { - var model = __webpack_require__(6063); - model.paginators = __webpack_require__(2911).pagination; - return model; - }, - enumerable: true, - configurable: true -}); +const getResolvedHostname = (resolvedRegion, { regionHostname, partitionHostname }) => regionHostname + ? regionHostname + : partitionHostname + ? partitionHostname.replace("{region}", resolvedRegion) + : undefined; -module.exports = AWS.Glue; +const getResolvedPartition = (region, { partitionHash }) => Object.keys(partitionHash || {}).find((key) => partitionHash[key].regions.includes(region)) ?? "aws"; +const getResolvedSigningRegion = (hostname, { signingRegion, regionRegex, useFipsEndpoint }) => { + if (signingRegion) { + return signingRegion; + } + else if (useFipsEndpoint) { + const regionRegexJs = regionRegex.replace("\\\\", "\\").replace(/^\^/g, "\\.").replace(/\$$/g, "\\."); + const regionRegexmatchArray = hostname.match(regionRegexJs); + if (regionRegexmatchArray) { + return regionRegexmatchArray[0].slice(1, -1); + } + } +}; -/***/ }), +const getRegionInfo = (region, { useFipsEndpoint = false, useDualstackEndpoint = false, signingService, regionHash, partitionHash, }) => { + const partition = getResolvedPartition(region, { partitionHash }); + const resolvedRegion = region in regionHash ? region : partitionHash[partition]?.endpoint ?? region; + const hostnameOptions = { useFipsEndpoint, useDualstackEndpoint }; + const regionHostname = getHostnameFromVariants(regionHash[resolvedRegion]?.variants, hostnameOptions); + const partitionHostname = getHostnameFromVariants(partitionHash[partition]?.variants, hostnameOptions); + const hostname = getResolvedHostname(resolvedRegion, { regionHostname, partitionHostname }); + if (hostname === undefined) { + throw new Error(`Endpoint resolution failed for: ${{ resolvedRegion, useFipsEndpoint, useDualstackEndpoint }}`); + } + const signingRegion = getResolvedSigningRegion(hostname, { + signingRegion: regionHash[resolvedRegion]?.signingRegion, + regionRegex: partitionHash[partition].regionRegex, + useFipsEndpoint, + }); + return { + partition, + signingService, + hostname, + ...(signingRegion && { signingRegion }), + ...(regionHash[resolvedRegion]?.signingService && { + signingService: regionHash[resolvedRegion].signingService, + }), + }; +}; -/***/ 1713: -/***/ (function(module) { +exports.CONFIG_USE_DUALSTACK_ENDPOINT = CONFIG_USE_DUALSTACK_ENDPOINT; +exports.CONFIG_USE_FIPS_ENDPOINT = CONFIG_USE_FIPS_ENDPOINT; +exports.DEFAULT_USE_DUALSTACK_ENDPOINT = DEFAULT_USE_DUALSTACK_ENDPOINT; +exports.DEFAULT_USE_FIPS_ENDPOINT = DEFAULT_USE_FIPS_ENDPOINT; +exports.ENV_USE_DUALSTACK_ENDPOINT = ENV_USE_DUALSTACK_ENDPOINT; +exports.ENV_USE_FIPS_ENDPOINT = ENV_USE_FIPS_ENDPOINT; +exports.NODE_REGION_CONFIG_FILE_OPTIONS = NODE_REGION_CONFIG_FILE_OPTIONS; +exports.NODE_REGION_CONFIG_OPTIONS = NODE_REGION_CONFIG_OPTIONS; +exports.NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS = NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS; +exports.NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS = NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS; +exports.REGION_ENV_NAME = REGION_ENV_NAME; +exports.REGION_INI_NAME = REGION_INI_NAME; +exports.getRegionInfo = getRegionInfo; +exports.resolveCustomEndpointsConfig = resolveCustomEndpointsConfig; +exports.resolveEndpointsConfig = resolveEndpointsConfig; +exports.resolveRegionConfig = resolveRegionConfig; -module.exports = {"version":"2.0","metadata":{"apiVersion":"2019-12-04","endpointPrefix":"kinesisvideo","protocol":"rest-json","serviceAbbreviation":"Amazon Kinesis Video Signaling Channels","serviceFullName":"Amazon Kinesis Video Signaling Channels","serviceId":"Kinesis Video Signaling","signatureVersion":"v4","uid":"kinesis-video-signaling-2019-12-04"},"operations":{"GetIceServerConfig":{"http":{"requestUri":"/v1/get-ice-server-config"},"input":{"type":"structure","required":["ChannelARN"],"members":{"ChannelARN":{},"ClientId":{},"Service":{},"Username":{}}},"output":{"type":"structure","members":{"IceServerList":{"type":"list","member":{"type":"structure","members":{"Uris":{"type":"list","member":{}},"Username":{},"Password":{},"Ttl":{"type":"integer"}}}}}}},"SendAlexaOfferToMaster":{"http":{"requestUri":"/v1/send-alexa-offer-to-master"},"input":{"type":"structure","required":["ChannelARN","SenderClientId","MessagePayload"],"members":{"ChannelARN":{},"SenderClientId":{},"MessagePayload":{}}},"output":{"type":"structure","members":{"Answer":{}}}}},"shapes":{}}; /***/ }), -/***/ 1722: -/***/ (function(module) { - -/** - * Convert array of 16 byte values to UUID string format of the form: - * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX - */ -var byteToHex = []; -for (var i = 0; i < 256; ++i) { - byteToHex[i] = (i + 0x100).toString(16).substr(1); -} - -function bytesToUuid(buf, offset) { - var i = offset || 0; - var bth = byteToHex; - // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4 - return ([bth[buf[i++]], bth[buf[i++]], - bth[buf[i++]], bth[buf[i++]], '-', - bth[buf[i++]], bth[buf[i++]], '-', - bth[buf[i++]], bth[buf[i++]], '-', - bth[buf[i++]], bth[buf[i++]], '-', - bth[buf[i++]], bth[buf[i++]], - bth[buf[i++]], bth[buf[i++]], - bth[buf[i++]], bth[buf[i++]]]).join(''); -} - -module.exports = bytesToUuid; +/***/ 402: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { +"use strict"; -/***/ }), - -/***/ 1724: -/***/ (function(module) { -module.exports = {"version":"2.0","metadata":{"apiVersion":"2017-04-19","endpointPrefix":"codestar","jsonVersion":"1.1","protocol":"json","serviceAbbreviation":"CodeStar","serviceFullName":"AWS CodeStar","serviceId":"CodeStar","signatureVersion":"v4","targetPrefix":"CodeStar_20170419","uid":"codestar-2017-04-19"},"operations":{"AssociateTeamMember":{"input":{"type":"structure","required":["projectId","userArn","projectRole"],"members":{"projectId":{},"clientRequestToken":{},"userArn":{},"projectRole":{},"remoteAccessAllowed":{"type":"boolean"}}},"output":{"type":"structure","members":{"clientRequestToken":{}}}},"CreateProject":{"input":{"type":"structure","required":["name","id"],"members":{"name":{"shape":"S9"},"id":{},"description":{"shape":"Sa"},"clientRequestToken":{},"sourceCode":{"type":"list","member":{"type":"structure","required":["source","destination"],"members":{"source":{"type":"structure","required":["s3"],"members":{"s3":{"shape":"Se"}}},"destination":{"type":"structure","members":{"codeCommit":{"type":"structure","required":["name"],"members":{"name":{}}},"gitHub":{"type":"structure","required":["name","type","owner","privateRepository","issuesEnabled","token"],"members":{"name":{},"description":{},"type":{},"owner":{},"privateRepository":{"type":"boolean"},"issuesEnabled":{"type":"boolean"},"token":{"type":"string","sensitive":true}}}}}}}},"toolchain":{"type":"structure","required":["source"],"members":{"source":{"type":"structure","required":["s3"],"members":{"s3":{"shape":"Se"}}},"roleArn":{},"stackParameters":{"type":"map","key":{},"value":{"type":"string","sensitive":true}}}},"tags":{"shape":"Sx"}}},"output":{"type":"structure","required":["id","arn"],"members":{"id":{},"arn":{},"clientRequestToken":{},"projectTemplateId":{}}}},"CreateUserProfile":{"input":{"type":"structure","required":["userArn","displayName","emailAddress"],"members":{"userArn":{},"displayName":{"shape":"S14"},"emailAddress":{"shape":"S15"},"sshPublicKey":{}}},"output":{"type":"structure","required":["userArn"],"members":{"userArn":{},"displayName":{"shape":"S14"},"emailAddress":{"shape":"S15"},"sshPublicKey":{},"createdTimestamp":{"type":"timestamp"},"lastModifiedTimestamp":{"type":"timestamp"}}}},"DeleteProject":{"input":{"type":"structure","required":["id"],"members":{"id":{},"clientRequestToken":{},"deleteStack":{"type":"boolean"}}},"output":{"type":"structure","members":{"stackId":{},"projectArn":{}}}},"DeleteUserProfile":{"input":{"type":"structure","required":["userArn"],"members":{"userArn":{}}},"output":{"type":"structure","required":["userArn"],"members":{"userArn":{}}}},"DescribeProject":{"input":{"type":"structure","required":["id"],"members":{"id":{}}},"output":{"type":"structure","members":{"name":{"shape":"S9"},"id":{},"arn":{},"description":{"shape":"Sa"},"clientRequestToken":{},"createdTimeStamp":{"type":"timestamp"},"stackId":{},"projectTemplateId":{},"status":{"type":"structure","required":["state"],"members":{"state":{},"reason":{}}}}}},"DescribeUserProfile":{"input":{"type":"structure","required":["userArn"],"members":{"userArn":{}}},"output":{"type":"structure","required":["userArn","createdTimestamp","lastModifiedTimestamp"],"members":{"userArn":{},"displayName":{"shape":"S14"},"emailAddress":{"shape":"S15"},"sshPublicKey":{},"createdTimestamp":{"type":"timestamp"},"lastModifiedTimestamp":{"type":"timestamp"}}}},"DisassociateTeamMember":{"input":{"type":"structure","required":["projectId","userArn"],"members":{"projectId":{},"userArn":{}}},"output":{"type":"structure","members":{}}},"ListProjects":{"input":{"type":"structure","members":{"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","required":["projects"],"members":{"projects":{"type":"list","member":{"type":"structure","members":{"projectId":{},"projectArn":{}}}},"nextToken":{}}}},"ListResources":{"input":{"type":"structure","required":["projectId"],"members":{"projectId":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"resources":{"type":"list","member":{"type":"structure","required":["id"],"members":{"id":{}}}},"nextToken":{}}}},"ListTagsForProject":{"input":{"type":"structure","required":["id"],"members":{"id":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"tags":{"shape":"Sx"},"nextToken":{}}}},"ListTeamMembers":{"input":{"type":"structure","required":["projectId"],"members":{"projectId":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","required":["teamMembers"],"members":{"teamMembers":{"type":"list","member":{"type":"structure","required":["userArn","projectRole"],"members":{"userArn":{},"projectRole":{},"remoteAccessAllowed":{"type":"boolean"}}}},"nextToken":{}}}},"ListUserProfiles":{"input":{"type":"structure","members":{"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","required":["userProfiles"],"members":{"userProfiles":{"type":"list","member":{"type":"structure","members":{"userArn":{},"displayName":{"shape":"S14"},"emailAddress":{"shape":"S15"},"sshPublicKey":{}}}},"nextToken":{}}}},"TagProject":{"input":{"type":"structure","required":["id","tags"],"members":{"id":{},"tags":{"shape":"Sx"}}},"output":{"type":"structure","members":{"tags":{"shape":"Sx"}}}},"UntagProject":{"input":{"type":"structure","required":["id","tags"],"members":{"id":{},"tags":{"type":"list","member":{}}}},"output":{"type":"structure","members":{}}},"UpdateProject":{"input":{"type":"structure","required":["id"],"members":{"id":{},"name":{"shape":"S9"},"description":{"shape":"Sa"}}},"output":{"type":"structure","members":{}}},"UpdateTeamMember":{"input":{"type":"structure","required":["projectId","userArn"],"members":{"projectId":{},"userArn":{},"projectRole":{},"remoteAccessAllowed":{"type":"boolean"}}},"output":{"type":"structure","members":{"userArn":{},"projectRole":{},"remoteAccessAllowed":{"type":"boolean"}}}},"UpdateUserProfile":{"input":{"type":"structure","required":["userArn"],"members":{"userArn":{},"displayName":{"shape":"S14"},"emailAddress":{"shape":"S15"},"sshPublicKey":{}}},"output":{"type":"structure","required":["userArn"],"members":{"userArn":{},"displayName":{"shape":"S14"},"emailAddress":{"shape":"S15"},"sshPublicKey":{},"createdTimestamp":{"type":"timestamp"},"lastModifiedTimestamp":{"type":"timestamp"}}}}},"shapes":{"S9":{"type":"string","sensitive":true},"Sa":{"type":"string","sensitive":true},"Se":{"type":"structure","members":{"bucketName":{},"bucketKey":{}}},"Sx":{"type":"map","key":{},"value":{}},"S14":{"type":"string","sensitive":true},"S15":{"type":"string","sensitive":true}}}; +var types = __nccwpck_require__(690); +var utilMiddleware = __nccwpck_require__(6324); +var middlewareSerde = __nccwpck_require__(3255); +var protocolHttp = __nccwpck_require__(2356); +var protocols = __nccwpck_require__(3422); -/***/ }), +const getSmithyContext = (context) => context[types.SMITHY_CONTEXT_KEY] || (context[types.SMITHY_CONTEXT_KEY] = {}); -/***/ 1733: -/***/ (function(module, __unusedexports, __webpack_require__) { +const resolveAuthOptions = (candidateAuthOptions, authSchemePreference) => { + if (!authSchemePreference || authSchemePreference.length === 0) { + return candidateAuthOptions; + } + const preferredAuthOptions = []; + for (const preferredSchemeName of authSchemePreference) { + for (const candidateAuthOption of candidateAuthOptions) { + const candidateAuthSchemeName = candidateAuthOption.schemeId.split("#")[1]; + if (candidateAuthSchemeName === preferredSchemeName) { + preferredAuthOptions.push(candidateAuthOption); + } + } + } + for (const candidateAuthOption of candidateAuthOptions) { + if (!preferredAuthOptions.find(({ schemeId }) => schemeId === candidateAuthOption.schemeId)) { + preferredAuthOptions.push(candidateAuthOption); + } + } + return preferredAuthOptions; +}; -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +function convertHttpAuthSchemesToMap(httpAuthSchemes) { + const map = new Map(); + for (const scheme of httpAuthSchemes) { + map.set(scheme.schemeId, scheme); + } + return map; +} +const httpAuthSchemeMiddleware = (config, mwOptions) => (next, context) => async (args) => { + const options = config.httpAuthSchemeProvider(await mwOptions.httpAuthSchemeParametersProvider(config, context, args.input)); + const authSchemePreference = config.authSchemePreference ? await config.authSchemePreference() : []; + const resolvedOptions = resolveAuthOptions(options, authSchemePreference); + const authSchemes = convertHttpAuthSchemesToMap(config.httpAuthSchemes); + const smithyContext = utilMiddleware.getSmithyContext(context); + const failureReasons = []; + for (const option of resolvedOptions) { + const scheme = authSchemes.get(option.schemeId); + if (!scheme) { + failureReasons.push(`HttpAuthScheme \`${option.schemeId}\` was not enabled for this service.`); + continue; + } + const identityProvider = scheme.identityProvider(await mwOptions.identityProviderConfigProvider(config)); + if (!identityProvider) { + failureReasons.push(`HttpAuthScheme \`${option.schemeId}\` did not have an IdentityProvider configured.`); + continue; + } + const { identityProperties = {}, signingProperties = {} } = option.propertiesExtractor?.(config, context) || {}; + option.identityProperties = Object.assign(option.identityProperties || {}, identityProperties); + option.signingProperties = Object.assign(option.signingProperties || {}, signingProperties); + smithyContext.selectedHttpAuthScheme = { + httpAuthOption: option, + identity: await identityProvider(option.identityProperties), + signer: scheme.signer, + }; + break; + } + if (!smithyContext.selectedHttpAuthScheme) { + throw new Error(failureReasons.join("\n")); + } + return next(args); +}; -apiLoader.services['sts'] = {}; -AWS.STS = Service.defineService('sts', ['2011-06-15']); -__webpack_require__(3861); -Object.defineProperty(apiLoader.services['sts'], '2011-06-15', { - get: function get() { - var model = __webpack_require__(9715); - model.paginators = __webpack_require__(7262).pagination; - return model; - }, - enumerable: true, - configurable: true +const httpAuthSchemeEndpointRuleSetMiddlewareOptions = { + step: "serialize", + tags: ["HTTP_AUTH_SCHEME"], + name: "httpAuthSchemeMiddleware", + override: true, + relation: "before", + toMiddleware: "endpointV2Middleware", +}; +const getHttpAuthSchemeEndpointRuleSetPlugin = (config, { httpAuthSchemeParametersProvider, identityProviderConfigProvider, }) => ({ + applyToStack: (clientStack) => { + clientStack.addRelativeTo(httpAuthSchemeMiddleware(config, { + httpAuthSchemeParametersProvider, + identityProviderConfigProvider, + }), httpAuthSchemeEndpointRuleSetMiddlewareOptions); + }, }); -module.exports = AWS.STS; - +const httpAuthSchemeMiddlewareOptions = { + step: "serialize", + tags: ["HTTP_AUTH_SCHEME"], + name: "httpAuthSchemeMiddleware", + override: true, + relation: "before", + toMiddleware: middlewareSerde.serializerMiddlewareOption.name, +}; +const getHttpAuthSchemePlugin = (config, { httpAuthSchemeParametersProvider, identityProviderConfigProvider, }) => ({ + applyToStack: (clientStack) => { + clientStack.addRelativeTo(httpAuthSchemeMiddleware(config, { + httpAuthSchemeParametersProvider, + identityProviderConfigProvider, + }), httpAuthSchemeMiddlewareOptions); + }, +}); -/***/ }), +const defaultErrorHandler = (signingProperties) => (error) => { + throw error; +}; +const defaultSuccessHandler = (httpResponse, signingProperties) => { }; +const httpSigningMiddleware = (config) => (next, context) => async (args) => { + if (!protocolHttp.HttpRequest.isInstance(args.request)) { + return next(args); + } + const smithyContext = utilMiddleware.getSmithyContext(context); + const scheme = smithyContext.selectedHttpAuthScheme; + if (!scheme) { + throw new Error(`No HttpAuthScheme was selected: unable to sign request`); + } + const { httpAuthOption: { signingProperties = {} }, identity, signer, } = scheme; + const output = await next({ + ...args, + request: await signer.sign(args.request, identity, signingProperties), + }).catch((signer.errorHandler || defaultErrorHandler)(signingProperties)); + (signer.successHandler || defaultSuccessHandler)(output.response, signingProperties); + return output; +}; -/***/ 1762: -/***/ (function(module, __unusedexports, __webpack_require__) { +const httpSigningMiddlewareOptions = { + step: "finalizeRequest", + tags: ["HTTP_SIGNING"], + name: "httpSigningMiddleware", + aliases: ["apiKeyMiddleware", "tokenMiddleware", "awsAuthMiddleware"], + override: true, + relation: "after", + toMiddleware: "retryMiddleware", +}; +const getHttpSigningPlugin = (config) => ({ + applyToStack: (clientStack) => { + clientStack.addRelativeTo(httpSigningMiddleware(), httpSigningMiddlewareOptions); + }, +}); -var AWS = __webpack_require__(395); +const normalizeProvider = (input) => { + if (typeof input === "function") + return input; + const promisified = Promise.resolve(input); + return () => promisified; +}; -/** - * Resolve client-side monitoring configuration from either environmental variables - * or shared config file. Configurations from environmental variables have higher priority - * than those from shared config file. The resolver will try to read the shared config file - * no matter whether the AWS_SDK_LOAD_CONFIG variable is set. - * @api private - */ -function resolveMonitoringConfig() { - var config = { - port: undefined, - clientId: undefined, - enabled: undefined, - host: undefined - }; - if (fromEnvironment(config) || fromConfigFile(config)) return toJSType(config); - return toJSType(config); +const makePagedClientRequest = async (CommandCtor, client, input, withCommand = (_) => _, ...args) => { + let command = new CommandCtor(input); + command = withCommand(command) ?? command; + return await client.send(command, ...args); +}; +function createPaginator(ClientCtor, CommandCtor, inputTokenName, outputTokenName, pageSizeTokenName) { + return async function* paginateOperation(config, input, ...additionalArguments) { + const _input = input; + let token = config.startingToken ?? _input[inputTokenName]; + let hasNext = true; + let page; + while (hasNext) { + _input[inputTokenName] = token; + if (pageSizeTokenName) { + _input[pageSizeTokenName] = _input[pageSizeTokenName] ?? config.pageSize; + } + if (config.client instanceof ClientCtor) { + page = await makePagedClientRequest(CommandCtor, config.client, input, config.withCommand, ...additionalArguments); + } + else { + throw new Error(`Invalid client, expected instance of ${ClientCtor.name}`); + } + yield page; + const prevToken = token; + token = get(page, outputTokenName); + hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken)); + } + return undefined; + }; } +const get = (fromObject, path) => { + let cursor = fromObject; + const pathComponents = path.split("."); + for (const step of pathComponents) { + if (!cursor || typeof cursor !== "object") { + return undefined; + } + cursor = cursor[step]; + } + return cursor; +}; -/** - * Resolve configurations from environmental variables. - * @param {object} client side monitoring config object needs to be resolved - * @returns {boolean} whether resolving configurations is done - * @api private - */ -function fromEnvironment(config) { - config.port = config.port || process.env.AWS_CSM_PORT; - config.enabled = config.enabled || process.env.AWS_CSM_ENABLED; - config.clientId = config.clientId || process.env.AWS_CSM_CLIENT_ID; - config.host = config.host || process.env.AWS_CSM_HOST; - return config.port && config.enabled && config.clientId && config.host || - ['false', '0'].indexOf(config.enabled) >= 0; //no need to read shared config file if explicitely disabled +function setFeature(context, feature, value) { + if (!context.__smithy_context) { + context.__smithy_context = { + features: {}, + }; + } + else if (!context.__smithy_context.features) { + context.__smithy_context.features = {}; + } + context.__smithy_context.features[feature] = value; } -/** - * Resolve cofigurations from shared config file with specified role name - * @param {object} client side monitoring config object needs to be resolved - * @returns {boolean} whether resolving configurations is done - * @api private - */ -function fromConfigFile(config) { - var sharedFileConfig; - try { - var configFile = AWS.util.iniLoader.loadFrom({ - isConfig: true, - filename: process.env[AWS.util.sharedConfigFileEnv] - }); - var sharedFileConfig = configFile[ - process.env.AWS_PROFILE || AWS.util.defaultProfile - ]; - } catch (err) { - return false; - } - if (!sharedFileConfig) return config; - config.port = config.port || sharedFileConfig.csm_port; - config.enabled = config.enabled || sharedFileConfig.csm_enabled; - config.clientId = config.clientId || sharedFileConfig.csm_client_id; - config.host = config.host || sharedFileConfig.csm_host; - return config.port && config.enabled && config.clientId && config.host; +class DefaultIdentityProviderConfig { + authSchemes = new Map(); + constructor(config) { + for (const [key, value] of Object.entries(config)) { + if (value !== undefined) { + this.authSchemes.set(key, value); + } + } + } + getIdentityProvider(schemeId) { + return this.authSchemes.get(schemeId); + } } -/** - * Transfer the resolved configuration value to proper types: port as number, enabled - * as boolean and clientId as string. The 'enabled' flag is valued to false when set - * to 'false' or '0'. - * @param {object} resolved client side monitoring config - * @api private - */ -function toJSType(config) { - //config.XXX is either undefined or string - var falsyNotations = ['false', '0', undefined]; - if (!config.enabled || falsyNotations.indexOf(config.enabled.toLowerCase()) >= 0) { - config.enabled = false; - } else { - config.enabled = true; - } - config.port = config.port ? parseInt(config.port, 10) : undefined; - return config; +class HttpApiKeyAuthSigner { + async sign(httpRequest, identity, signingProperties) { + if (!signingProperties) { + throw new Error("request could not be signed with `apiKey` since the `name` and `in` signer properties are missing"); + } + if (!signingProperties.name) { + throw new Error("request could not be signed with `apiKey` since the `name` signer property is missing"); + } + if (!signingProperties.in) { + throw new Error("request could not be signed with `apiKey` since the `in` signer property is missing"); + } + if (!identity.apiKey) { + throw new Error("request could not be signed with `apiKey` since the `apiKey` is not defined"); + } + const clonedRequest = protocolHttp.HttpRequest.clone(httpRequest); + if (signingProperties.in === types.HttpApiKeyAuthLocation.QUERY) { + clonedRequest.query[signingProperties.name] = identity.apiKey; + } + else if (signingProperties.in === types.HttpApiKeyAuthLocation.HEADER) { + clonedRequest.headers[signingProperties.name] = signingProperties.scheme + ? `${signingProperties.scheme} ${identity.apiKey}` + : identity.apiKey; + } + else { + throw new Error("request can only be signed with `apiKey` locations `query` or `header`, " + + "but found: `" + + signingProperties.in + + "`"); + } + return clonedRequest; + } } -module.exports = resolveMonitoringConfig; - - -/***/ }), - -/***/ 1764: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2010-08-01","endpointPrefix":"monitoring","protocol":"query","serviceAbbreviation":"CloudWatch","serviceFullName":"Amazon CloudWatch","serviceId":"CloudWatch","signatureVersion":"v4","uid":"monitoring-2010-08-01","xmlNamespace":"http://monitoring.amazonaws.com/doc/2010-08-01/"},"operations":{"DeleteAlarms":{"input":{"type":"structure","required":["AlarmNames"],"members":{"AlarmNames":{"shape":"S2"}}}},"DeleteAnomalyDetector":{"input":{"type":"structure","required":["Namespace","MetricName","Stat"],"members":{"Namespace":{},"MetricName":{},"Dimensions":{"shape":"S7"},"Stat":{}}},"output":{"resultWrapper":"DeleteAnomalyDetectorResult","type":"structure","members":{}}},"DeleteDashboards":{"input":{"type":"structure","required":["DashboardNames"],"members":{"DashboardNames":{"type":"list","member":{}}}},"output":{"resultWrapper":"DeleteDashboardsResult","type":"structure","members":{}}},"DeleteInsightRules":{"input":{"type":"structure","required":["RuleNames"],"members":{"RuleNames":{"shape":"Si"}}},"output":{"resultWrapper":"DeleteInsightRulesResult","type":"structure","members":{"Failures":{"shape":"Sl"}}}},"DescribeAlarmHistory":{"input":{"type":"structure","members":{"AlarmName":{},"AlarmTypes":{"shape":"Ss"},"HistoryItemType":{},"StartDate":{"type":"timestamp"},"EndDate":{"type":"timestamp"},"MaxRecords":{"type":"integer"},"NextToken":{},"ScanBy":{}}},"output":{"resultWrapper":"DescribeAlarmHistoryResult","type":"structure","members":{"AlarmHistoryItems":{"type":"list","member":{"type":"structure","members":{"AlarmName":{},"AlarmType":{},"Timestamp":{"type":"timestamp"},"HistoryItemType":{},"HistorySummary":{},"HistoryData":{}}}},"NextToken":{}}}},"DescribeAlarms":{"input":{"type":"structure","members":{"AlarmNames":{"shape":"S2"},"AlarmNamePrefix":{},"AlarmTypes":{"shape":"Ss"},"ChildrenOfAlarmName":{},"ParentsOfAlarmName":{},"StateValue":{},"ActionPrefix":{},"MaxRecords":{"type":"integer"},"NextToken":{}}},"output":{"resultWrapper":"DescribeAlarmsResult","type":"structure","members":{"CompositeAlarms":{"type":"list","member":{"type":"structure","members":{"ActionsEnabled":{"type":"boolean"},"AlarmActions":{"shape":"S1c"},"AlarmArn":{},"AlarmConfigurationUpdatedTimestamp":{"type":"timestamp"},"AlarmDescription":{},"AlarmName":{},"AlarmRule":{},"InsufficientDataActions":{"shape":"S1c"},"OKActions":{"shape":"S1c"},"StateReason":{},"StateReasonData":{},"StateUpdatedTimestamp":{"type":"timestamp"},"StateValue":{}},"xmlOrder":["ActionsEnabled","AlarmActions","AlarmArn","AlarmConfigurationUpdatedTimestamp","AlarmDescription","AlarmName","AlarmRule","InsufficientDataActions","OKActions","StateReason","StateReasonData","StateUpdatedTimestamp","StateValue"]}},"MetricAlarms":{"shape":"S1j"},"NextToken":{}}}},"DescribeAlarmsForMetric":{"input":{"type":"structure","required":["MetricName","Namespace"],"members":{"MetricName":{},"Namespace":{},"Statistic":{},"ExtendedStatistic":{},"Dimensions":{"shape":"S7"},"Period":{"type":"integer"},"Unit":{}}},"output":{"resultWrapper":"DescribeAlarmsForMetricResult","type":"structure","members":{"MetricAlarms":{"shape":"S1j"}}}},"DescribeAnomalyDetectors":{"input":{"type":"structure","members":{"NextToken":{},"MaxResults":{"type":"integer"},"Namespace":{},"MetricName":{},"Dimensions":{"shape":"S7"}}},"output":{"resultWrapper":"DescribeAnomalyDetectorsResult","type":"structure","members":{"AnomalyDetectors":{"type":"list","member":{"type":"structure","members":{"Namespace":{},"MetricName":{},"Dimensions":{"shape":"S7"},"Stat":{},"Configuration":{"shape":"S2b"},"StateValue":{}}}},"NextToken":{}}}},"DescribeInsightRules":{"input":{"type":"structure","members":{"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"resultWrapper":"DescribeInsightRulesResult","type":"structure","members":{"NextToken":{},"InsightRules":{"type":"list","member":{"type":"structure","required":["Name","State","Schema","Definition"],"members":{"Name":{},"State":{},"Schema":{},"Definition":{}}}}}}},"DisableAlarmActions":{"input":{"type":"structure","required":["AlarmNames"],"members":{"AlarmNames":{"shape":"S2"}}}},"DisableInsightRules":{"input":{"type":"structure","required":["RuleNames"],"members":{"RuleNames":{"shape":"Si"}}},"output":{"resultWrapper":"DisableInsightRulesResult","type":"structure","members":{"Failures":{"shape":"Sl"}}}},"EnableAlarmActions":{"input":{"type":"structure","required":["AlarmNames"],"members":{"AlarmNames":{"shape":"S2"}}}},"EnableInsightRules":{"input":{"type":"structure","required":["RuleNames"],"members":{"RuleNames":{"shape":"Si"}}},"output":{"resultWrapper":"EnableInsightRulesResult","type":"structure","members":{"Failures":{"shape":"Sl"}}}},"GetDashboard":{"input":{"type":"structure","required":["DashboardName"],"members":{"DashboardName":{}}},"output":{"resultWrapper":"GetDashboardResult","type":"structure","members":{"DashboardArn":{},"DashboardBody":{},"DashboardName":{}}}},"GetInsightRuleReport":{"input":{"type":"structure","required":["RuleName","StartTime","EndTime","Period"],"members":{"RuleName":{},"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"Period":{"type":"integer"},"MaxContributorCount":{"type":"integer"},"Metrics":{"type":"list","member":{}},"OrderBy":{}}},"output":{"resultWrapper":"GetInsightRuleReportResult","type":"structure","members":{"KeyLabels":{"type":"list","member":{}},"AggregationStatistic":{},"AggregateValue":{"type":"double"},"ApproximateUniqueCount":{"type":"long"},"Contributors":{"type":"list","member":{"type":"structure","required":["Keys","ApproximateAggregateValue","Datapoints"],"members":{"Keys":{"type":"list","member":{}},"ApproximateAggregateValue":{"type":"double"},"Datapoints":{"type":"list","member":{"type":"structure","required":["Timestamp","ApproximateValue"],"members":{"Timestamp":{"type":"timestamp"},"ApproximateValue":{"type":"double"}}}}}}},"MetricDatapoints":{"type":"list","member":{"type":"structure","required":["Timestamp"],"members":{"Timestamp":{"type":"timestamp"},"UniqueContributors":{"type":"double"},"MaxContributorValue":{"type":"double"},"SampleCount":{"type":"double"},"Average":{"type":"double"},"Sum":{"type":"double"},"Minimum":{"type":"double"},"Maximum":{"type":"double"}}}}}}},"GetMetricData":{"input":{"type":"structure","required":["MetricDataQueries","StartTime","EndTime"],"members":{"MetricDataQueries":{"shape":"S1v"},"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"NextToken":{},"ScanBy":{},"MaxDatapoints":{"type":"integer"}}},"output":{"resultWrapper":"GetMetricDataResult","type":"structure","members":{"MetricDataResults":{"type":"list","member":{"type":"structure","members":{"Id":{},"Label":{},"Timestamps":{"type":"list","member":{"type":"timestamp"}},"Values":{"type":"list","member":{"type":"double"}},"StatusCode":{},"Messages":{"shape":"S3q"}}}},"NextToken":{},"Messages":{"shape":"S3q"}}}},"GetMetricStatistics":{"input":{"type":"structure","required":["Namespace","MetricName","StartTime","EndTime","Period"],"members":{"Namespace":{},"MetricName":{},"Dimensions":{"shape":"S7"},"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"Period":{"type":"integer"},"Statistics":{"type":"list","member":{}},"ExtendedStatistics":{"type":"list","member":{}},"Unit":{}}},"output":{"resultWrapper":"GetMetricStatisticsResult","type":"structure","members":{"Label":{},"Datapoints":{"type":"list","member":{"type":"structure","members":{"Timestamp":{"type":"timestamp"},"SampleCount":{"type":"double"},"Average":{"type":"double"},"Sum":{"type":"double"},"Minimum":{"type":"double"},"Maximum":{"type":"double"},"Unit":{},"ExtendedStatistics":{"type":"map","key":{},"value":{"type":"double"}}},"xmlOrder":["Timestamp","SampleCount","Average","Sum","Minimum","Maximum","Unit","ExtendedStatistics"]}}}}},"GetMetricWidgetImage":{"input":{"type":"structure","required":["MetricWidget"],"members":{"MetricWidget":{},"OutputFormat":{}}},"output":{"resultWrapper":"GetMetricWidgetImageResult","type":"structure","members":{"MetricWidgetImage":{"type":"blob"}}}},"ListDashboards":{"input":{"type":"structure","members":{"DashboardNamePrefix":{},"NextToken":{}}},"output":{"resultWrapper":"ListDashboardsResult","type":"structure","members":{"DashboardEntries":{"type":"list","member":{"type":"structure","members":{"DashboardName":{},"DashboardArn":{},"LastModified":{"type":"timestamp"},"Size":{"type":"long"}}}},"NextToken":{}}}},"ListMetrics":{"input":{"type":"structure","members":{"Namespace":{},"MetricName":{},"Dimensions":{"type":"list","member":{"type":"structure","required":["Name"],"members":{"Name":{},"Value":{}}}},"NextToken":{},"RecentlyActive":{}}},"output":{"resultWrapper":"ListMetricsResult","type":"structure","members":{"Metrics":{"type":"list","member":{"shape":"S1z"}},"NextToken":{}},"xmlOrder":["Metrics","NextToken"]}},"ListTagsForResource":{"input":{"type":"structure","required":["ResourceARN"],"members":{"ResourceARN":{}}},"output":{"resultWrapper":"ListTagsForResourceResult","type":"structure","members":{"Tags":{"shape":"S4m"}}}},"PutAnomalyDetector":{"input":{"type":"structure","required":["Namespace","MetricName","Stat"],"members":{"Namespace":{},"MetricName":{},"Dimensions":{"shape":"S7"},"Stat":{},"Configuration":{"shape":"S2b"}}},"output":{"resultWrapper":"PutAnomalyDetectorResult","type":"structure","members":{}}},"PutCompositeAlarm":{"input":{"type":"structure","required":["AlarmName","AlarmRule"],"members":{"ActionsEnabled":{"type":"boolean"},"AlarmActions":{"shape":"S1c"},"AlarmDescription":{},"AlarmName":{},"AlarmRule":{},"InsufficientDataActions":{"shape":"S1c"},"OKActions":{"shape":"S1c"},"Tags":{"shape":"S4m"}}}},"PutDashboard":{"input":{"type":"structure","required":["DashboardName","DashboardBody"],"members":{"DashboardName":{},"DashboardBody":{}}},"output":{"resultWrapper":"PutDashboardResult","type":"structure","members":{"DashboardValidationMessages":{"type":"list","member":{"type":"structure","members":{"DataPath":{},"Message":{}}}}}}},"PutInsightRule":{"input":{"type":"structure","required":["RuleName","RuleDefinition"],"members":{"RuleName":{},"RuleState":{},"RuleDefinition":{},"Tags":{"shape":"S4m"}}},"output":{"resultWrapper":"PutInsightRuleResult","type":"structure","members":{}}},"PutMetricAlarm":{"input":{"type":"structure","required":["AlarmName","EvaluationPeriods","ComparisonOperator"],"members":{"AlarmName":{},"AlarmDescription":{},"ActionsEnabled":{"type":"boolean"},"OKActions":{"shape":"S1c"},"AlarmActions":{"shape":"S1c"},"InsufficientDataActions":{"shape":"S1c"},"MetricName":{},"Namespace":{},"Statistic":{},"ExtendedStatistic":{},"Dimensions":{"shape":"S7"},"Period":{"type":"integer"},"Unit":{},"EvaluationPeriods":{"type":"integer"},"DatapointsToAlarm":{"type":"integer"},"Threshold":{"type":"double"},"ComparisonOperator":{},"TreatMissingData":{},"EvaluateLowSampleCountPercentile":{},"Metrics":{"shape":"S1v"},"Tags":{"shape":"S4m"},"ThresholdMetricId":{}}}},"PutMetricData":{"input":{"type":"structure","required":["Namespace","MetricData"],"members":{"Namespace":{},"MetricData":{"type":"list","member":{"type":"structure","required":["MetricName"],"members":{"MetricName":{},"Dimensions":{"shape":"S7"},"Timestamp":{"type":"timestamp"},"Value":{"type":"double"},"StatisticValues":{"type":"structure","required":["SampleCount","Sum","Minimum","Maximum"],"members":{"SampleCount":{"type":"double"},"Sum":{"type":"double"},"Minimum":{"type":"double"},"Maximum":{"type":"double"}}},"Values":{"type":"list","member":{"type":"double"}},"Counts":{"type":"list","member":{"type":"double"}},"Unit":{},"StorageResolution":{"type":"integer"}}}}}}},"SetAlarmState":{"input":{"type":"structure","required":["AlarmName","StateValue","StateReason"],"members":{"AlarmName":{},"StateValue":{},"StateReason":{},"StateReasonData":{}}}},"TagResource":{"input":{"type":"structure","required":["ResourceARN","Tags"],"members":{"ResourceARN":{},"Tags":{"shape":"S4m"}}},"output":{"resultWrapper":"TagResourceResult","type":"structure","members":{}}},"UntagResource":{"input":{"type":"structure","required":["ResourceARN","TagKeys"],"members":{"ResourceARN":{},"TagKeys":{"type":"list","member":{}}}},"output":{"resultWrapper":"UntagResourceResult","type":"structure","members":{}}}},"shapes":{"S2":{"type":"list","member":{}},"S7":{"type":"list","member":{"type":"structure","required":["Name","Value"],"members":{"Name":{},"Value":{}},"xmlOrder":["Name","Value"]}},"Si":{"type":"list","member":{}},"Sl":{"type":"list","member":{"type":"structure","members":{"FailureResource":{},"ExceptionType":{},"FailureCode":{},"FailureDescription":{}}}},"Ss":{"type":"list","member":{}},"S1c":{"type":"list","member":{}},"S1j":{"type":"list","member":{"type":"structure","members":{"AlarmName":{},"AlarmArn":{},"AlarmDescription":{},"AlarmConfigurationUpdatedTimestamp":{"type":"timestamp"},"ActionsEnabled":{"type":"boolean"},"OKActions":{"shape":"S1c"},"AlarmActions":{"shape":"S1c"},"InsufficientDataActions":{"shape":"S1c"},"StateValue":{},"StateReason":{},"StateReasonData":{},"StateUpdatedTimestamp":{"type":"timestamp"},"MetricName":{},"Namespace":{},"Statistic":{},"ExtendedStatistic":{},"Dimensions":{"shape":"S7"},"Period":{"type":"integer"},"Unit":{},"EvaluationPeriods":{"type":"integer"},"DatapointsToAlarm":{"type":"integer"},"Threshold":{"type":"double"},"ComparisonOperator":{},"TreatMissingData":{},"EvaluateLowSampleCountPercentile":{},"Metrics":{"shape":"S1v"},"ThresholdMetricId":{}},"xmlOrder":["AlarmName","AlarmArn","AlarmDescription","AlarmConfigurationUpdatedTimestamp","ActionsEnabled","OKActions","AlarmActions","InsufficientDataActions","StateValue","StateReason","StateReasonData","StateUpdatedTimestamp","MetricName","Namespace","Statistic","Dimensions","Period","Unit","EvaluationPeriods","Threshold","ComparisonOperator","ExtendedStatistic","TreatMissingData","EvaluateLowSampleCountPercentile","DatapointsToAlarm","Metrics","ThresholdMetricId"]}},"S1v":{"type":"list","member":{"type":"structure","required":["Id"],"members":{"Id":{},"MetricStat":{"type":"structure","required":["Metric","Period","Stat"],"members":{"Metric":{"shape":"S1z"},"Period":{"type":"integer"},"Stat":{},"Unit":{}}},"Expression":{},"Label":{},"ReturnData":{"type":"boolean"},"Period":{"type":"integer"}}}},"S1z":{"type":"structure","members":{"Namespace":{},"MetricName":{},"Dimensions":{"shape":"S7"}},"xmlOrder":["Namespace","MetricName","Dimensions"]},"S2b":{"type":"structure","members":{"ExcludedTimeRanges":{"type":"list","member":{"type":"structure","required":["StartTime","EndTime"],"members":{"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"}},"xmlOrder":["StartTime","EndTime"]}},"MetricTimezone":{}}},"S3q":{"type":"list","member":{"type":"structure","members":{"Code":{},"Value":{}}}},"S4m":{"type":"list","member":{"type":"structure","required":["Key","Value"],"members":{"Key":{},"Value":{}}}}}}; - -/***/ }), - -/***/ 1777: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['s3'] = {}; -AWS.S3 = Service.defineService('s3', ['2006-03-01']); -__webpack_require__(6016); -Object.defineProperty(apiLoader.services['s3'], '2006-03-01', { - get: function get() { - var model = __webpack_require__(7696); - model.paginators = __webpack_require__(707).pagination; - model.waiters = __webpack_require__(1306).waiters; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.S3; - - -/***/ }), - -/***/ 1786: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['ssooidc'] = {}; -AWS.SSOOIDC = Service.defineService('ssooidc', ['2019-06-10']); -Object.defineProperty(apiLoader.services['ssooidc'], '2019-06-10', { - get: function get() { - var model = __webpack_require__(1802); - model.paginators = __webpack_require__(9468).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.SSOOIDC; - - -/***/ }), - -/***/ 1791: -/***/ (function(module, __unusedexports, __webpack_require__) { - -var AWS = __webpack_require__(395); -var inherit = AWS.util.inherit; - -/** - * @api private - */ -AWS.Signers.V3 = inherit(AWS.Signers.RequestSigner, { - addAuthorization: function addAuthorization(credentials, date) { - - var datetime = AWS.util.date.rfc822(date); +class HttpBearerAuthSigner { + async sign(httpRequest, identity, signingProperties) { + const clonedRequest = protocolHttp.HttpRequest.clone(httpRequest); + if (!identity.token) { + throw new Error("request could not be signed with `token` since the `token` is not defined"); + } + clonedRequest.headers["Authorization"] = `Bearer ${identity.token}`; + return clonedRequest; + } +} - this.request.headers['X-Amz-Date'] = datetime; +class NoAuthSigner { + async sign(httpRequest, identity, signingProperties) { + return httpRequest; + } +} - if (credentials.sessionToken) { - this.request.headers['x-amz-security-token'] = credentials.sessionToken; +const createIsIdentityExpiredFunction = (expirationMs) => function isIdentityExpired(identity) { + return doesIdentityRequireRefresh(identity) && identity.expiration.getTime() - Date.now() < expirationMs; +}; +const EXPIRATION_MS = 300_000; +const isIdentityExpired = createIsIdentityExpiredFunction(EXPIRATION_MS); +const doesIdentityRequireRefresh = (identity) => identity.expiration !== undefined; +const memoizeIdentityProvider = (provider, isExpired, requiresRefresh) => { + if (provider === undefined) { + return undefined; + } + const normalizedProvider = typeof provider !== "function" ? async () => Promise.resolve(provider) : provider; + let resolved; + let pending; + let hasResult; + let isConstant = false; + const coalesceProvider = async (options) => { + if (!pending) { + pending = normalizedProvider(options); + } + try { + resolved = await pending; + hasResult = true; + isConstant = false; + } + finally { + pending = undefined; + } + return resolved; + }; + if (isExpired === undefined) { + return async (options) => { + if (!hasResult || options?.forceRefresh) { + resolved = await coalesceProvider(options); + } + return resolved; + }; } + return async (options) => { + if (!hasResult || options?.forceRefresh) { + resolved = await coalesceProvider(options); + } + if (isConstant) { + return resolved; + } + if (!requiresRefresh(resolved)) { + isConstant = true; + return resolved; + } + if (isExpired(resolved)) { + await coalesceProvider(options); + return resolved; + } + return resolved; + }; +}; - this.request.headers['X-Amzn-Authorization'] = - this.authorization(credentials, datetime); +Object.defineProperty(exports, "requestBuilder", ({ + enumerable: true, + get: function () { return protocols.requestBuilder; } +})); +exports.DefaultIdentityProviderConfig = DefaultIdentityProviderConfig; +exports.EXPIRATION_MS = EXPIRATION_MS; +exports.HttpApiKeyAuthSigner = HttpApiKeyAuthSigner; +exports.HttpBearerAuthSigner = HttpBearerAuthSigner; +exports.NoAuthSigner = NoAuthSigner; +exports.createIsIdentityExpiredFunction = createIsIdentityExpiredFunction; +exports.createPaginator = createPaginator; +exports.doesIdentityRequireRefresh = doesIdentityRequireRefresh; +exports.getHttpAuthSchemeEndpointRuleSetPlugin = getHttpAuthSchemeEndpointRuleSetPlugin; +exports.getHttpAuthSchemePlugin = getHttpAuthSchemePlugin; +exports.getHttpSigningPlugin = getHttpSigningPlugin; +exports.getSmithyContext = getSmithyContext; +exports.httpAuthSchemeEndpointRuleSetMiddlewareOptions = httpAuthSchemeEndpointRuleSetMiddlewareOptions; +exports.httpAuthSchemeMiddleware = httpAuthSchemeMiddleware; +exports.httpAuthSchemeMiddlewareOptions = httpAuthSchemeMiddlewareOptions; +exports.httpSigningMiddleware = httpSigningMiddleware; +exports.httpSigningMiddlewareOptions = httpSigningMiddlewareOptions; +exports.isIdentityExpired = isIdentityExpired; +exports.memoizeIdentityProvider = memoizeIdentityProvider; +exports.normalizeProvider = normalizeProvider; +exports.setFeature = setFeature; - }, - authorization: function authorization(credentials) { - return 'AWS3 ' + - 'AWSAccessKeyId=' + credentials.accessKeyId + ',' + - 'Algorithm=HmacSHA256,' + - 'SignedHeaders=' + this.signedHeaders() + ',' + - 'Signature=' + this.signature(credentials); - }, +/***/ }), - signedHeaders: function signedHeaders() { - var headers = []; - AWS.util.arrayEach(this.headersToSign(), function iterator(h) { - headers.push(h.toLowerCase()); - }); - return headers.sort().join(';'); - }, +/***/ 4645: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - canonicalHeaders: function canonicalHeaders() { - var headers = this.request.headers; - var parts = []; - AWS.util.arrayEach(this.headersToSign(), function iterator(h) { - parts.push(h.toLowerCase().trim() + ':' + String(headers[h]).trim()); - }); - return parts.sort().join('\n') + '\n'; - }, +"use strict"; - headersToSign: function headersToSign() { - var headers = []; - AWS.util.each(this.request.headers, function iterator(k) { - if (k === 'Host' || k === 'Content-Encoding' || k.match(/^X-Amz/i)) { - headers.push(k); - } - }); - return headers; - }, - signature: function signature(credentials) { - return AWS.util.crypto.hmac(credentials.secretAccessKey, this.stringToSign(), 'base64'); - }, +var serde = __nccwpck_require__(2430); +var utilUtf8 = __nccwpck_require__(1577); +var protocols = __nccwpck_require__(3422); +var protocolHttp = __nccwpck_require__(2356); +var utilBodyLengthBrowser = __nccwpck_require__(2098); +var schema = __nccwpck_require__(6890); +var utilMiddleware = __nccwpck_require__(6324); +var utilBase64 = __nccwpck_require__(8385); + +const majorUint64 = 0; +const majorNegativeInt64 = 1; +const majorUnstructuredByteString = 2; +const majorUtf8String = 3; +const majorList = 4; +const majorMap = 5; +const majorTag = 6; +const majorSpecial = 7; +const specialFalse = 20; +const specialTrue = 21; +const specialNull = 22; +const specialUndefined = 23; +const extendedOneByte = 24; +const extendedFloat16 = 25; +const extendedFloat32 = 26; +const extendedFloat64 = 27; +const minorIndefinite = 31; +function alloc(size) { + return typeof Buffer !== "undefined" ? Buffer.alloc(size) : new Uint8Array(size); +} +const tagSymbol = Symbol("@smithy/core/cbor::tagSymbol"); +function tag(data) { + data[tagSymbol] = true; + return data; +} - stringToSign: function stringToSign() { - var parts = []; - parts.push(this.request.method); - parts.push('/'); - parts.push(''); - parts.push(this.canonicalHeaders()); - parts.push(this.request.body); - return AWS.util.crypto.sha256(parts.join('\n')); - } - -}); - -/** - * @api private - */ -module.exports = AWS.Signers.V3; - - -/***/ }), - -/***/ 1797: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2017-03-31","endpointPrefix":"lakeformation","jsonVersion":"1.1","protocol":"json","serviceFullName":"AWS Lake Formation","serviceId":"LakeFormation","signatureVersion":"v4","signingName":"lakeformation","targetPrefix":"AWSLakeFormation","uid":"lakeformation-2017-03-31"},"operations":{"BatchGrantPermissions":{"input":{"type":"structure","required":["Entries"],"members":{"CatalogId":{},"Entries":{"shape":"S3"}}},"output":{"type":"structure","members":{"Failures":{"shape":"Sm"}}}},"BatchRevokePermissions":{"input":{"type":"structure","required":["Entries"],"members":{"CatalogId":{},"Entries":{"shape":"S3"}}},"output":{"type":"structure","members":{"Failures":{"shape":"Sm"}}}},"DeregisterResource":{"input":{"type":"structure","required":["ResourceArn"],"members":{"ResourceArn":{}}},"output":{"type":"structure","members":{}}},"DescribeResource":{"input":{"type":"structure","required":["ResourceArn"],"members":{"ResourceArn":{}}},"output":{"type":"structure","members":{"ResourceInfo":{"shape":"Sw"}}}},"GetDataLakeSettings":{"input":{"type":"structure","members":{"CatalogId":{}}},"output":{"type":"structure","members":{"DataLakeSettings":{"shape":"S11"}}}},"GetEffectivePermissionsForPath":{"input":{"type":"structure","required":["ResourceArn"],"members":{"CatalogId":{},"ResourceArn":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"Permissions":{"shape":"S1a"},"NextToken":{}}}},"GrantPermissions":{"input":{"type":"structure","required":["Principal","Resource","Permissions"],"members":{"CatalogId":{},"Principal":{"shape":"S6"},"Resource":{"shape":"S8"},"Permissions":{"shape":"Sj"},"PermissionsWithGrantOption":{"shape":"Sj"}}},"output":{"type":"structure","members":{}}},"ListPermissions":{"input":{"type":"structure","members":{"CatalogId":{},"Principal":{"shape":"S6"},"ResourceType":{},"Resource":{"shape":"S8"},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"PrincipalResourcePermissions":{"shape":"S1a"},"NextToken":{}}}},"ListResources":{"input":{"type":"structure","members":{"FilterConditionList":{"type":"list","member":{"type":"structure","members":{"Field":{},"ComparisonOperator":{},"StringValueList":{"type":"list","member":{}}}}},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"ResourceInfoList":{"type":"list","member":{"shape":"Sw"}},"NextToken":{}}}},"PutDataLakeSettings":{"input":{"type":"structure","required":["DataLakeSettings"],"members":{"CatalogId":{},"DataLakeSettings":{"shape":"S11"}}},"output":{"type":"structure","members":{}}},"RegisterResource":{"input":{"type":"structure","required":["ResourceArn"],"members":{"ResourceArn":{},"UseServiceLinkedRole":{"type":"boolean"},"RoleArn":{}}},"output":{"type":"structure","members":{}}},"RevokePermissions":{"input":{"type":"structure","required":["Principal","Resource","Permissions"],"members":{"CatalogId":{},"Principal":{"shape":"S6"},"Resource":{"shape":"S8"},"Permissions":{"shape":"Sj"},"PermissionsWithGrantOption":{"shape":"Sj"}}},"output":{"type":"structure","members":{}}},"UpdateResource":{"input":{"type":"structure","required":["RoleArn","ResourceArn"],"members":{"RoleArn":{},"ResourceArn":{}}},"output":{"type":"structure","members":{}}}},"shapes":{"S3":{"type":"list","member":{"shape":"S4"}},"S4":{"type":"structure","required":["Id"],"members":{"Id":{},"Principal":{"shape":"S6"},"Resource":{"shape":"S8"},"Permissions":{"shape":"Sj"},"PermissionsWithGrantOption":{"shape":"Sj"}}},"S6":{"type":"structure","members":{"DataLakePrincipalIdentifier":{}}},"S8":{"type":"structure","members":{"Catalog":{"type":"structure","members":{}},"Database":{"type":"structure","required":["Name"],"members":{"CatalogId":{},"Name":{}}},"Table":{"type":"structure","required":["DatabaseName"],"members":{"CatalogId":{},"DatabaseName":{},"Name":{},"TableWildcard":{"type":"structure","members":{}}}},"TableWithColumns":{"type":"structure","required":["DatabaseName","Name"],"members":{"CatalogId":{},"DatabaseName":{},"Name":{},"ColumnNames":{"shape":"Sf"},"ColumnWildcard":{"type":"structure","members":{"ExcludedColumnNames":{"shape":"Sf"}}}}},"DataLocation":{"type":"structure","required":["ResourceArn"],"members":{"CatalogId":{},"ResourceArn":{}}}}},"Sf":{"type":"list","member":{}},"Sj":{"type":"list","member":{}},"Sm":{"type":"list","member":{"type":"structure","members":{"RequestEntry":{"shape":"S4"},"Error":{"type":"structure","members":{"ErrorCode":{},"ErrorMessage":{}}}}}},"Sw":{"type":"structure","members":{"ResourceArn":{},"RoleArn":{},"LastModified":{"type":"timestamp"}}},"S11":{"type":"structure","members":{"DataLakeAdmins":{"type":"list","member":{"shape":"S6"}},"CreateDatabaseDefaultPermissions":{"shape":"S13"},"CreateTableDefaultPermissions":{"shape":"S13"},"TrustedResourceOwners":{"type":"list","member":{}}}},"S13":{"type":"list","member":{"type":"structure","members":{"Principal":{"shape":"S6"},"Permissions":{"shape":"Sj"}}}},"S1a":{"type":"list","member":{"type":"structure","members":{"Principal":{"shape":"S6"},"Resource":{"shape":"S8"},"Permissions":{"shape":"Sj"},"PermissionsWithGrantOption":{"shape":"Sj"}}}}}}; - -/***/ }), - -/***/ 1798: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['forecastservice'] = {}; -AWS.ForecastService = Service.defineService('forecastservice', ['2018-06-26']); -Object.defineProperty(apiLoader.services['forecastservice'], '2018-06-26', { - get: function get() { - var model = __webpack_require__(5723); - model.paginators = __webpack_require__(5532).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.ForecastService; - - -/***/ }), - -/***/ 1802: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2019-06-10","endpointPrefix":"oidc","jsonVersion":"1.1","protocol":"rest-json","serviceAbbreviation":"SSO OIDC","serviceFullName":"AWS SSO OIDC","serviceId":"SSO OIDC","signatureVersion":"v4","signingName":"awsssooidc","uid":"sso-oidc-2019-06-10"},"operations":{"CreateToken":{"http":{"requestUri":"/token"},"input":{"type":"structure","required":["clientId","clientSecret","grantType","deviceCode"],"members":{"clientId":{},"clientSecret":{},"grantType":{},"deviceCode":{},"code":{},"refreshToken":{},"scope":{"shape":"S8"},"redirectUri":{}}},"output":{"type":"structure","members":{"accessToken":{},"tokenType":{},"expiresIn":{"type":"integer"},"refreshToken":{},"idToken":{}}},"authtype":"none"},"RegisterClient":{"http":{"requestUri":"/client/register"},"input":{"type":"structure","required":["clientName","clientType"],"members":{"clientName":{},"clientType":{},"scopes":{"shape":"S8"}}},"output":{"type":"structure","members":{"clientId":{},"clientSecret":{},"clientIdIssuedAt":{"type":"long"},"clientSecretExpiresAt":{"type":"long"},"authorizationEndpoint":{},"tokenEndpoint":{}}},"authtype":"none"},"StartDeviceAuthorization":{"http":{"requestUri":"/device_authorization"},"input":{"type":"structure","required":["clientId","clientSecret","startUrl"],"members":{"clientId":{},"clientSecret":{},"startUrl":{}}},"output":{"type":"structure","members":{"deviceCode":{},"userCode":{},"verificationUri":{},"verificationUriComplete":{},"expiresIn":{"type":"integer"},"interval":{"type":"integer"}}},"authtype":"none"}},"shapes":{"S8":{"type":"list","member":{}}}}; - -/***/ }), - -/***/ 1809: -/***/ (function(module, __unusedexports, __webpack_require__) { - -"use strict"; - - -var Type = __webpack_require__(4945); - -function resolveYamlNull(data) { - if (data === null) return true; - - var max = data.length; - - return (max === 1 && data === '~') || - (max === 4 && (data === 'null' || data === 'Null' || data === 'NULL')); +const USE_TEXT_DECODER = typeof TextDecoder !== "undefined"; +const USE_BUFFER$1 = typeof Buffer !== "undefined"; +let payload = alloc(0); +let dataView$1 = new DataView(payload.buffer, payload.byteOffset, payload.byteLength); +const textDecoder = USE_TEXT_DECODER ? new TextDecoder() : null; +let _offset = 0; +function setPayload(bytes) { + payload = bytes; + dataView$1 = new DataView(payload.buffer, payload.byteOffset, payload.byteLength); } - -function constructYamlNull() { - return null; +function decode(at, to) { + if (at >= to) { + throw new Error("unexpected end of (decode) payload."); + } + const major = (payload[at] & 0b1110_0000) >> 5; + const minor = payload[at] & 0b0001_1111; + switch (major) { + case majorUint64: + case majorNegativeInt64: + case majorTag: + let unsignedInt; + let offset; + if (minor < 24) { + unsignedInt = minor; + offset = 1; + } + else { + switch (minor) { + case extendedOneByte: + case extendedFloat16: + case extendedFloat32: + case extendedFloat64: + const countLength = minorValueToArgumentLength[minor]; + const countOffset = (countLength + 1); + offset = countOffset; + if (to - at < countOffset) { + throw new Error(`countLength ${countLength} greater than remaining buf len.`); + } + const countIndex = at + 1; + if (countLength === 1) { + unsignedInt = payload[countIndex]; + } + else if (countLength === 2) { + unsignedInt = dataView$1.getUint16(countIndex); + } + else if (countLength === 4) { + unsignedInt = dataView$1.getUint32(countIndex); + } + else { + unsignedInt = dataView$1.getBigUint64(countIndex); + } + break; + default: + throw new Error(`unexpected minor value ${minor}.`); + } + } + if (major === majorUint64) { + _offset = offset; + return castBigInt(unsignedInt); + } + else if (major === majorNegativeInt64) { + let negativeInt; + if (typeof unsignedInt === "bigint") { + negativeInt = BigInt(-1) - unsignedInt; + } + else { + negativeInt = -1 - unsignedInt; + } + _offset = offset; + return castBigInt(negativeInt); + } + else { + if (minor === 2 || minor === 3) { + const length = decodeCount(at + offset, to); + let b = BigInt(0); + const start = at + offset + _offset; + for (let i = start; i < start + length; ++i) { + b = (b << BigInt(8)) | BigInt(payload[i]); + } + _offset = offset + _offset + length; + return minor === 3 ? -b - BigInt(1) : b; + } + else if (minor === 4) { + const decimalFraction = decode(at + offset, to); + const [exponent, mantissa] = decimalFraction; + const normalizer = mantissa < 0 ? -1 : 1; + const mantissaStr = "0".repeat(Math.abs(exponent) + 1) + String(BigInt(normalizer) * BigInt(mantissa)); + let numericString; + const sign = mantissa < 0 ? "-" : ""; + numericString = + exponent === 0 + ? mantissaStr + : mantissaStr.slice(0, mantissaStr.length + exponent) + "." + mantissaStr.slice(exponent); + numericString = numericString.replace(/^0+/g, ""); + if (numericString === "") { + numericString = "0"; + } + if (numericString[0] === ".") { + numericString = "0" + numericString; + } + numericString = sign + numericString; + _offset = offset + _offset; + return serde.nv(numericString); + } + else { + const value = decode(at + offset, to); + const valueOffset = _offset; + _offset = offset + valueOffset; + return tag({ tag: castBigInt(unsignedInt), value }); + } + } + case majorUtf8String: + case majorMap: + case majorList: + case majorUnstructuredByteString: + if (minor === minorIndefinite) { + switch (major) { + case majorUtf8String: + return decodeUtf8StringIndefinite(at, to); + case majorMap: + return decodeMapIndefinite(at, to); + case majorList: + return decodeListIndefinite(at, to); + case majorUnstructuredByteString: + return decodeUnstructuredByteStringIndefinite(at, to); + } + } + else { + switch (major) { + case majorUtf8String: + return decodeUtf8String(at, to); + case majorMap: + return decodeMap(at, to); + case majorList: + return decodeList(at, to); + case majorUnstructuredByteString: + return decodeUnstructuredByteString(at, to); + } + } + default: + return decodeSpecial(at, to); + } } - -function isNull(object) { - return object === null; +function bytesToUtf8(bytes, at, to) { + if (USE_BUFFER$1 && bytes.constructor?.name === "Buffer") { + return bytes.toString("utf-8", at, to); + } + if (textDecoder) { + return textDecoder.decode(bytes.subarray(at, to)); + } + return utilUtf8.toUtf8(bytes.subarray(at, to)); } - -module.exports = new Type('tag:yaml.org,2002:null', { - kind: 'scalar', - resolve: resolveYamlNull, - construct: constructYamlNull, - predicate: isNull, - represent: { - canonical: function () { return '~'; }, - lowercase: function () { return 'null'; }, - uppercase: function () { return 'NULL'; }, - camelcase: function () { return 'Null'; } - }, - defaultStyle: 'lowercase' -}); - - -/***/ }), - -/***/ 1818: -/***/ (function(module, __unusedexports, __webpack_require__) { - -var AWS = __webpack_require__(395); -var os = __webpack_require__(2087); -var path = __webpack_require__(5622); - -function parseFile(filename, isConfig) { - var content = AWS.util.ini.parse(AWS.util.readFileSync(filename)); - var tmpContent = {}; - Object.keys(content).forEach(function(profileName) { - var profileContent = content[profileName]; - profileName = isConfig ? profileName.replace(/^profile\s/, '') : profileName; - Object.defineProperty(tmpContent, profileName, { - value: profileContent, - enumerable: true - }); - }); - return tmpContent; +function demote(bigInteger) { + const num = Number(bigInteger); + if (num < Number.MIN_SAFE_INTEGER || Number.MAX_SAFE_INTEGER < num) { + console.warn(new Error(`@smithy/core/cbor - truncating BigInt(${bigInteger}) to ${num} with loss of precision.`)); + } + return num; } - -/** - * Ini file loader class the same as that used in the SDK. It loads and - * parses config and credentials files in .ini format and cache the content - * to assure files are only read once. - * Note that calling operations on the instance instantiated from this class - * won't affect the behavior of SDK since SDK uses an internal singleton of - * this class. - * @!macro nobrowser - */ -AWS.IniLoader = AWS.util.inherit({ - constructor: function IniLoader() { - this.resolvedProfiles = {}; - }, - - /** Remove all cached files. Used after config files are updated. */ - clearCachedFiles: function clearCachedFiles() { - this.resolvedProfiles = {}; - }, - -/** - * Load configurations from config/credentials files and cache them - * for later use. If no file is specified it will try to load default - * files. - * @param options [map] information describing the file - * @option options filename [String] ('~/.aws/credentials' or defined by - * AWS_SHARED_CREDENTIALS_FILE process env var or '~/.aws/config' if - * isConfig is set to true) - * path to the file to be read. - * @option options isConfig [Boolean] (false) True to read config file. - * @return [map] object containing contents from file in key-value - * pairs. - */ - loadFrom: function loadFrom(options) { - options = options || {}; - var isConfig = options.isConfig === true; - var filename = options.filename || this.getDefaultFilePath(isConfig); - if (!this.resolvedProfiles[filename]) { - var fileContent = this.parseFile(filename, isConfig); - Object.defineProperty(this.resolvedProfiles, filename, { value: fileContent }); - } - return this.resolvedProfiles[filename]; - }, - - /** - * @api private - */ - parseFile: parseFile, - - /** - * @api private - */ - getDefaultFilePath: function getDefaultFilePath(isConfig) { - return path.join( - this.getHomeDir(), - '.aws', - isConfig ? 'config' : 'credentials' - ); - }, - - /** - * @api private - */ - getHomeDir: function getHomeDir() { - var env = process.env; - var home = env.HOME || - env.USERPROFILE || - (env.HOMEPATH ? ((env.HOMEDRIVE || 'C:/') + env.HOMEPATH) : null); - - if (home) { - return home; +const minorValueToArgumentLength = { + [extendedOneByte]: 1, + [extendedFloat16]: 2, + [extendedFloat32]: 4, + [extendedFloat64]: 8, +}; +function bytesToFloat16(a, b) { + const sign = a >> 7; + const exponent = (a & 0b0111_1100) >> 2; + const fraction = ((a & 0b0000_0011) << 8) | b; + const scalar = sign === 0 ? 1 : -1; + let exponentComponent; + let summation; + if (exponent === 0b00000) { + if (fraction === 0b00000_00000) { + return 0; + } + else { + exponentComponent = Math.pow(2, 1 - 15); + summation = 0; + } } - - if (typeof os.homedir === 'function') { - return os.homedir(); + else if (exponent === 0b11111) { + if (fraction === 0b00000_00000) { + return scalar * Infinity; + } + else { + return NaN; + } } - - throw AWS.util.error( - new Error('Cannot load credentials, HOME path not set') - ); - } -}); - -var IniLoader = AWS.IniLoader; - -module.exports = { - IniLoader: IniLoader, - parseFile: parseFile, -}; - - -/***/ }), - -/***/ 1836: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['budgets'] = {}; -AWS.Budgets = Service.defineService('budgets', ['2016-10-20']); -Object.defineProperty(apiLoader.services['budgets'], '2016-10-20', { - get: function get() { - var model = __webpack_require__(2261); - model.paginators = __webpack_require__(422).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.Budgets; - - -/***/ }), - -/***/ 1841: -/***/ (function(module) { - -module.exports = {"pagination":{"GetApiKeys":{"input_token":"position","limit_key":"limit","output_token":"position","result_key":"items"},"GetBasePathMappings":{"input_token":"position","limit_key":"limit","output_token":"position","result_key":"items"},"GetClientCertificates":{"input_token":"position","limit_key":"limit","output_token":"position","result_key":"items"},"GetDeployments":{"input_token":"position","limit_key":"limit","output_token":"position","result_key":"items"},"GetDomainNames":{"input_token":"position","limit_key":"limit","output_token":"position","result_key":"items"},"GetModels":{"input_token":"position","limit_key":"limit","output_token":"position","result_key":"items"},"GetResources":{"input_token":"position","limit_key":"limit","output_token":"position","result_key":"items"},"GetRestApis":{"input_token":"position","limit_key":"limit","output_token":"position","result_key":"items"},"GetUsage":{"input_token":"position","limit_key":"limit","output_token":"position","result_key":"items"},"GetUsagePlanKeys":{"input_token":"position","limit_key":"limit","output_token":"position","result_key":"items"},"GetUsagePlans":{"input_token":"position","limit_key":"limit","output_token":"position","result_key":"items"},"GetVpcLinks":{"input_token":"position","limit_key":"limit","output_token":"position","result_key":"items"}}}; - -/***/ }), - -/***/ 1854: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2019-12-02","endpointPrefix":"imagebuilder","jsonVersion":"1.1","protocol":"rest-json","serviceAbbreviation":"imagebuilder","serviceFullName":"EC2 Image Builder","serviceId":"imagebuilder","signatureVersion":"v4","signingName":"imagebuilder","uid":"imagebuilder-2019-12-02"},"operations":{"CancelImageCreation":{"http":{"method":"PUT","requestUri":"/CancelImageCreation"},"input":{"type":"structure","required":["imageBuildVersionArn","clientToken"],"members":{"imageBuildVersionArn":{},"clientToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"requestId":{},"clientToken":{},"imageBuildVersionArn":{}}}},"CreateComponent":{"http":{"method":"PUT","requestUri":"/CreateComponent"},"input":{"type":"structure","required":["name","semanticVersion","platform","clientToken"],"members":{"name":{},"semanticVersion":{},"description":{},"changeDescription":{},"platform":{},"supportedOsVersions":{"shape":"Sa"},"data":{},"uri":{},"kmsKeyId":{},"tags":{"shape":"Se"},"clientToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"requestId":{},"clientToken":{},"componentBuildVersionArn":{}}}},"CreateDistributionConfiguration":{"http":{"method":"PUT","requestUri":"/CreateDistributionConfiguration"},"input":{"type":"structure","required":["name","distributions","clientToken"],"members":{"name":{},"description":{},"distributions":{"shape":"Sk"},"tags":{"shape":"Se"},"clientToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"requestId":{},"clientToken":{},"distributionConfigurationArn":{}}}},"CreateImage":{"http":{"method":"PUT","requestUri":"/CreateImage"},"input":{"type":"structure","required":["imageRecipeArn","infrastructureConfigurationArn","clientToken"],"members":{"imageRecipeArn":{},"distributionConfigurationArn":{},"infrastructureConfigurationArn":{},"imageTestsConfiguration":{"shape":"Sy"},"enhancedImageMetadataEnabled":{"type":"boolean"},"tags":{"shape":"Se"},"clientToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"requestId":{},"clientToken":{},"imageBuildVersionArn":{}}}},"CreateImagePipeline":{"http":{"method":"PUT","requestUri":"/CreateImagePipeline"},"input":{"type":"structure","required":["name","imageRecipeArn","infrastructureConfigurationArn","clientToken"],"members":{"name":{},"description":{},"imageRecipeArn":{},"infrastructureConfigurationArn":{},"distributionConfigurationArn":{},"imageTestsConfiguration":{"shape":"Sy"},"enhancedImageMetadataEnabled":{"type":"boolean"},"schedule":{"shape":"S13"},"status":{},"tags":{"shape":"Se"},"clientToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"requestId":{},"clientToken":{},"imagePipelineArn":{}}}},"CreateImageRecipe":{"http":{"method":"PUT","requestUri":"/CreateImageRecipe"},"input":{"type":"structure","required":["name","semanticVersion","components","parentImage","clientToken"],"members":{"name":{},"description":{},"semanticVersion":{},"components":{"shape":"S19"},"parentImage":{},"blockDeviceMappings":{"shape":"S1c"},"tags":{"shape":"Se"},"workingDirectory":{},"clientToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"requestId":{},"clientToken":{},"imageRecipeArn":{}}}},"CreateInfrastructureConfiguration":{"http":{"method":"PUT","requestUri":"/CreateInfrastructureConfiguration"},"input":{"type":"structure","required":["name","instanceProfileName","clientToken"],"members":{"name":{},"description":{},"instanceTypes":{"shape":"S1l"},"instanceProfileName":{},"securityGroupIds":{"shape":"S1n"},"subnetId":{},"logging":{"shape":"S1o"},"keyPair":{},"terminateInstanceOnFailure":{"type":"boolean"},"snsTopicArn":{},"resourceTags":{"shape":"S1r"},"tags":{"shape":"Se"},"clientToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"requestId":{},"clientToken":{},"infrastructureConfigurationArn":{}}}},"DeleteComponent":{"http":{"method":"DELETE","requestUri":"/DeleteComponent"},"input":{"type":"structure","required":["componentBuildVersionArn"],"members":{"componentBuildVersionArn":{"location":"querystring","locationName":"componentBuildVersionArn"}}},"output":{"type":"structure","members":{"requestId":{},"componentBuildVersionArn":{}}}},"DeleteDistributionConfiguration":{"http":{"method":"DELETE","requestUri":"/DeleteDistributionConfiguration"},"input":{"type":"structure","required":["distributionConfigurationArn"],"members":{"distributionConfigurationArn":{"location":"querystring","locationName":"distributionConfigurationArn"}}},"output":{"type":"structure","members":{"requestId":{},"distributionConfigurationArn":{}}}},"DeleteImage":{"http":{"method":"DELETE","requestUri":"/DeleteImage"},"input":{"type":"structure","required":["imageBuildVersionArn"],"members":{"imageBuildVersionArn":{"location":"querystring","locationName":"imageBuildVersionArn"}}},"output":{"type":"structure","members":{"requestId":{},"imageBuildVersionArn":{}}}},"DeleteImagePipeline":{"http":{"method":"DELETE","requestUri":"/DeleteImagePipeline"},"input":{"type":"structure","required":["imagePipelineArn"],"members":{"imagePipelineArn":{"location":"querystring","locationName":"imagePipelineArn"}}},"output":{"type":"structure","members":{"requestId":{},"imagePipelineArn":{}}}},"DeleteImageRecipe":{"http":{"method":"DELETE","requestUri":"/DeleteImageRecipe"},"input":{"type":"structure","required":["imageRecipeArn"],"members":{"imageRecipeArn":{"location":"querystring","locationName":"imageRecipeArn"}}},"output":{"type":"structure","members":{"requestId":{},"imageRecipeArn":{}}}},"DeleteInfrastructureConfiguration":{"http":{"method":"DELETE","requestUri":"/DeleteInfrastructureConfiguration"},"input":{"type":"structure","required":["infrastructureConfigurationArn"],"members":{"infrastructureConfigurationArn":{"location":"querystring","locationName":"infrastructureConfigurationArn"}}},"output":{"type":"structure","members":{"requestId":{},"infrastructureConfigurationArn":{}}}},"GetComponent":{"http":{"method":"GET","requestUri":"/GetComponent"},"input":{"type":"structure","required":["componentBuildVersionArn"],"members":{"componentBuildVersionArn":{"location":"querystring","locationName":"componentBuildVersionArn"}}},"output":{"type":"structure","members":{"requestId":{},"component":{"type":"structure","members":{"arn":{},"name":{},"version":{},"description":{},"changeDescription":{},"type":{},"platform":{},"supportedOsVersions":{"shape":"Sa"},"owner":{},"data":{},"kmsKeyId":{},"encrypted":{"type":"boolean"},"dateCreated":{},"tags":{"shape":"Se"}}}}}},"GetComponentPolicy":{"http":{"method":"GET","requestUri":"/GetComponentPolicy"},"input":{"type":"structure","required":["componentArn"],"members":{"componentArn":{"location":"querystring","locationName":"componentArn"}}},"output":{"type":"structure","members":{"requestId":{},"policy":{}}}},"GetDistributionConfiguration":{"http":{"method":"GET","requestUri":"/GetDistributionConfiguration"},"input":{"type":"structure","required":["distributionConfigurationArn"],"members":{"distributionConfigurationArn":{"location":"querystring","locationName":"distributionConfigurationArn"}}},"output":{"type":"structure","members":{"requestId":{},"distributionConfiguration":{"shape":"S2h"}}}},"GetImage":{"http":{"method":"GET","requestUri":"/GetImage"},"input":{"type":"structure","required":["imageBuildVersionArn"],"members":{"imageBuildVersionArn":{"location":"querystring","locationName":"imageBuildVersionArn"}}},"output":{"type":"structure","members":{"requestId":{},"image":{"type":"structure","members":{"arn":{},"name":{},"version":{},"platform":{},"enhancedImageMetadataEnabled":{"type":"boolean"},"osVersion":{},"state":{"shape":"S2n"},"imageRecipe":{"shape":"S2p"},"sourcePipelineName":{},"sourcePipelineArn":{},"infrastructureConfiguration":{"shape":"S2q"},"distributionConfiguration":{"shape":"S2h"},"imageTestsConfiguration":{"shape":"Sy"},"dateCreated":{},"outputResources":{"shape":"S2r"},"tags":{"shape":"Se"}}}}}},"GetImagePipeline":{"http":{"method":"GET","requestUri":"/GetImagePipeline"},"input":{"type":"structure","required":["imagePipelineArn"],"members":{"imagePipelineArn":{"location":"querystring","locationName":"imagePipelineArn"}}},"output":{"type":"structure","members":{"requestId":{},"imagePipeline":{"shape":"S2w"}}}},"GetImagePolicy":{"http":{"method":"GET","requestUri":"/GetImagePolicy"},"input":{"type":"structure","required":["imageArn"],"members":{"imageArn":{"location":"querystring","locationName":"imageArn"}}},"output":{"type":"structure","members":{"requestId":{},"policy":{}}}},"GetImageRecipe":{"http":{"method":"GET","requestUri":"/GetImageRecipe"},"input":{"type":"structure","required":["imageRecipeArn"],"members":{"imageRecipeArn":{"location":"querystring","locationName":"imageRecipeArn"}}},"output":{"type":"structure","members":{"requestId":{},"imageRecipe":{"shape":"S2p"}}}},"GetImageRecipePolicy":{"http":{"method":"GET","requestUri":"/GetImageRecipePolicy"},"input":{"type":"structure","required":["imageRecipeArn"],"members":{"imageRecipeArn":{"location":"querystring","locationName":"imageRecipeArn"}}},"output":{"type":"structure","members":{"requestId":{},"policy":{}}}},"GetInfrastructureConfiguration":{"http":{"method":"GET","requestUri":"/GetInfrastructureConfiguration"},"input":{"type":"structure","required":["infrastructureConfigurationArn"],"members":{"infrastructureConfigurationArn":{"location":"querystring","locationName":"infrastructureConfigurationArn"}}},"output":{"type":"structure","members":{"requestId":{},"infrastructureConfiguration":{"shape":"S2q"}}}},"ImportComponent":{"http":{"method":"PUT","requestUri":"/ImportComponent"},"input":{"type":"structure","required":["name","semanticVersion","type","format","platform","clientToken"],"members":{"name":{},"semanticVersion":{},"description":{},"changeDescription":{},"type":{},"format":{},"platform":{},"data":{},"uri":{},"kmsKeyId":{},"tags":{"shape":"Se"},"clientToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"requestId":{},"clientToken":{},"componentBuildVersionArn":{}}}},"ListComponentBuildVersions":{"http":{"requestUri":"/ListComponentBuildVersions"},"input":{"type":"structure","required":["componentVersionArn"],"members":{"componentVersionArn":{},"maxResults":{"type":"integer"},"nextToken":{}}},"output":{"type":"structure","members":{"requestId":{},"componentSummaryList":{"type":"list","member":{"type":"structure","members":{"arn":{},"name":{},"version":{},"platform":{},"supportedOsVersions":{"shape":"Sa"},"type":{},"owner":{},"description":{},"changeDescription":{},"dateCreated":{},"tags":{"shape":"Se"}}}},"nextToken":{}}}},"ListComponents":{"http":{"requestUri":"/ListComponents"},"input":{"type":"structure","members":{"owner":{},"filters":{"shape":"S3g"},"maxResults":{"type":"integer"},"nextToken":{}}},"output":{"type":"structure","members":{"requestId":{},"componentVersionList":{"type":"list","member":{"type":"structure","members":{"arn":{},"name":{},"version":{},"description":{},"platform":{},"supportedOsVersions":{"shape":"Sa"},"type":{},"owner":{},"dateCreated":{}}}},"nextToken":{}}}},"ListDistributionConfigurations":{"http":{"requestUri":"/ListDistributionConfigurations"},"input":{"type":"structure","members":{"filters":{"shape":"S3g"},"maxResults":{"type":"integer"},"nextToken":{}}},"output":{"type":"structure","members":{"requestId":{},"distributionConfigurationSummaryList":{"type":"list","member":{"type":"structure","members":{"arn":{},"name":{},"description":{},"dateCreated":{},"dateUpdated":{},"tags":{"shape":"Se"}}}},"nextToken":{}}}},"ListImageBuildVersions":{"http":{"requestUri":"/ListImageBuildVersions"},"input":{"type":"structure","required":["imageVersionArn"],"members":{"imageVersionArn":{},"filters":{"shape":"S3g"},"maxResults":{"type":"integer"},"nextToken":{}}},"output":{"type":"structure","members":{"requestId":{},"imageSummaryList":{"shape":"S3v"},"nextToken":{}}}},"ListImagePipelineImages":{"http":{"requestUri":"/ListImagePipelineImages"},"input":{"type":"structure","required":["imagePipelineArn"],"members":{"imagePipelineArn":{},"filters":{"shape":"S3g"},"maxResults":{"type":"integer"},"nextToken":{}}},"output":{"type":"structure","members":{"requestId":{},"imageSummaryList":{"shape":"S3v"},"nextToken":{}}}},"ListImagePipelines":{"http":{"requestUri":"/ListImagePipelines"},"input":{"type":"structure","members":{"filters":{"shape":"S3g"},"maxResults":{"type":"integer"},"nextToken":{}}},"output":{"type":"structure","members":{"requestId":{},"imagePipelineList":{"type":"list","member":{"shape":"S2w"}},"nextToken":{}}}},"ListImageRecipes":{"http":{"requestUri":"/ListImageRecipes"},"input":{"type":"structure","members":{"owner":{},"filters":{"shape":"S3g"},"maxResults":{"type":"integer"},"nextToken":{}}},"output":{"type":"structure","members":{"requestId":{},"imageRecipeSummaryList":{"type":"list","member":{"type":"structure","members":{"arn":{},"name":{},"platform":{},"owner":{},"parentImage":{},"dateCreated":{},"tags":{"shape":"Se"}}}},"nextToken":{}}}},"ListImages":{"http":{"requestUri":"/ListImages"},"input":{"type":"structure","members":{"owner":{},"filters":{"shape":"S3g"},"maxResults":{"type":"integer"},"nextToken":{}}},"output":{"type":"structure","members":{"requestId":{},"imageVersionList":{"type":"list","member":{"type":"structure","members":{"arn":{},"name":{},"version":{},"platform":{},"osVersion":{},"owner":{},"dateCreated":{}}}},"nextToken":{}}}},"ListInfrastructureConfigurations":{"http":{"requestUri":"/ListInfrastructureConfigurations"},"input":{"type":"structure","members":{"filters":{"shape":"S3g"},"maxResults":{"type":"integer"},"nextToken":{}}},"output":{"type":"structure","members":{"requestId":{},"infrastructureConfigurationSummaryList":{"type":"list","member":{"type":"structure","members":{"arn":{},"name":{},"description":{},"dateCreated":{},"dateUpdated":{},"resourceTags":{"shape":"S1r"},"tags":{"shape":"Se"}}}},"nextToken":{}}}},"ListTagsForResource":{"http":{"method":"GET","requestUri":"/tags/{resourceArn}"},"input":{"type":"structure","required":["resourceArn"],"members":{"resourceArn":{"location":"uri","locationName":"resourceArn"}}},"output":{"type":"structure","members":{"tags":{"shape":"Se"}}}},"PutComponentPolicy":{"http":{"method":"PUT","requestUri":"/PutComponentPolicy"},"input":{"type":"structure","required":["componentArn","policy"],"members":{"componentArn":{},"policy":{}}},"output":{"type":"structure","members":{"requestId":{},"componentArn":{}}}},"PutImagePolicy":{"http":{"method":"PUT","requestUri":"/PutImagePolicy"},"input":{"type":"structure","required":["imageArn","policy"],"members":{"imageArn":{},"policy":{}}},"output":{"type":"structure","members":{"requestId":{},"imageArn":{}}}},"PutImageRecipePolicy":{"http":{"method":"PUT","requestUri":"/PutImageRecipePolicy"},"input":{"type":"structure","required":["imageRecipeArn","policy"],"members":{"imageRecipeArn":{},"policy":{}}},"output":{"type":"structure","members":{"requestId":{},"imageRecipeArn":{}}}},"StartImagePipelineExecution":{"http":{"method":"PUT","requestUri":"/StartImagePipelineExecution"},"input":{"type":"structure","required":["imagePipelineArn","clientToken"],"members":{"imagePipelineArn":{},"clientToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"requestId":{},"clientToken":{},"imageBuildVersionArn":{}}}},"TagResource":{"http":{"requestUri":"/tags/{resourceArn}"},"input":{"type":"structure","required":["resourceArn","tags"],"members":{"resourceArn":{"location":"uri","locationName":"resourceArn"},"tags":{"shape":"Se"}}},"output":{"type":"structure","members":{}}},"UntagResource":{"http":{"method":"DELETE","requestUri":"/tags/{resourceArn}"},"input":{"type":"structure","required":["resourceArn","tagKeys"],"members":{"resourceArn":{"location":"uri","locationName":"resourceArn"},"tagKeys":{"location":"querystring","locationName":"tagKeys","type":"list","member":{}}}},"output":{"type":"structure","members":{}}},"UpdateDistributionConfiguration":{"http":{"method":"PUT","requestUri":"/UpdateDistributionConfiguration"},"input":{"type":"structure","required":["distributionConfigurationArn","distributions","clientToken"],"members":{"distributionConfigurationArn":{},"description":{},"distributions":{"shape":"Sk"},"clientToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"requestId":{},"clientToken":{},"distributionConfigurationArn":{}}}},"UpdateImagePipeline":{"http":{"method":"PUT","requestUri":"/UpdateImagePipeline"},"input":{"type":"structure","required":["imagePipelineArn","imageRecipeArn","infrastructureConfigurationArn","clientToken"],"members":{"imagePipelineArn":{},"description":{},"imageRecipeArn":{},"infrastructureConfigurationArn":{},"distributionConfigurationArn":{},"imageTestsConfiguration":{"shape":"Sy"},"enhancedImageMetadataEnabled":{"type":"boolean"},"schedule":{"shape":"S13"},"status":{},"clientToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"requestId":{},"clientToken":{},"imagePipelineArn":{}}}},"UpdateInfrastructureConfiguration":{"http":{"method":"PUT","requestUri":"/UpdateInfrastructureConfiguration"},"input":{"type":"structure","required":["infrastructureConfigurationArn","instanceProfileName","clientToken"],"members":{"infrastructureConfigurationArn":{},"description":{},"instanceTypes":{"shape":"S1l"},"instanceProfileName":{},"securityGroupIds":{"shape":"S1n"},"subnetId":{},"logging":{"shape":"S1o"},"keyPair":{},"terminateInstanceOnFailure":{"type":"boolean"},"snsTopicArn":{},"clientToken":{"idempotencyToken":true},"resourceTags":{"shape":"S1r"}}},"output":{"type":"structure","members":{"requestId":{},"clientToken":{},"infrastructureConfigurationArn":{}}}}},"shapes":{"Sa":{"type":"list","member":{}},"Se":{"type":"map","key":{},"value":{}},"Sk":{"type":"list","member":{"type":"structure","required":["region"],"members":{"region":{},"amiDistributionConfiguration":{"type":"structure","members":{"name":{},"description":{},"amiTags":{"shape":"Se"},"kmsKeyId":{},"launchPermission":{"type":"structure","members":{"userIds":{"type":"list","member":{}},"userGroups":{"type":"list","member":{}}}}}},"licenseConfigurationArns":{"type":"list","member":{}}}}},"Sy":{"type":"structure","members":{"imageTestsEnabled":{"type":"boolean"},"timeoutMinutes":{"type":"integer"}}},"S13":{"type":"structure","members":{"scheduleExpression":{},"pipelineExecutionStartCondition":{}}},"S19":{"type":"list","member":{"type":"structure","required":["componentArn"],"members":{"componentArn":{}}}},"S1c":{"type":"list","member":{"type":"structure","members":{"deviceName":{},"ebs":{"type":"structure","members":{"encrypted":{"type":"boolean"},"deleteOnTermination":{"type":"boolean"},"iops":{"type":"integer"},"kmsKeyId":{},"snapshotId":{},"volumeSize":{"type":"integer"},"volumeType":{}}},"virtualName":{},"noDevice":{}}}},"S1l":{"type":"list","member":{}},"S1n":{"type":"list","member":{}},"S1o":{"type":"structure","members":{"s3Logs":{"type":"structure","members":{"s3BucketName":{},"s3KeyPrefix":{}}}}},"S1r":{"type":"map","key":{},"value":{}},"S2h":{"type":"structure","required":["timeoutMinutes"],"members":{"arn":{},"name":{},"description":{},"distributions":{"shape":"Sk"},"timeoutMinutes":{"type":"integer"},"dateCreated":{},"dateUpdated":{},"tags":{"shape":"Se"}}},"S2n":{"type":"structure","members":{"status":{},"reason":{}}},"S2p":{"type":"structure","members":{"arn":{},"name":{},"description":{},"platform":{},"owner":{},"version":{},"components":{"shape":"S19"},"parentImage":{},"blockDeviceMappings":{"shape":"S1c"},"dateCreated":{},"tags":{"shape":"Se"},"workingDirectory":{}}},"S2q":{"type":"structure","members":{"arn":{},"name":{},"description":{},"instanceTypes":{"shape":"S1l"},"instanceProfileName":{},"securityGroupIds":{"shape":"S1n"},"subnetId":{},"logging":{"shape":"S1o"},"keyPair":{},"terminateInstanceOnFailure":{"type":"boolean"},"snsTopicArn":{},"dateCreated":{},"dateUpdated":{},"resourceTags":{"shape":"S1r"},"tags":{"shape":"Se"}}},"S2r":{"type":"structure","members":{"amis":{"type":"list","member":{"type":"structure","members":{"region":{},"image":{},"name":{},"description":{},"state":{"shape":"S2n"}}}}}},"S2w":{"type":"structure","members":{"arn":{},"name":{},"description":{},"platform":{},"enhancedImageMetadataEnabled":{"type":"boolean"},"imageRecipeArn":{},"infrastructureConfigurationArn":{},"distributionConfigurationArn":{},"imageTestsConfiguration":{"shape":"Sy"},"schedule":{"shape":"S13"},"status":{},"dateCreated":{},"dateUpdated":{},"dateLastRun":{},"dateNextRun":{},"tags":{"shape":"Se"}}},"S3g":{"type":"list","member":{"type":"structure","members":{"name":{},"values":{"type":"list","member":{}}}}},"S3v":{"type":"list","member":{"type":"structure","members":{"arn":{},"name":{},"version":{},"platform":{},"osVersion":{},"state":{"shape":"S2n"},"owner":{},"dateCreated":{},"outputResources":{"shape":"S2r"},"tags":{"shape":"Se"}}}}}}; - -/***/ }), - -/***/ 1872: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2019-12-02","endpointPrefix":"iotsitewise","jsonVersion":"1.1","protocol":"rest-json","serviceFullName":"AWS IoT SiteWise","serviceId":"IoTSiteWise","signatureVersion":"v4","signingName":"iotsitewise","uid":"iotsitewise-2019-12-02"},"operations":{"AssociateAssets":{"http":{"requestUri":"/assets/{assetId}/associate"},"input":{"type":"structure","required":["assetId","hierarchyId","childAssetId"],"members":{"assetId":{"location":"uri","locationName":"assetId"},"hierarchyId":{},"childAssetId":{},"clientToken":{"idempotencyToken":true}}},"endpoint":{"hostPrefix":"model."}},"BatchAssociateProjectAssets":{"http":{"requestUri":"/projects/{projectId}/assets/associate","responseCode":200},"input":{"type":"structure","required":["projectId","assetIds"],"members":{"projectId":{"location":"uri","locationName":"projectId"},"assetIds":{"shape":"S5"},"clientToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"errors":{"type":"list","member":{"shape":"S8"}}}},"endpoint":{"hostPrefix":"monitor."}},"BatchDisassociateProjectAssets":{"http":{"requestUri":"/projects/{projectId}/assets/disassociate","responseCode":200},"input":{"type":"structure","required":["projectId","assetIds"],"members":{"projectId":{"location":"uri","locationName":"projectId"},"assetIds":{"shape":"S5"},"clientToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"errors":{"type":"list","member":{"shape":"S8"}}}},"endpoint":{"hostPrefix":"monitor."}},"BatchPutAssetPropertyValue":{"http":{"requestUri":"/properties"},"input":{"type":"structure","required":["entries"],"members":{"entries":{"type":"list","member":{"type":"structure","required":["entryId","propertyValues"],"members":{"entryId":{},"assetId":{},"propertyId":{},"propertyAlias":{},"propertyValues":{"type":"list","member":{"shape":"Sk"}}}}}}},"output":{"type":"structure","required":["errorEntries"],"members":{"errorEntries":{"type":"list","member":{"type":"structure","required":["entryId","errors"],"members":{"entryId":{},"errors":{"type":"list","member":{"type":"structure","required":["errorCode","errorMessage","timestamps"],"members":{"errorCode":{},"errorMessage":{},"timestamps":{"type":"list","member":{"shape":"Sq"}}}}}}}}}},"endpoint":{"hostPrefix":"data."}},"CreateAccessPolicy":{"http":{"requestUri":"/access-policies","responseCode":201},"input":{"type":"structure","required":["accessPolicyIdentity","accessPolicyResource","accessPolicyPermission"],"members":{"accessPolicyIdentity":{"shape":"S13"},"accessPolicyResource":{"shape":"S17"},"accessPolicyPermission":{},"clientToken":{"idempotencyToken":true},"tags":{"shape":"S1b"}}},"output":{"type":"structure","required":["accessPolicyId","accessPolicyArn"],"members":{"accessPolicyId":{},"accessPolicyArn":{}}},"endpoint":{"hostPrefix":"monitor."}},"CreateAsset":{"http":{"requestUri":"/assets","responseCode":202},"input":{"type":"structure","required":["assetName","assetModelId"],"members":{"assetName":{},"assetModelId":{},"clientToken":{"idempotencyToken":true},"tags":{"shape":"S1b"}}},"output":{"type":"structure","required":["assetId","assetArn","assetStatus"],"members":{"assetId":{},"assetArn":{},"assetStatus":{"shape":"S1j"}}},"endpoint":{"hostPrefix":"model."}},"CreateAssetModel":{"http":{"requestUri":"/asset-models","responseCode":202},"input":{"type":"structure","required":["assetModelName"],"members":{"assetModelName":{},"assetModelDescription":{},"assetModelProperties":{"type":"list","member":{"type":"structure","required":["name","dataType","type"],"members":{"name":{},"dataType":{},"unit":{},"type":{"shape":"S1t"}}}},"assetModelHierarchies":{"type":"list","member":{"type":"structure","required":["name","childAssetModelId"],"members":{"name":{},"childAssetModelId":{}}}},"clientToken":{"idempotencyToken":true},"tags":{"shape":"S1b"}}},"output":{"type":"structure","required":["assetModelId","assetModelArn","assetModelStatus"],"members":{"assetModelId":{},"assetModelArn":{},"assetModelStatus":{"shape":"S2b"}}},"endpoint":{"hostPrefix":"model."}},"CreateDashboard":{"http":{"requestUri":"/dashboards","responseCode":201},"input":{"type":"structure","required":["projectId","dashboardName","dashboardDefinition"],"members":{"projectId":{},"dashboardName":{},"dashboardDescription":{},"dashboardDefinition":{},"clientToken":{"idempotencyToken":true},"tags":{"shape":"S1b"}}},"output":{"type":"structure","required":["dashboardId","dashboardArn"],"members":{"dashboardId":{},"dashboardArn":{}}},"endpoint":{"hostPrefix":"monitor."}},"CreateGateway":{"http":{"requestUri":"/20200301/gateways","responseCode":201},"input":{"type":"structure","required":["gatewayName","gatewayPlatform"],"members":{"gatewayName":{},"gatewayPlatform":{"shape":"S2h"},"tags":{"shape":"S1b"}}},"output":{"type":"structure","required":["gatewayId","gatewayArn"],"members":{"gatewayId":{},"gatewayArn":{}}},"endpoint":{"hostPrefix":"edge."}},"CreatePortal":{"http":{"requestUri":"/portals","responseCode":202},"input":{"type":"structure","required":["portalName","portalContactEmail","roleArn"],"members":{"portalName":{},"portalDescription":{},"portalContactEmail":{},"clientToken":{"idempotencyToken":true},"portalLogoImageFile":{"shape":"S2m"},"roleArn":{},"tags":{"shape":"S1b"}}},"output":{"type":"structure","required":["portalId","portalArn","portalStartUrl","portalStatus","ssoApplicationId"],"members":{"portalId":{},"portalArn":{},"portalStartUrl":{},"portalStatus":{"shape":"S2r"},"ssoApplicationId":{}}},"endpoint":{"hostPrefix":"monitor."}},"CreateProject":{"http":{"requestUri":"/projects","responseCode":201},"input":{"type":"structure","required":["portalId","projectName"],"members":{"portalId":{},"projectName":{},"projectDescription":{},"clientToken":{"idempotencyToken":true},"tags":{"shape":"S1b"}}},"output":{"type":"structure","required":["projectId","projectArn"],"members":{"projectId":{},"projectArn":{}}},"endpoint":{"hostPrefix":"monitor."}},"DeleteAccessPolicy":{"http":{"method":"DELETE","requestUri":"/access-policies/{accessPolicyId}","responseCode":204},"input":{"type":"structure","required":["accessPolicyId"],"members":{"accessPolicyId":{"location":"uri","locationName":"accessPolicyId"},"clientToken":{"idempotencyToken":true,"location":"querystring","locationName":"clientToken"}}},"output":{"type":"structure","members":{}},"endpoint":{"hostPrefix":"monitor."}},"DeleteAsset":{"http":{"method":"DELETE","requestUri":"/assets/{assetId}","responseCode":202},"input":{"type":"structure","required":["assetId"],"members":{"assetId":{"location":"uri","locationName":"assetId"},"clientToken":{"idempotencyToken":true,"location":"querystring","locationName":"clientToken"}}},"output":{"type":"structure","required":["assetStatus"],"members":{"assetStatus":{"shape":"S1j"}}},"endpoint":{"hostPrefix":"model."}},"DeleteAssetModel":{"http":{"method":"DELETE","requestUri":"/asset-models/{assetModelId}","responseCode":202},"input":{"type":"structure","required":["assetModelId"],"members":{"assetModelId":{"location":"uri","locationName":"assetModelId"},"clientToken":{"idempotencyToken":true,"location":"querystring","locationName":"clientToken"}}},"output":{"type":"structure","required":["assetModelStatus"],"members":{"assetModelStatus":{"shape":"S2b"}}},"endpoint":{"hostPrefix":"model."}},"DeleteDashboard":{"http":{"method":"DELETE","requestUri":"/dashboards/{dashboardId}","responseCode":204},"input":{"type":"structure","required":["dashboardId"],"members":{"dashboardId":{"location":"uri","locationName":"dashboardId"},"clientToken":{"idempotencyToken":true,"location":"querystring","locationName":"clientToken"}}},"output":{"type":"structure","members":{}},"endpoint":{"hostPrefix":"monitor."}},"DeleteGateway":{"http":{"method":"DELETE","requestUri":"/20200301/gateways/{gatewayId}"},"input":{"type":"structure","required":["gatewayId"],"members":{"gatewayId":{"location":"uri","locationName":"gatewayId"}}},"endpoint":{"hostPrefix":"edge."}},"DeletePortal":{"http":{"method":"DELETE","requestUri":"/portals/{portalId}","responseCode":202},"input":{"type":"structure","required":["portalId"],"members":{"portalId":{"location":"uri","locationName":"portalId"},"clientToken":{"idempotencyToken":true,"location":"querystring","locationName":"clientToken"}}},"output":{"type":"structure","required":["portalStatus"],"members":{"portalStatus":{"shape":"S2r"}}},"endpoint":{"hostPrefix":"monitor."}},"DeleteProject":{"http":{"method":"DELETE","requestUri":"/projects/{projectId}","responseCode":204},"input":{"type":"structure","required":["projectId"],"members":{"projectId":{"location":"uri","locationName":"projectId"},"clientToken":{"idempotencyToken":true,"location":"querystring","locationName":"clientToken"}}},"output":{"type":"structure","members":{}},"endpoint":{"hostPrefix":"monitor."}},"DescribeAccessPolicy":{"http":{"method":"GET","requestUri":"/access-policies/{accessPolicyId}","responseCode":200},"input":{"type":"structure","required":["accessPolicyId"],"members":{"accessPolicyId":{"location":"uri","locationName":"accessPolicyId"}}},"output":{"type":"structure","required":["accessPolicyId","accessPolicyArn","accessPolicyIdentity","accessPolicyResource","accessPolicyPermission","accessPolicyCreationDate","accessPolicyLastUpdateDate"],"members":{"accessPolicyId":{},"accessPolicyArn":{},"accessPolicyIdentity":{"shape":"S13"},"accessPolicyResource":{"shape":"S17"},"accessPolicyPermission":{},"accessPolicyCreationDate":{"type":"timestamp"},"accessPolicyLastUpdateDate":{"type":"timestamp"}}},"endpoint":{"hostPrefix":"monitor."}},"DescribeAsset":{"http":{"method":"GET","requestUri":"/assets/{assetId}"},"input":{"type":"structure","required":["assetId"],"members":{"assetId":{"location":"uri","locationName":"assetId"}}},"output":{"type":"structure","required":["assetId","assetArn","assetName","assetModelId","assetProperties","assetHierarchies","assetCreationDate","assetLastUpdateDate","assetStatus"],"members":{"assetId":{},"assetArn":{},"assetName":{},"assetModelId":{},"assetProperties":{"type":"list","member":{"type":"structure","required":["id","name","dataType"],"members":{"id":{},"name":{},"alias":{},"notification":{"shape":"S3k"},"dataType":{},"unit":{}}}},"assetHierarchies":{"shape":"S3n"},"assetCreationDate":{"type":"timestamp"},"assetLastUpdateDate":{"type":"timestamp"},"assetStatus":{"shape":"S1j"}}},"endpoint":{"hostPrefix":"model."}},"DescribeAssetModel":{"http":{"method":"GET","requestUri":"/asset-models/{assetModelId}"},"input":{"type":"structure","required":["assetModelId"],"members":{"assetModelId":{"location":"uri","locationName":"assetModelId"}}},"output":{"type":"structure","required":["assetModelId","assetModelArn","assetModelName","assetModelDescription","assetModelProperties","assetModelHierarchies","assetModelCreationDate","assetModelLastUpdateDate","assetModelStatus"],"members":{"assetModelId":{},"assetModelArn":{},"assetModelName":{},"assetModelDescription":{},"assetModelProperties":{"shape":"S3r"},"assetModelHierarchies":{"shape":"S3t"},"assetModelCreationDate":{"type":"timestamp"},"assetModelLastUpdateDate":{"type":"timestamp"},"assetModelStatus":{"shape":"S2b"}}},"endpoint":{"hostPrefix":"model."}},"DescribeAssetProperty":{"http":{"method":"GET","requestUri":"/assets/{assetId}/properties/{propertyId}"},"input":{"type":"structure","required":["assetId","propertyId"],"members":{"assetId":{"location":"uri","locationName":"assetId"},"propertyId":{"location":"uri","locationName":"propertyId"}}},"output":{"type":"structure","required":["assetId","assetName","assetModelId","assetProperty"],"members":{"assetId":{},"assetName":{},"assetModelId":{},"assetProperty":{"type":"structure","required":["id","name","dataType"],"members":{"id":{},"name":{},"alias":{},"notification":{"shape":"S3k"},"dataType":{},"unit":{},"type":{"shape":"S1t"}}}}},"endpoint":{"hostPrefix":"model."}},"DescribeDashboard":{"http":{"method":"GET","requestUri":"/dashboards/{dashboardId}","responseCode":200},"input":{"type":"structure","required":["dashboardId"],"members":{"dashboardId":{"location":"uri","locationName":"dashboardId"}}},"output":{"type":"structure","required":["dashboardId","dashboardArn","dashboardName","projectId","dashboardDefinition","dashboardCreationDate","dashboardLastUpdateDate"],"members":{"dashboardId":{},"dashboardArn":{},"dashboardName":{},"projectId":{},"dashboardDescription":{},"dashboardDefinition":{},"dashboardCreationDate":{"type":"timestamp"},"dashboardLastUpdateDate":{"type":"timestamp"}}},"endpoint":{"hostPrefix":"monitor."}},"DescribeGateway":{"http":{"method":"GET","requestUri":"/20200301/gateways/{gatewayId}"},"input":{"type":"structure","required":["gatewayId"],"members":{"gatewayId":{"location":"uri","locationName":"gatewayId"}}},"output":{"type":"structure","required":["gatewayId","gatewayName","gatewayArn","gatewayCapabilitySummaries","creationDate","lastUpdateDate"],"members":{"gatewayId":{},"gatewayName":{},"gatewayArn":{},"gatewayPlatform":{"shape":"S2h"},"gatewayCapabilitySummaries":{"shape":"S42"},"creationDate":{"type":"timestamp"},"lastUpdateDate":{"type":"timestamp"}}},"endpoint":{"hostPrefix":"edge."}},"DescribeGatewayCapabilityConfiguration":{"http":{"method":"GET","requestUri":"/20200301/gateways/{gatewayId}/capability/{capabilityNamespace}"},"input":{"type":"structure","required":["gatewayId","capabilityNamespace"],"members":{"gatewayId":{"location":"uri","locationName":"gatewayId"},"capabilityNamespace":{"location":"uri","locationName":"capabilityNamespace"}}},"output":{"type":"structure","required":["gatewayId","capabilityNamespace","capabilityConfiguration","capabilitySyncStatus"],"members":{"gatewayId":{},"capabilityNamespace":{},"capabilityConfiguration":{},"capabilitySyncStatus":{}}},"endpoint":{"hostPrefix":"edge."}},"DescribeLoggingOptions":{"http":{"method":"GET","requestUri":"/logging"},"input":{"type":"structure","members":{}},"output":{"type":"structure","required":["loggingOptions"],"members":{"loggingOptions":{"shape":"S4b"}}},"endpoint":{"hostPrefix":"model."}},"DescribePortal":{"http":{"method":"GET","requestUri":"/portals/{portalId}","responseCode":200},"input":{"type":"structure","required":["portalId"],"members":{"portalId":{"location":"uri","locationName":"portalId"}}},"output":{"type":"structure","required":["portalId","portalArn","portalName","portalClientId","portalStartUrl","portalContactEmail","portalStatus","portalCreationDate","portalLastUpdateDate"],"members":{"portalId":{},"portalArn":{},"portalName":{},"portalDescription":{},"portalClientId":{},"portalStartUrl":{},"portalContactEmail":{},"portalStatus":{"shape":"S2r"},"portalCreationDate":{"type":"timestamp"},"portalLastUpdateDate":{"type":"timestamp"},"portalLogoImageLocation":{"type":"structure","required":["id","url"],"members":{"id":{},"url":{}}},"roleArn":{}}},"endpoint":{"hostPrefix":"monitor."}},"DescribeProject":{"http":{"method":"GET","requestUri":"/projects/{projectId}","responseCode":200},"input":{"type":"structure","required":["projectId"],"members":{"projectId":{"location":"uri","locationName":"projectId"}}},"output":{"type":"structure","required":["projectId","projectArn","projectName","portalId","projectCreationDate","projectLastUpdateDate"],"members":{"projectId":{},"projectArn":{},"projectName":{},"portalId":{},"projectDescription":{},"projectCreationDate":{"type":"timestamp"},"projectLastUpdateDate":{"type":"timestamp"}}},"endpoint":{"hostPrefix":"monitor."}},"DisassociateAssets":{"http":{"requestUri":"/assets/{assetId}/disassociate"},"input":{"type":"structure","required":["assetId","hierarchyId","childAssetId"],"members":{"assetId":{"location":"uri","locationName":"assetId"},"hierarchyId":{},"childAssetId":{},"clientToken":{"idempotencyToken":true}}},"endpoint":{"hostPrefix":"model."}},"GetAssetPropertyAggregates":{"http":{"method":"GET","requestUri":"/properties/aggregates"},"input":{"type":"structure","required":["aggregateTypes","resolution","startDate","endDate"],"members":{"assetId":{"location":"querystring","locationName":"assetId"},"propertyId":{"location":"querystring","locationName":"propertyId"},"propertyAlias":{"location":"querystring","locationName":"propertyAlias"},"aggregateTypes":{"location":"querystring","locationName":"aggregateTypes","type":"list","member":{}},"resolution":{"location":"querystring","locationName":"resolution"},"qualities":{"shape":"S4o","location":"querystring","locationName":"qualities"},"startDate":{"location":"querystring","locationName":"startDate","type":"timestamp"},"endDate":{"location":"querystring","locationName":"endDate","type":"timestamp"},"timeOrdering":{"location":"querystring","locationName":"timeOrdering"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","required":["aggregatedValues"],"members":{"aggregatedValues":{"type":"list","member":{"type":"structure","required":["timestamp","value"],"members":{"timestamp":{"type":"timestamp"},"quality":{},"value":{"type":"structure","members":{"average":{"type":"double"},"count":{"type":"double"},"maximum":{"type":"double"},"minimum":{"type":"double"},"sum":{"type":"double"},"standardDeviation":{"type":"double"}}}}}},"nextToken":{}}},"endpoint":{"hostPrefix":"data."}},"GetAssetPropertyValue":{"http":{"method":"GET","requestUri":"/properties/latest"},"input":{"type":"structure","members":{"assetId":{"location":"querystring","locationName":"assetId"},"propertyId":{"location":"querystring","locationName":"propertyId"},"propertyAlias":{"location":"querystring","locationName":"propertyAlias"}}},"output":{"type":"structure","members":{"propertyValue":{"shape":"Sk"}}},"endpoint":{"hostPrefix":"data."}},"GetAssetPropertyValueHistory":{"http":{"method":"GET","requestUri":"/properties/history"},"input":{"type":"structure","members":{"assetId":{"location":"querystring","locationName":"assetId"},"propertyId":{"location":"querystring","locationName":"propertyId"},"propertyAlias":{"location":"querystring","locationName":"propertyAlias"},"startDate":{"location":"querystring","locationName":"startDate","type":"timestamp"},"endDate":{"location":"querystring","locationName":"endDate","type":"timestamp"},"qualities":{"shape":"S4o","location":"querystring","locationName":"qualities"},"timeOrdering":{"location":"querystring","locationName":"timeOrdering"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","required":["assetPropertyValueHistory"],"members":{"assetPropertyValueHistory":{"type":"list","member":{"shape":"Sk"}},"nextToken":{}}},"endpoint":{"hostPrefix":"data."}},"ListAccessPolicies":{"http":{"method":"GET","requestUri":"/access-policies","responseCode":200},"input":{"type":"structure","members":{"identityType":{"location":"querystring","locationName":"identityType"},"identityId":{"location":"querystring","locationName":"identityId"},"resourceType":{"location":"querystring","locationName":"resourceType"},"resourceId":{"location":"querystring","locationName":"resourceId"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","required":["accessPolicySummaries"],"members":{"accessPolicySummaries":{"type":"list","member":{"type":"structure","required":["id","identity","resource","permission"],"members":{"id":{},"identity":{"shape":"S13"},"resource":{"shape":"S17"},"permission":{},"creationDate":{"type":"timestamp"},"lastUpdateDate":{"type":"timestamp"}}}},"nextToken":{}}},"endpoint":{"hostPrefix":"monitor."}},"ListAssetModels":{"http":{"method":"GET","requestUri":"/asset-models"},"input":{"type":"structure","members":{"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","required":["assetModelSummaries"],"members":{"assetModelSummaries":{"type":"list","member":{"type":"structure","required":["id","arn","name","description","creationDate","lastUpdateDate","status"],"members":{"id":{},"arn":{},"name":{},"description":{},"creationDate":{"type":"timestamp"},"lastUpdateDate":{"type":"timestamp"},"status":{"shape":"S2b"}}}},"nextToken":{}}},"endpoint":{"hostPrefix":"model."}},"ListAssets":{"http":{"method":"GET","requestUri":"/assets"},"input":{"type":"structure","members":{"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"assetModelId":{"location":"querystring","locationName":"assetModelId"},"filter":{"location":"querystring","locationName":"filter"}}},"output":{"type":"structure","required":["assetSummaries"],"members":{"assetSummaries":{"type":"list","member":{"type":"structure","required":["id","arn","name","assetModelId","creationDate","lastUpdateDate","status","hierarchies"],"members":{"id":{},"arn":{},"name":{},"assetModelId":{},"creationDate":{"type":"timestamp"},"lastUpdateDate":{"type":"timestamp"},"status":{"shape":"S1j"},"hierarchies":{"shape":"S3n"}}}},"nextToken":{}}},"endpoint":{"hostPrefix":"model."}},"ListAssociatedAssets":{"http":{"method":"GET","requestUri":"/assets/{assetId}/hierarchies"},"input":{"type":"structure","required":["assetId","hierarchyId"],"members":{"assetId":{"location":"uri","locationName":"assetId"},"hierarchyId":{"location":"querystring","locationName":"hierarchyId"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","required":["assetSummaries"],"members":{"assetSummaries":{"type":"list","member":{"type":"structure","required":["id","arn","name","assetModelId","creationDate","lastUpdateDate","status","hierarchies"],"members":{"id":{},"arn":{},"name":{},"assetModelId":{},"creationDate":{"type":"timestamp"},"lastUpdateDate":{"type":"timestamp"},"status":{"shape":"S1j"},"hierarchies":{"shape":"S3n"}}}},"nextToken":{}}},"endpoint":{"hostPrefix":"model."}},"ListDashboards":{"http":{"method":"GET","requestUri":"/dashboards","responseCode":200},"input":{"type":"structure","required":["projectId"],"members":{"projectId":{"location":"querystring","locationName":"projectId"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","required":["dashboardSummaries"],"members":{"dashboardSummaries":{"type":"list","member":{"type":"structure","required":["id","name"],"members":{"id":{},"name":{},"description":{},"creationDate":{"type":"timestamp"},"lastUpdateDate":{"type":"timestamp"}}}},"nextToken":{}}},"endpoint":{"hostPrefix":"monitor."}},"ListGateways":{"http":{"method":"GET","requestUri":"/20200301/gateways"},"input":{"type":"structure","members":{"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","required":["gatewaySummaries"],"members":{"gatewaySummaries":{"type":"list","member":{"type":"structure","required":["gatewayId","gatewayName","creationDate","lastUpdateDate"],"members":{"gatewayId":{},"gatewayName":{},"gatewayCapabilitySummaries":{"shape":"S42"},"creationDate":{"type":"timestamp"},"lastUpdateDate":{"type":"timestamp"}}}},"nextToken":{}}},"endpoint":{"hostPrefix":"edge."}},"ListPortals":{"http":{"method":"GET","requestUri":"/portals","responseCode":200},"input":{"type":"structure","members":{"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"portalSummaries":{"type":"list","member":{"type":"structure","required":["id","name","startUrl"],"members":{"id":{},"name":{},"description":{},"startUrl":{},"creationDate":{"type":"timestamp"},"lastUpdateDate":{"type":"timestamp"},"roleArn":{}}}},"nextToken":{}}},"endpoint":{"hostPrefix":"monitor."}},"ListProjectAssets":{"http":{"method":"GET","requestUri":"/projects/{projectId}/assets","responseCode":200},"input":{"type":"structure","required":["projectId"],"members":{"projectId":{"location":"uri","locationName":"projectId"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","required":["assetIds"],"members":{"assetIds":{"type":"list","member":{}},"nextToken":{}}},"endpoint":{"hostPrefix":"monitor."}},"ListProjects":{"http":{"method":"GET","requestUri":"/projects","responseCode":200},"input":{"type":"structure","required":["portalId"],"members":{"portalId":{"location":"querystring","locationName":"portalId"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","required":["projectSummaries"],"members":{"projectSummaries":{"type":"list","member":{"type":"structure","required":["id","name"],"members":{"id":{},"name":{},"description":{},"creationDate":{"type":"timestamp"},"lastUpdateDate":{"type":"timestamp"}}}},"nextToken":{}}},"endpoint":{"hostPrefix":"monitor."}},"ListTagsForResource":{"http":{"method":"GET","requestUri":"/tags"},"input":{"type":"structure","required":["resourceArn"],"members":{"resourceArn":{"location":"querystring","locationName":"resourceArn"}}},"output":{"type":"structure","members":{"tags":{"shape":"S1b"}}}},"PutLoggingOptions":{"http":{"method":"PUT","requestUri":"/logging"},"input":{"type":"structure","required":["loggingOptions"],"members":{"loggingOptions":{"shape":"S4b"}}},"output":{"type":"structure","members":{}},"endpoint":{"hostPrefix":"model."}},"TagResource":{"http":{"requestUri":"/tags"},"input":{"type":"structure","required":["resourceArn","tags"],"members":{"resourceArn":{"location":"querystring","locationName":"resourceArn"},"tags":{"shape":"S1b"}}},"output":{"type":"structure","members":{}}},"UntagResource":{"http":{"method":"DELETE","requestUri":"/tags"},"input":{"type":"structure","required":["resourceArn","tagKeys"],"members":{"resourceArn":{"location":"querystring","locationName":"resourceArn"},"tagKeys":{"location":"querystring","locationName":"tagKeys","type":"list","member":{}}}},"output":{"type":"structure","members":{}}},"UpdateAccessPolicy":{"http":{"method":"PUT","requestUri":"/access-policies/{accessPolicyId}","responseCode":200},"input":{"type":"structure","required":["accessPolicyId","accessPolicyIdentity","accessPolicyResource","accessPolicyPermission"],"members":{"accessPolicyId":{"location":"uri","locationName":"accessPolicyId"},"accessPolicyIdentity":{"shape":"S13"},"accessPolicyResource":{"shape":"S17"},"accessPolicyPermission":{},"clientToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{}},"endpoint":{"hostPrefix":"monitor."}},"UpdateAsset":{"http":{"method":"PUT","requestUri":"/assets/{assetId}","responseCode":202},"input":{"type":"structure","required":["assetId","assetName"],"members":{"assetId":{"location":"uri","locationName":"assetId"},"assetName":{},"clientToken":{"idempotencyToken":true}}},"output":{"type":"structure","required":["assetStatus"],"members":{"assetStatus":{"shape":"S1j"}}},"endpoint":{"hostPrefix":"model."}},"UpdateAssetModel":{"http":{"method":"PUT","requestUri":"/asset-models/{assetModelId}","responseCode":202},"input":{"type":"structure","required":["assetModelId","assetModelName"],"members":{"assetModelId":{"location":"uri","locationName":"assetModelId"},"assetModelName":{},"assetModelDescription":{},"assetModelProperties":{"shape":"S3r"},"assetModelHierarchies":{"shape":"S3t"},"clientToken":{"idempotencyToken":true}}},"output":{"type":"structure","required":["assetModelStatus"],"members":{"assetModelStatus":{"shape":"S2b"}}},"endpoint":{"hostPrefix":"model."}},"UpdateAssetProperty":{"http":{"method":"PUT","requestUri":"/assets/{assetId}/properties/{propertyId}"},"input":{"type":"structure","required":["assetId","propertyId"],"members":{"assetId":{"location":"uri","locationName":"assetId"},"propertyId":{"location":"uri","locationName":"propertyId"},"propertyAlias":{},"propertyNotificationState":{},"clientToken":{"idempotencyToken":true}}},"endpoint":{"hostPrefix":"model."}},"UpdateDashboard":{"http":{"method":"PUT","requestUri":"/dashboards/{dashboardId}","responseCode":200},"input":{"type":"structure","required":["dashboardId","dashboardName","dashboardDefinition"],"members":{"dashboardId":{"location":"uri","locationName":"dashboardId"},"dashboardName":{},"dashboardDescription":{},"dashboardDefinition":{},"clientToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{}},"endpoint":{"hostPrefix":"monitor."}},"UpdateGateway":{"http":{"method":"PUT","requestUri":"/20200301/gateways/{gatewayId}"},"input":{"type":"structure","required":["gatewayId","gatewayName"],"members":{"gatewayId":{"location":"uri","locationName":"gatewayId"},"gatewayName":{}}},"endpoint":{"hostPrefix":"edge."}},"UpdateGatewayCapabilityConfiguration":{"http":{"requestUri":"/20200301/gateways/{gatewayId}/capability","responseCode":201},"input":{"type":"structure","required":["gatewayId","capabilityNamespace","capabilityConfiguration"],"members":{"gatewayId":{"location":"uri","locationName":"gatewayId"},"capabilityNamespace":{},"capabilityConfiguration":{}}},"output":{"type":"structure","required":["capabilityNamespace","capabilitySyncStatus"],"members":{"capabilityNamespace":{},"capabilitySyncStatus":{}}},"endpoint":{"hostPrefix":"edge."}},"UpdatePortal":{"http":{"method":"PUT","requestUri":"/portals/{portalId}","responseCode":202},"input":{"type":"structure","required":["portalId","portalName","portalContactEmail","roleArn"],"members":{"portalId":{"location":"uri","locationName":"portalId"},"portalName":{},"portalDescription":{},"portalContactEmail":{},"portalLogoImage":{"type":"structure","members":{"id":{},"file":{"shape":"S2m"}}},"roleArn":{},"clientToken":{"idempotencyToken":true}}},"output":{"type":"structure","required":["portalStatus"],"members":{"portalStatus":{"shape":"S2r"}}},"endpoint":{"hostPrefix":"monitor."}},"UpdateProject":{"http":{"method":"PUT","requestUri":"/projects/{projectId}","responseCode":200},"input":{"type":"structure","required":["projectId","projectName"],"members":{"projectId":{"location":"uri","locationName":"projectId"},"projectName":{},"projectDescription":{},"clientToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{}},"endpoint":{"hostPrefix":"monitor."}}},"shapes":{"S5":{"type":"list","member":{}},"S8":{"type":"structure","required":["assetId","code","message"],"members":{"assetId":{},"code":{},"message":{}}},"Sk":{"type":"structure","required":["value","timestamp"],"members":{"value":{"type":"structure","members":{"stringValue":{},"integerValue":{"type":"integer"},"doubleValue":{"type":"double"},"booleanValue":{"type":"boolean"}}},"timestamp":{"shape":"Sq"},"quality":{}}},"Sq":{"type":"structure","required":["timeInSeconds"],"members":{"timeInSeconds":{"type":"long"},"offsetInNanos":{"type":"integer"}}},"S13":{"type":"structure","members":{"user":{"type":"structure","required":["id"],"members":{"id":{}}},"group":{"type":"structure","required":["id"],"members":{"id":{}}}}},"S17":{"type":"structure","members":{"portal":{"type":"structure","required":["id"],"members":{"id":{}}},"project":{"type":"structure","required":["id"],"members":{"id":{}}}}},"S1b":{"type":"map","key":{},"value":{}},"S1j":{"type":"structure","required":["state"],"members":{"state":{},"error":{"shape":"S1l"}}},"S1l":{"type":"structure","required":["code","message"],"members":{"code":{},"message":{}}},"S1t":{"type":"structure","members":{"attribute":{"type":"structure","members":{"defaultValue":{}}},"measurement":{"type":"structure","members":{}},"transform":{"type":"structure","required":["expression","variables"],"members":{"expression":{},"variables":{"shape":"S1z"}}},"metric":{"type":"structure","required":["expression","variables","window"],"members":{"expression":{},"variables":{"shape":"S1z"},"window":{"type":"structure","members":{"tumbling":{"type":"structure","required":["interval"],"members":{"interval":{}}}}}}}}},"S1z":{"type":"list","member":{"type":"structure","required":["name","value"],"members":{"name":{},"value":{"type":"structure","required":["propertyId"],"members":{"propertyId":{},"hierarchyId":{}}}}}},"S2b":{"type":"structure","required":["state"],"members":{"state":{},"error":{"shape":"S1l"}}},"S2h":{"type":"structure","required":["greengrass"],"members":{"greengrass":{"type":"structure","required":["groupArn"],"members":{"groupArn":{}}}}},"S2m":{"type":"structure","required":["data","type"],"members":{"data":{"type":"blob"},"type":{}}},"S2r":{"type":"structure","required":["state"],"members":{"state":{},"error":{"type":"structure","members":{"code":{},"message":{}}}}},"S3k":{"type":"structure","required":["topic","state"],"members":{"topic":{},"state":{}}},"S3n":{"type":"list","member":{"type":"structure","required":["name"],"members":{"id":{},"name":{}}}},"S3r":{"type":"list","member":{"type":"structure","required":["name","dataType","type"],"members":{"id":{},"name":{},"dataType":{},"unit":{},"type":{"shape":"S1t"}}}},"S3t":{"type":"list","member":{"type":"structure","required":["name","childAssetModelId"],"members":{"id":{},"name":{},"childAssetModelId":{}}}},"S42":{"type":"list","member":{"type":"structure","required":["capabilityNamespace","capabilitySyncStatus"],"members":{"capabilityNamespace":{},"capabilitySyncStatus":{}}}},"S4b":{"type":"structure","required":["level"],"members":{"level":{}}},"S4o":{"type":"list","member":{}}}}; - -/***/ }), - -/***/ 1879: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['lexruntime'] = {}; -AWS.LexRuntime = Service.defineService('lexruntime', ['2016-11-28']); -Object.defineProperty(apiLoader.services['lexruntime'], '2016-11-28', { - get: function get() { - var model = __webpack_require__(1352); - model.paginators = __webpack_require__(2681).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.LexRuntime; - - -/***/ }), - -/***/ 1885: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -// Generated by CoffeeScript 1.12.7 -(function() { - "use strict"; - var bom, defaults, events, isEmpty, processItem, processors, sax, setImmediate, - bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; }, - extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, - hasProp = {}.hasOwnProperty; - - sax = __webpack_require__(4645); - - events = __webpack_require__(8614); - - bom = __webpack_require__(6210); - - processors = __webpack_require__(5350); - - setImmediate = __webpack_require__(8213).setImmediate; - - defaults = __webpack_require__(1514).defaults; - - isEmpty = function(thing) { - return typeof thing === "object" && (thing != null) && Object.keys(thing).length === 0; - }; - - processItem = function(processors, item, key) { - var i, len, process; - for (i = 0, len = processors.length; i < len; i++) { - process = processors[i]; - item = process(item, key); + else { + exponentComponent = Math.pow(2, exponent - 15); + summation = 1; } - return item; - }; - - exports.Parser = (function(superClass) { - extend(Parser, superClass); - - function Parser(opts) { - this.parseString = bind(this.parseString, this); - this.reset = bind(this.reset, this); - this.assignOrPush = bind(this.assignOrPush, this); - this.processAsync = bind(this.processAsync, this); - var key, ref, value; - if (!(this instanceof exports.Parser)) { - return new exports.Parser(opts); - } - this.options = {}; - ref = defaults["0.2"]; - for (key in ref) { - if (!hasProp.call(ref, key)) continue; - value = ref[key]; - this.options[key] = value; - } - for (key in opts) { - if (!hasProp.call(opts, key)) continue; - value = opts[key]; - this.options[key] = value; - } - if (this.options.xmlns) { - this.options.xmlnskey = this.options.attrkey + "ns"; - } - if (this.options.normalizeTags) { - if (!this.options.tagNameProcessors) { - this.options.tagNameProcessors = []; + summation += fraction / 1024; + return scalar * (exponentComponent * summation); +} +function decodeCount(at, to) { + const minor = payload[at] & 0b0001_1111; + if (minor < 24) { + _offset = 1; + return minor; + } + if (minor === extendedOneByte || + minor === extendedFloat16 || + minor === extendedFloat32 || + minor === extendedFloat64) { + const countLength = minorValueToArgumentLength[minor]; + _offset = (countLength + 1); + if (to - at < _offset) { + throw new Error(`countLength ${countLength} greater than remaining buf len.`); } - this.options.tagNameProcessors.unshift(processors.normalize); - } - this.reset(); + const countIndex = at + 1; + if (countLength === 1) { + return payload[countIndex]; + } + else if (countLength === 2) { + return dataView$1.getUint16(countIndex); + } + else if (countLength === 4) { + return dataView$1.getUint32(countIndex); + } + return demote(dataView$1.getBigUint64(countIndex)); } - - Parser.prototype.processAsync = function() { - var chunk, err; - try { - if (this.remaining.length <= this.options.chunkSize) { - chunk = this.remaining; - this.remaining = ''; - this.saxParser = this.saxParser.write(chunk); - return this.saxParser.close(); - } else { - chunk = this.remaining.substr(0, this.options.chunkSize); - this.remaining = this.remaining.substr(this.options.chunkSize, this.remaining.length); - this.saxParser = this.saxParser.write(chunk); - return setImmediate(this.processAsync); + throw new Error(`unexpected minor value ${minor}.`); +} +function decodeUtf8String(at, to) { + const length = decodeCount(at, to); + const offset = _offset; + at += offset; + if (to - at < length) { + throw new Error(`string len ${length} greater than remaining buf len.`); + } + const value = bytesToUtf8(payload, at, at + length); + _offset = offset + length; + return value; +} +function decodeUtf8StringIndefinite(at, to) { + at += 1; + const vector = []; + for (const base = at; at < to;) { + if (payload[at] === 0b1111_1111) { + const data = alloc(vector.length); + data.set(vector, 0); + _offset = at - base + 2; + return bytesToUtf8(data, 0, data.length); } - } catch (error1) { - err = error1; - if (!this.saxParser.errThrown) { - this.saxParser.errThrown = true; - return this.emit(err); + const major = (payload[at] & 0b1110_0000) >> 5; + const minor = payload[at] & 0b0001_1111; + if (major !== majorUtf8String) { + throw new Error(`unexpected major type ${major} in indefinite string.`); } - } - }; - - Parser.prototype.assignOrPush = function(obj, key, newValue) { - if (!(key in obj)) { - if (!this.options.explicitArray) { - return obj[key] = newValue; - } else { - return obj[key] = [newValue]; + if (minor === minorIndefinite) { + throw new Error("nested indefinite string."); } - } else { - if (!(obj[key] instanceof Array)) { - obj[key] = [obj[key]]; + const bytes = decodeUnstructuredByteString(at, to); + const length = _offset; + at += length; + for (let i = 0; i < bytes.length; ++i) { + vector.push(bytes[i]); } - return obj[key].push(newValue); - } - }; - - Parser.prototype.reset = function() { - var attrkey, charkey, ontext, stack; - this.removeAllListeners(); - this.saxParser = sax.parser(this.options.strict, { - trim: false, - normalize: false, - xmlns: this.options.xmlns - }); - this.saxParser.errThrown = false; - this.saxParser.onerror = (function(_this) { - return function(error) { - _this.saxParser.resume(); - if (!_this.saxParser.errThrown) { - _this.saxParser.errThrown = true; - return _this.emit("error", error); - } - }; - })(this); - this.saxParser.onend = (function(_this) { - return function() { - if (!_this.saxParser.ended) { - _this.saxParser.ended = true; - return _this.emit("end", _this.resultObject); - } - }; - })(this); - this.saxParser.ended = false; - this.EXPLICIT_CHARKEY = this.options.explicitCharkey; - this.resultObject = null; - stack = []; - attrkey = this.options.attrkey; - charkey = this.options.charkey; - this.saxParser.onopentag = (function(_this) { - return function(node) { - var key, newValue, obj, processedKey, ref; - obj = {}; - obj[charkey] = ""; - if (!_this.options.ignoreAttrs) { - ref = node.attributes; - for (key in ref) { - if (!hasProp.call(ref, key)) continue; - if (!(attrkey in obj) && !_this.options.mergeAttrs) { - obj[attrkey] = {}; - } - newValue = _this.options.attrValueProcessors ? processItem(_this.options.attrValueProcessors, node.attributes[key], key) : node.attributes[key]; - processedKey = _this.options.attrNameProcessors ? processItem(_this.options.attrNameProcessors, key) : key; - if (_this.options.mergeAttrs) { - _this.assignOrPush(obj, processedKey, newValue); - } else { - obj[attrkey][processedKey] = newValue; - } - } - } - obj["#name"] = _this.options.tagNameProcessors ? processItem(_this.options.tagNameProcessors, node.name) : node.name; - if (_this.options.xmlns) { - obj[_this.options.xmlnskey] = { - uri: node.uri, - local: node.local - }; - } - return stack.push(obj); - }; - })(this); - this.saxParser.onclosetag = (function(_this) { - return function() { - var cdata, emptyStr, key, node, nodeName, obj, objClone, old, s, xpath; - obj = stack.pop(); - nodeName = obj["#name"]; - if (!_this.options.explicitChildren || !_this.options.preserveChildrenOrder) { - delete obj["#name"]; - } - if (obj.cdata === true) { - cdata = obj.cdata; - delete obj.cdata; - } - s = stack[stack.length - 1]; - if (obj[charkey].match(/^\s*$/) && !cdata) { - emptyStr = obj[charkey]; - delete obj[charkey]; - } else { - if (_this.options.trim) { - obj[charkey] = obj[charkey].trim(); + } + throw new Error("expected break marker."); +} +function decodeUnstructuredByteString(at, to) { + const length = decodeCount(at, to); + const offset = _offset; + at += offset; + if (to - at < length) { + throw new Error(`unstructured byte string len ${length} greater than remaining buf len.`); + } + const value = payload.subarray(at, at + length); + _offset = offset + length; + return value; +} +function decodeUnstructuredByteStringIndefinite(at, to) { + at += 1; + const vector = []; + for (const base = at; at < to;) { + if (payload[at] === 0b1111_1111) { + const data = alloc(vector.length); + data.set(vector, 0); + _offset = at - base + 2; + return data; + } + const major = (payload[at] & 0b1110_0000) >> 5; + const minor = payload[at] & 0b0001_1111; + if (major !== majorUnstructuredByteString) { + throw new Error(`unexpected major type ${major} in indefinite string.`); + } + if (minor === minorIndefinite) { + throw new Error("nested indefinite string."); + } + const bytes = decodeUnstructuredByteString(at, to); + const length = _offset; + at += length; + for (let i = 0; i < bytes.length; ++i) { + vector.push(bytes[i]); + } + } + throw new Error("expected break marker."); +} +function decodeList(at, to) { + const listDataLength = decodeCount(at, to); + const offset = _offset; + at += offset; + const base = at; + const list = Array(listDataLength); + for (let i = 0; i < listDataLength; ++i) { + const item = decode(at, to); + const itemOffset = _offset; + list[i] = item; + at += itemOffset; + } + _offset = offset + (at - base); + return list; +} +function decodeListIndefinite(at, to) { + at += 1; + const list = []; + for (const base = at; at < to;) { + if (payload[at] === 0b1111_1111) { + _offset = at - base + 2; + return list; + } + const item = decode(at, to); + const n = _offset; + at += n; + list.push(item); + } + throw new Error("expected break marker."); +} +function decodeMap(at, to) { + const mapDataLength = decodeCount(at, to); + const offset = _offset; + at += offset; + const base = at; + const map = {}; + for (let i = 0; i < mapDataLength; ++i) { + if (at >= to) { + throw new Error("unexpected end of map payload."); + } + const major = (payload[at] & 0b1110_0000) >> 5; + if (major !== majorUtf8String) { + throw new Error(`unexpected major type ${major} for map key at index ${at}.`); + } + const key = decode(at, to); + at += _offset; + const value = decode(at, to); + at += _offset; + map[key] = value; + } + _offset = offset + (at - base); + return map; +} +function decodeMapIndefinite(at, to) { + at += 1; + const base = at; + const map = {}; + for (; at < to;) { + if (at >= to) { + throw new Error("unexpected end of map payload."); + } + if (payload[at] === 0b1111_1111) { + _offset = at - base + 2; + return map; + } + const major = (payload[at] & 0b1110_0000) >> 5; + if (major !== majorUtf8String) { + throw new Error(`unexpected major type ${major} for map key.`); + } + const key = decode(at, to); + at += _offset; + const value = decode(at, to); + at += _offset; + map[key] = value; + } + throw new Error("expected break marker."); +} +function decodeSpecial(at, to) { + const minor = payload[at] & 0b0001_1111; + switch (minor) { + case specialTrue: + case specialFalse: + _offset = 1; + return minor === specialTrue; + case specialNull: + _offset = 1; + return null; + case specialUndefined: + _offset = 1; + return null; + case extendedFloat16: + if (to - at < 3) { + throw new Error("incomplete float16 at end of buf."); } - if (_this.options.normalize) { - obj[charkey] = obj[charkey].replace(/\s{2,}/g, " ").trim(); + _offset = 3; + return bytesToFloat16(payload[at + 1], payload[at + 2]); + case extendedFloat32: + if (to - at < 5) { + throw new Error("incomplete float32 at end of buf."); } - obj[charkey] = _this.options.valueProcessors ? processItem(_this.options.valueProcessors, obj[charkey], nodeName) : obj[charkey]; - if (Object.keys(obj).length === 1 && charkey in obj && !_this.EXPLICIT_CHARKEY) { - obj = obj[charkey]; + _offset = 5; + return dataView$1.getFloat32(at + 1); + case extendedFloat64: + if (to - at < 9) { + throw new Error("incomplete float64 at end of buf."); } - } - if (isEmpty(obj)) { - obj = _this.options.emptyTag !== '' ? _this.options.emptyTag : emptyStr; - } - if (_this.options.validator != null) { - xpath = "/" + ((function() { - var i, len, results; - results = []; - for (i = 0, len = stack.length; i < len; i++) { - node = stack[i]; - results.push(node["#name"]); - } - return results; - })()).concat(nodeName).join("/"); - (function() { - var err; - try { - return obj = _this.options.validator(xpath, s && s[nodeName], obj); - } catch (error1) { - err = error1; - return _this.emit("error", err); - } - })(); - } - if (_this.options.explicitChildren && !_this.options.mergeAttrs && typeof obj === 'object') { - if (!_this.options.preserveChildrenOrder) { - node = {}; - if (_this.options.attrkey in obj) { - node[_this.options.attrkey] = obj[_this.options.attrkey]; - delete obj[_this.options.attrkey]; - } - if (!_this.options.charsAsChildren && _this.options.charkey in obj) { - node[_this.options.charkey] = obj[_this.options.charkey]; - delete obj[_this.options.charkey]; - } - if (Object.getOwnPropertyNames(obj).length > 0) { - node[_this.options.childkey] = obj; - } - obj = node; - } else if (s) { - s[_this.options.childkey] = s[_this.options.childkey] || []; - objClone = {}; - for (key in obj) { - if (!hasProp.call(obj, key)) continue; - objClone[key] = obj[key]; - } - s[_this.options.childkey].push(objClone); - delete obj["#name"]; - if (Object.keys(obj).length === 1 && charkey in obj && !_this.EXPLICIT_CHARKEY) { - obj = obj[charkey]; - } + _offset = 9; + return dataView$1.getFloat64(at + 1); + default: + throw new Error(`unexpected minor value ${minor}.`); + } +} +function castBigInt(bigInt) { + if (typeof bigInt === "number") { + return bigInt; + } + const num = Number(bigInt); + if (Number.MIN_SAFE_INTEGER <= num && num <= Number.MAX_SAFE_INTEGER) { + return num; + } + return bigInt; +} + +const USE_BUFFER = typeof Buffer !== "undefined"; +const initialSize = 2048; +let data = alloc(initialSize); +let dataView = new DataView(data.buffer, data.byteOffset, data.byteLength); +let cursor = 0; +function ensureSpace(bytes) { + const remaining = data.byteLength - cursor; + if (remaining < bytes) { + if (cursor < 16_000_000) { + resize(Math.max(data.byteLength * 4, data.byteLength + bytes)); + } + else { + resize(data.byteLength + bytes + 16_000_000); + } + } +} +function toUint8Array() { + const out = alloc(cursor); + out.set(data.subarray(0, cursor), 0); + cursor = 0; + return out; +} +function resize(size) { + const old = data; + data = alloc(size); + if (old) { + if (old.copy) { + old.copy(data, 0, 0, old.byteLength); + } + else { + data.set(old, 0); + } + } + dataView = new DataView(data.buffer, data.byteOffset, data.byteLength); +} +function encodeHeader(major, value) { + if (value < 24) { + data[cursor++] = (major << 5) | value; + } + else if (value < 1 << 8) { + data[cursor++] = (major << 5) | 24; + data[cursor++] = value; + } + else if (value < 1 << 16) { + data[cursor++] = (major << 5) | extendedFloat16; + dataView.setUint16(cursor, value); + cursor += 2; + } + else if (value < 2 ** 32) { + data[cursor++] = (major << 5) | extendedFloat32; + dataView.setUint32(cursor, value); + cursor += 4; + } + else { + data[cursor++] = (major << 5) | extendedFloat64; + dataView.setBigUint64(cursor, typeof value === "bigint" ? value : BigInt(value)); + cursor += 8; + } +} +function encode(_input) { + const encodeStack = [_input]; + while (encodeStack.length) { + const input = encodeStack.pop(); + ensureSpace(typeof input === "string" ? input.length * 4 : 64); + if (typeof input === "string") { + if (USE_BUFFER) { + encodeHeader(majorUtf8String, Buffer.byteLength(input)); + cursor += data.write(input, cursor); } - } - if (stack.length > 0) { - return _this.assignOrPush(s, nodeName, obj); - } else { - if (_this.options.explicitRoot) { - old = obj; - obj = {}; - obj[nodeName] = old; - } - _this.resultObject = obj; - _this.saxParser.ended = true; - return _this.emit("end", _this.resultObject); - } - }; - })(this); - ontext = (function(_this) { - return function(text) { - var charChild, s; - s = stack[stack.length - 1]; - if (s) { - s[charkey] += text; - if (_this.options.explicitChildren && _this.options.preserveChildrenOrder && _this.options.charsAsChildren && (_this.options.includeWhiteChars || text.replace(/\\n/g, '').trim() !== '')) { - s[_this.options.childkey] = s[_this.options.childkey] || []; - charChild = { - '#name': '__text__' - }; - charChild[charkey] = text; - if (_this.options.normalize) { - charChild[charkey] = charChild[charkey].replace(/\s{2,}/g, " ").trim(); - } - s[_this.options.childkey].push(charChild); + else { + const bytes = utilUtf8.fromUtf8(input); + encodeHeader(majorUtf8String, bytes.byteLength); + data.set(bytes, cursor); + cursor += bytes.byteLength; } - return s; - } - }; - })(this); - this.saxParser.ontext = ontext; - return this.saxParser.oncdata = (function(_this) { - return function(text) { - var s; - s = ontext(text); - if (s) { - return s.cdata = true; - } - }; - })(this); - }; - - Parser.prototype.parseString = function(str, cb) { - var err; - if ((cb != null) && typeof cb === "function") { - this.on("end", function(result) { - this.reset(); - return cb(null, result); - }); - this.on("error", function(err) { - this.reset(); - return cb(err); - }); - } - try { - str = str.toString(); - if (str.trim() === '') { - this.emit("end", null); - return true; + continue; + } + else if (typeof input === "number") { + if (Number.isInteger(input)) { + const nonNegative = input >= 0; + const major = nonNegative ? majorUint64 : majorNegativeInt64; + const value = nonNegative ? input : -input - 1; + if (value < 24) { + data[cursor++] = (major << 5) | value; + } + else if (value < 256) { + data[cursor++] = (major << 5) | 24; + data[cursor++] = value; + } + else if (value < 65536) { + data[cursor++] = (major << 5) | extendedFloat16; + data[cursor++] = value >> 8; + data[cursor++] = value; + } + else if (value < 4294967296) { + data[cursor++] = (major << 5) | extendedFloat32; + dataView.setUint32(cursor, value); + cursor += 4; + } + else { + data[cursor++] = (major << 5) | extendedFloat64; + dataView.setBigUint64(cursor, BigInt(value)); + cursor += 8; + } + continue; + } + data[cursor++] = (majorSpecial << 5) | extendedFloat64; + dataView.setFloat64(cursor, input); + cursor += 8; + continue; + } + else if (typeof input === "bigint") { + const nonNegative = input >= 0; + const major = nonNegative ? majorUint64 : majorNegativeInt64; + const value = nonNegative ? input : -input - BigInt(1); + const n = Number(value); + if (n < 24) { + data[cursor++] = (major << 5) | n; + } + else if (n < 256) { + data[cursor++] = (major << 5) | 24; + data[cursor++] = n; + } + else if (n < 65536) { + data[cursor++] = (major << 5) | extendedFloat16; + data[cursor++] = n >> 8; + data[cursor++] = n & 0b1111_1111; + } + else if (n < 4294967296) { + data[cursor++] = (major << 5) | extendedFloat32; + dataView.setUint32(cursor, n); + cursor += 4; + } + else if (value < BigInt("18446744073709551616")) { + data[cursor++] = (major << 5) | extendedFloat64; + dataView.setBigUint64(cursor, value); + cursor += 8; + } + else { + const binaryBigInt = value.toString(2); + const bigIntBytes = new Uint8Array(Math.ceil(binaryBigInt.length / 8)); + let b = value; + let i = 0; + while (bigIntBytes.byteLength - ++i >= 0) { + bigIntBytes[bigIntBytes.byteLength - i] = Number(b & BigInt(255)); + b >>= BigInt(8); + } + ensureSpace(bigIntBytes.byteLength * 2); + data[cursor++] = nonNegative ? 0b110_00010 : 0b110_00011; + if (USE_BUFFER) { + encodeHeader(majorUnstructuredByteString, Buffer.byteLength(bigIntBytes)); + } + else { + encodeHeader(majorUnstructuredByteString, bigIntBytes.byteLength); + } + data.set(bigIntBytes, cursor); + cursor += bigIntBytes.byteLength; + } + continue; } - str = bom.stripBOM(str); - if (this.options.async) { - this.remaining = str; - setImmediate(this.processAsync); - return this.saxParser; + else if (input === null) { + data[cursor++] = (majorSpecial << 5) | specialNull; + continue; } - return this.saxParser.write(str).close(); - } catch (error1) { - err = error1; - if (!(this.saxParser.errThrown || this.saxParser.ended)) { - this.emit('error', err); - return this.saxParser.errThrown = true; - } else if (this.saxParser.ended) { - throw err; + else if (typeof input === "boolean") { + data[cursor++] = (majorSpecial << 5) | (input ? specialTrue : specialFalse); + continue; } - } - }; - - return Parser; + else if (typeof input === "undefined") { + throw new Error("@smithy/core/cbor: client may not serialize undefined value."); + } + else if (Array.isArray(input)) { + for (let i = input.length - 1; i >= 0; --i) { + encodeStack.push(input[i]); + } + encodeHeader(majorList, input.length); + continue; + } + else if (typeof input.byteLength === "number") { + ensureSpace(input.length * 2); + encodeHeader(majorUnstructuredByteString, input.length); + data.set(input, cursor); + cursor += input.byteLength; + continue; + } + else if (typeof input === "object") { + if (input instanceof serde.NumericValue) { + const decimalIndex = input.string.indexOf("."); + const exponent = decimalIndex === -1 ? 0 : decimalIndex - input.string.length + 1; + const mantissa = BigInt(input.string.replace(".", "")); + data[cursor++] = 0b110_00100; + encodeStack.push(mantissa); + encodeStack.push(exponent); + encodeHeader(majorList, 2); + continue; + } + if (input[tagSymbol]) { + if ("tag" in input && "value" in input) { + encodeStack.push(input.value); + encodeHeader(majorTag, input.tag); + continue; + } + else { + throw new Error("tag encountered with missing fields, need 'tag' and 'value', found: " + JSON.stringify(input)); + } + } + const keys = Object.keys(input); + for (let i = keys.length - 1; i >= 0; --i) { + const key = keys[i]; + encodeStack.push(input[key]); + encodeStack.push(key); + } + encodeHeader(majorMap, keys.length); + continue; + } + throw new Error(`data type ${input?.constructor?.name ?? typeof input} not compatible for encoding.`); + } +} - })(events.EventEmitter); +const cbor = { + deserialize(payload) { + setPayload(payload); + return decode(0, payload.length); + }, + serialize(input) { + try { + encode(input); + return toUint8Array(); + } + catch (e) { + toUint8Array(); + throw e; + } + }, + resizeEncodingBuffer(size) { + resize(size); + }, +}; - exports.parseString = function(str, a, b) { - var cb, options, parser; - if (b != null) { - if (typeof b === 'function') { - cb = b; - } - if (typeof a === 'object') { - options = a; - } - } else { - if (typeof a === 'function') { - cb = a; - } - options = {}; +const parseCborBody = (streamBody, context) => { + return protocols.collectBody(streamBody, context).then(async (bytes) => { + if (bytes.length) { + try { + return cbor.deserialize(bytes); + } + catch (e) { + Object.defineProperty(e, "$responseBodyText", { + value: context.utf8Encoder(bytes), + }); + throw e; + } + } + return {}; + }); +}; +const dateToTag = (date) => { + return tag({ + tag: 1, + value: date.getTime() / 1000, + }); +}; +const parseCborErrorBody = async (errorBody, context) => { + const value = await parseCborBody(errorBody, context); + value.message = value.message ?? value.Message; + return value; +}; +const loadSmithyRpcV2CborErrorCode = (output, data) => { + const sanitizeErrorCode = (rawValue) => { + let cleanValue = rawValue; + if (typeof cleanValue === "number") { + cleanValue = cleanValue.toString(); + } + if (cleanValue.indexOf(",") >= 0) { + cleanValue = cleanValue.split(",")[0]; + } + if (cleanValue.indexOf(":") >= 0) { + cleanValue = cleanValue.split(":")[0]; + } + if (cleanValue.indexOf("#") >= 0) { + cleanValue = cleanValue.split("#")[1]; + } + return cleanValue; + }; + if (data["__type"] !== undefined) { + return sanitizeErrorCode(data["__type"]); } - parser = new exports.Parser(options); - return parser.parseString(str, cb); - }; - -}).call(this); + const codeKey = Object.keys(data).find((key) => key.toLowerCase() === "code"); + if (codeKey && data[codeKey] !== undefined) { + return sanitizeErrorCode(data[codeKey]); + } +}; +const checkCborResponse = (response) => { + if (String(response.headers["smithy-protocol"]).toLowerCase() !== "rpc-v2-cbor") { + throw new Error("Malformed RPCv2 CBOR response, status: " + response.statusCode); + } +}; +const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => { + const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); + const contents = { + protocol, + hostname, + port, + method: "POST", + path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path, + headers: { + ...headers, + }, + }; + if (resolvedHostname !== undefined) { + contents.hostname = resolvedHostname; + } + if (body !== undefined) { + contents.body = body; + try { + contents.headers["content-length"] = String(utilBodyLengthBrowser.calculateBodyLength(body)); + } + catch (e) { } + } + return new protocolHttp.HttpRequest(contents); +}; +class CborCodec extends protocols.SerdeContext { + createSerializer() { + const serializer = new CborShapeSerializer(); + serializer.setSerdeContext(this.serdeContext); + return serializer; + } + createDeserializer() { + const deserializer = new CborShapeDeserializer(); + deserializer.setSerdeContext(this.serdeContext); + return deserializer; + } +} +class CborShapeSerializer extends protocols.SerdeContext { + value; + write(schema, value) { + this.value = this.serialize(schema, value); + } + serialize(schema$1, source) { + const ns = schema.NormalizedSchema.of(schema$1); + if (source == null) { + if (ns.isIdempotencyToken()) { + return serde.generateIdempotencyToken(); + } + return source; + } + if (ns.isBlobSchema()) { + if (typeof source === "string") { + return (this.serdeContext?.base64Decoder ?? utilBase64.fromBase64)(source); + } + return source; + } + if (ns.isTimestampSchema()) { + if (typeof source === "number" || typeof source === "bigint") { + return dateToTag(new Date((Number(source) / 1000) | 0)); + } + return dateToTag(source); + } + if (typeof source === "function" || typeof source === "object") { + const sourceObject = source; + if (ns.isListSchema() && Array.isArray(sourceObject)) { + const sparse = !!ns.getMergedTraits().sparse; + const newArray = []; + let i = 0; + for (const item of sourceObject) { + const value = this.serialize(ns.getValueSchema(), item); + if (value != null || sparse) { + newArray[i++] = value; + } + } + return newArray; + } + if (sourceObject instanceof Date) { + return dateToTag(sourceObject); + } + const newObject = {}; + if (ns.isMapSchema()) { + const sparse = !!ns.getMergedTraits().sparse; + for (const key of Object.keys(sourceObject)) { + const value = this.serialize(ns.getValueSchema(), sourceObject[key]); + if (value != null || sparse) { + newObject[key] = value; + } + } + } + else if (ns.isStructSchema()) { + for (const [key, memberSchema] of ns.structIterator()) { + const value = this.serialize(memberSchema, sourceObject[key]); + if (value != null) { + newObject[key] = value; + } + } + const isUnion = ns.isUnionSchema(); + if (isUnion && Array.isArray(sourceObject.$unknown)) { + const [k, v] = sourceObject.$unknown; + newObject[k] = v; + } + else if (typeof sourceObject.__type === "string") { + for (const [k, v] of Object.entries(sourceObject)) { + if (!(k in newObject)) { + newObject[k] = this.serialize(15, v); + } + } + } + } + else if (ns.isDocumentSchema()) { + for (const key of Object.keys(sourceObject)) { + newObject[key] = this.serialize(ns.getValueSchema(), sourceObject[key]); + } + } + else if (ns.isBigDecimalSchema()) { + return sourceObject; + } + return newObject; + } + return source; + } + flush() { + const buffer = cbor.serialize(this.value); + this.value = undefined; + return buffer; + } +} +class CborShapeDeserializer extends protocols.SerdeContext { + read(schema, bytes) { + const data = cbor.deserialize(bytes); + return this.readValue(schema, data); + } + readValue(_schema, value) { + const ns = schema.NormalizedSchema.of(_schema); + if (ns.isTimestampSchema()) { + if (typeof value === "number") { + return serde._parseEpochTimestamp(value); + } + if (typeof value === "object") { + if (value.tag === 1 && "value" in value) { + return serde._parseEpochTimestamp(value.value); + } + } + } + if (ns.isBlobSchema()) { + if (typeof value === "string") { + return (this.serdeContext?.base64Decoder ?? utilBase64.fromBase64)(value); + } + return value; + } + if (typeof value === "undefined" || + typeof value === "boolean" || + typeof value === "number" || + typeof value === "string" || + typeof value === "bigint" || + typeof value === "symbol") { + return value; + } + else if (typeof value === "object") { + if (value === null) { + return null; + } + if ("byteLength" in value) { + return value; + } + if (value instanceof Date) { + return value; + } + if (ns.isDocumentSchema()) { + return value; + } + if (ns.isListSchema()) { + const newArray = []; + const memberSchema = ns.getValueSchema(); + const sparse = !!ns.getMergedTraits().sparse; + for (const item of value) { + const itemValue = this.readValue(memberSchema, item); + if (itemValue != null || sparse) { + newArray.push(itemValue); + } + } + return newArray; + } + const newObject = {}; + if (ns.isMapSchema()) { + const sparse = !!ns.getMergedTraits().sparse; + const targetSchema = ns.getValueSchema(); + for (const key of Object.keys(value)) { + const itemValue = this.readValue(targetSchema, value[key]); + if (itemValue != null || sparse) { + newObject[key] = itemValue; + } + } + } + else if (ns.isStructSchema()) { + const isUnion = ns.isUnionSchema(); + let keys; + if (isUnion) { + keys = new Set(Object.keys(value).filter((k) => k !== "__type")); + } + for (const [key, memberSchema] of ns.structIterator()) { + if (isUnion) { + keys.delete(key); + } + if (value[key] != null) { + newObject[key] = this.readValue(memberSchema, value[key]); + } + } + if (isUnion && keys?.size === 1 && Object.keys(newObject).length === 0) { + const k = keys.values().next().value; + newObject.$unknown = [k, value[k]]; + } + else if (typeof value.__type === "string") { + for (const [k, v] of Object.entries(value)) { + if (!(k in newObject)) { + newObject[k] = v; + } + } + } + } + else if (value instanceof serde.NumericValue) { + return value; + } + return newObject; + } + else { + return value; + } + } +} -/***/ }), +class SmithyRpcV2CborProtocol extends protocols.RpcProtocol { + codec = new CborCodec(); + serializer = this.codec.createSerializer(); + deserializer = this.codec.createDeserializer(); + constructor({ defaultNamespace }) { + super({ defaultNamespace }); + } + getShapeId() { + return "smithy.protocols#rpcv2Cbor"; + } + getPayloadCodec() { + return this.codec; + } + async serializeRequest(operationSchema, input, context) { + const request = await super.serializeRequest(operationSchema, input, context); + Object.assign(request.headers, { + "content-type": this.getDefaultContentType(), + "smithy-protocol": "rpc-v2-cbor", + accept: this.getDefaultContentType(), + }); + if (schema.deref(operationSchema.input) === "unit") { + delete request.body; + delete request.headers["content-type"]; + } + else { + if (!request.body) { + this.serializer.write(15, {}); + request.body = this.serializer.flush(); + } + try { + request.headers["content-length"] = String(request.body.byteLength); + } + catch (e) { } + } + const { service, operation } = utilMiddleware.getSmithyContext(context); + const path = `/service/${service}/operation/${operation}`; + if (request.path.endsWith("/")) { + request.path += path.slice(1); + } + else { + request.path += path; + } + return request; + } + async deserializeResponse(operationSchema, context, response) { + return super.deserializeResponse(operationSchema, context, response); + } + async handleError(operationSchema, context, response, dataObject, metadata) { + const errorName = loadSmithyRpcV2CborErrorCode(response, dataObject) ?? "Unknown"; + let namespace = this.options.defaultNamespace; + if (errorName.includes("#")) { + [namespace] = errorName.split("#"); + } + const errorMetadata = { + $metadata: metadata, + $fault: response.statusCode <= 500 ? "client" : "server", + }; + const registry = schema.TypeRegistry.for(namespace); + let errorSchema; + try { + errorSchema = registry.getSchema(errorName); + } + catch (e) { + if (dataObject.Message) { + dataObject.message = dataObject.Message; + } + const synthetic = schema.TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace); + const baseExceptionSchema = synthetic.getBaseException(); + if (baseExceptionSchema) { + const ErrorCtor = synthetic.getErrorCtor(baseExceptionSchema); + throw Object.assign(new ErrorCtor({ name: errorName }), errorMetadata, dataObject); + } + throw Object.assign(new Error(errorName), errorMetadata, dataObject); + } + const ns = schema.NormalizedSchema.of(errorSchema); + const ErrorCtor = registry.getErrorCtor(errorSchema); + const message = dataObject.message ?? dataObject.Message ?? "Unknown"; + const exception = new ErrorCtor(message); + const output = {}; + for (const [name, member] of ns.structIterator()) { + output[name] = this.deserializer.readValue(member, dataObject[name]); + } + throw Object.assign(exception, errorMetadata, { + $fault: ns.getMergedTraits().error, + message, + }, output); + } + getDefaultContentType() { + return "application/cbor"; + } +} -/***/ 1890: -/***/ (function(module) { +exports.CborCodec = CborCodec; +exports.CborShapeDeserializer = CborShapeDeserializer; +exports.CborShapeSerializer = CborShapeSerializer; +exports.SmithyRpcV2CborProtocol = SmithyRpcV2CborProtocol; +exports.buildHttpRpcRequest = buildHttpRpcRequest; +exports.cbor = cbor; +exports.checkCborResponse = checkCborResponse; +exports.dateToTag = dateToTag; +exports.loadSmithyRpcV2CborErrorCode = loadSmithyRpcV2CborErrorCode; +exports.parseCborBody = parseCborBody; +exports.parseCborErrorBody = parseCborErrorBody; +exports.tag = tag; +exports.tagSymbol = tagSymbol; -module.exports = {"version":"2.0","metadata":{"apiVersion":"2018-01-12","endpointPrefix":"dlm","jsonVersion":"1.1","protocol":"rest-json","serviceAbbreviation":"Amazon DLM","serviceFullName":"Amazon Data Lifecycle Manager","serviceId":"DLM","signatureVersion":"v4","signingName":"dlm","uid":"dlm-2018-01-12"},"operations":{"CreateLifecyclePolicy":{"http":{"requestUri":"/policies"},"input":{"type":"structure","required":["ExecutionRoleArn","Description","State","PolicyDetails"],"members":{"ExecutionRoleArn":{},"Description":{},"State":{},"PolicyDetails":{"shape":"S5"},"Tags":{"shape":"S13"}}},"output":{"type":"structure","members":{"PolicyId":{}}}},"DeleteLifecyclePolicy":{"http":{"method":"DELETE","requestUri":"/policies/{policyId}/"},"input":{"type":"structure","required":["PolicyId"],"members":{"PolicyId":{"location":"uri","locationName":"policyId"}}},"output":{"type":"structure","members":{}}},"GetLifecyclePolicies":{"http":{"method":"GET","requestUri":"/policies"},"input":{"type":"structure","members":{"PolicyIds":{"location":"querystring","locationName":"policyIds","type":"list","member":{}},"State":{"location":"querystring","locationName":"state"},"ResourceTypes":{"shape":"S7","location":"querystring","locationName":"resourceTypes"},"TargetTags":{"location":"querystring","locationName":"targetTags","type":"list","member":{}},"TagsToAdd":{"location":"querystring","locationName":"tagsToAdd","type":"list","member":{}}}},"output":{"type":"structure","members":{"Policies":{"type":"list","member":{"type":"structure","members":{"PolicyId":{},"Description":{},"State":{},"Tags":{"shape":"S13"}}}}}}},"GetLifecyclePolicy":{"http":{"method":"GET","requestUri":"/policies/{policyId}/"},"input":{"type":"structure","required":["PolicyId"],"members":{"PolicyId":{"location":"uri","locationName":"policyId"}}},"output":{"type":"structure","members":{"Policy":{"type":"structure","members":{"PolicyId":{},"Description":{},"State":{},"StatusMessage":{},"ExecutionRoleArn":{},"DateCreated":{"shape":"S1n"},"DateModified":{"shape":"S1n"},"PolicyDetails":{"shape":"S5"},"Tags":{"shape":"S13"},"PolicyArn":{}}}}}},"ListTagsForResource":{"http":{"method":"GET","requestUri":"/tags/{resourceArn}"},"input":{"type":"structure","required":["ResourceArn"],"members":{"ResourceArn":{"location":"uri","locationName":"resourceArn"}}},"output":{"type":"structure","members":{"Tags":{"shape":"S13"}}}},"TagResource":{"http":{"requestUri":"/tags/{resourceArn}"},"input":{"type":"structure","required":["ResourceArn","Tags"],"members":{"ResourceArn":{"location":"uri","locationName":"resourceArn"},"Tags":{"shape":"S13"}}},"output":{"type":"structure","members":{}}},"UntagResource":{"http":{"method":"DELETE","requestUri":"/tags/{resourceArn}"},"input":{"type":"structure","required":["ResourceArn","TagKeys"],"members":{"ResourceArn":{"location":"uri","locationName":"resourceArn"},"TagKeys":{"location":"querystring","locationName":"tagKeys","type":"list","member":{}}}},"output":{"type":"structure","members":{}}},"UpdateLifecyclePolicy":{"http":{"method":"PATCH","requestUri":"/policies/{policyId}"},"input":{"type":"structure","required":["PolicyId"],"members":{"PolicyId":{"location":"uri","locationName":"policyId"},"ExecutionRoleArn":{},"State":{},"Description":{},"PolicyDetails":{"shape":"S5"}}},"output":{"type":"structure","members":{}}}},"shapes":{"S5":{"type":"structure","members":{"PolicyType":{},"ResourceTypes":{"shape":"S7"},"TargetTags":{"type":"list","member":{"shape":"Sa"}},"Schedules":{"type":"list","member":{"type":"structure","members":{"Name":{},"CopyTags":{"type":"boolean"},"TagsToAdd":{"type":"list","member":{"shape":"Sa"}},"VariableTags":{"type":"list","member":{"shape":"Sa"}},"CreateRule":{"type":"structure","members":{"Interval":{"type":"integer"},"IntervalUnit":{},"Times":{"type":"list","member":{}},"CronExpression":{}}},"RetainRule":{"type":"structure","members":{"Count":{"type":"integer"},"Interval":{"type":"integer"},"IntervalUnit":{}}},"FastRestoreRule":{"type":"structure","required":["AvailabilityZones"],"members":{"Count":{"type":"integer"},"Interval":{"type":"integer"},"IntervalUnit":{},"AvailabilityZones":{"type":"list","member":{}}}},"CrossRegionCopyRules":{"type":"list","member":{"type":"structure","required":["TargetRegion","Encrypted"],"members":{"TargetRegion":{},"Encrypted":{"type":"boolean"},"CmkArn":{},"CopyTags":{"type":"boolean"},"RetainRule":{"type":"structure","members":{"Interval":{"type":"integer"},"IntervalUnit":{}}}}}}}}},"Parameters":{"type":"structure","members":{"ExcludeBootVolume":{"type":"boolean"}}}}},"S7":{"type":"list","member":{}},"Sa":{"type":"structure","required":["Key","Value"],"members":{"Key":{},"Value":{}}},"S13":{"type":"map","key":{},"value":{}},"S1n":{"type":"timestamp","timestampFormat":"iso8601"}}}; /***/ }), -/***/ 1894: -/***/ (function(module) { +/***/ 3422: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -module.exports = {"version":"2.0","metadata":{"apiVersion":"2018-03-01","endpointPrefix":"fsx","jsonVersion":"1.1","protocol":"json","serviceFullName":"Amazon FSx","serviceId":"FSx","signatureVersion":"v4","signingName":"fsx","targetPrefix":"AWSSimbaAPIService_v20180301","uid":"fsx-2018-03-01"},"operations":{"CancelDataRepositoryTask":{"input":{"type":"structure","required":["TaskId"],"members":{"TaskId":{}}},"output":{"type":"structure","members":{"Lifecycle":{},"TaskId":{}}},"idempotent":true},"CreateBackup":{"input":{"type":"structure","required":["FileSystemId"],"members":{"FileSystemId":{},"ClientRequestToken":{"idempotencyToken":true},"Tags":{"shape":"S8"}}},"output":{"type":"structure","members":{"Backup":{"shape":"Sd"}}},"idempotent":true},"CreateDataRepositoryTask":{"input":{"type":"structure","required":["Type","FileSystemId","Report"],"members":{"Type":{},"Paths":{"shape":"S20"},"FileSystemId":{},"Report":{"shape":"S22"},"ClientRequestToken":{"idempotencyToken":true},"Tags":{"shape":"S8"}}},"output":{"type":"structure","members":{"DataRepositoryTask":{"shape":"S26"}}},"idempotent":true},"CreateFileSystem":{"input":{"type":"structure","required":["FileSystemType","StorageCapacity","SubnetIds"],"members":{"ClientRequestToken":{"idempotencyToken":true},"FileSystemType":{},"StorageCapacity":{"type":"integer"},"StorageType":{},"SubnetIds":{"shape":"Sv"},"SecurityGroupIds":{"shape":"S2g"},"Tags":{"shape":"S8"},"KmsKeyId":{},"WindowsConfiguration":{"shape":"S2i"},"LustreConfiguration":{"shape":"S2l"}}},"output":{"type":"structure","members":{"FileSystem":{"shape":"Sn"}}}},"CreateFileSystemFromBackup":{"input":{"type":"structure","required":["BackupId","SubnetIds"],"members":{"BackupId":{},"ClientRequestToken":{"idempotencyToken":true},"SubnetIds":{"shape":"Sv"},"SecurityGroupIds":{"shape":"S2g"},"Tags":{"shape":"S8"},"WindowsConfiguration":{"shape":"S2i"},"LustreConfiguration":{"shape":"S2l"},"StorageType":{}}},"output":{"type":"structure","members":{"FileSystem":{"shape":"Sn"}}}},"DeleteBackup":{"input":{"type":"structure","required":["BackupId"],"members":{"BackupId":{},"ClientRequestToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"BackupId":{},"Lifecycle":{}}},"idempotent":true},"DeleteFileSystem":{"input":{"type":"structure","required":["FileSystemId"],"members":{"FileSystemId":{},"ClientRequestToken":{"idempotencyToken":true},"WindowsConfiguration":{"type":"structure","members":{"SkipFinalBackup":{"type":"boolean"},"FinalBackupTags":{"shape":"S8"}}},"LustreConfiguration":{"type":"structure","members":{"SkipFinalBackup":{"type":"boolean"},"FinalBackupTags":{"shape":"S8"}}}}},"output":{"type":"structure","members":{"FileSystemId":{},"Lifecycle":{},"WindowsResponse":{"type":"structure","members":{"FinalBackupId":{},"FinalBackupTags":{"shape":"S8"}}},"LustreResponse":{"type":"structure","members":{"FinalBackupId":{},"FinalBackupTags":{"shape":"S8"}}}}},"idempotent":true},"DescribeBackups":{"input":{"type":"structure","members":{"BackupIds":{"type":"list","member":{}},"Filters":{"type":"list","member":{"type":"structure","members":{"Name":{},"Values":{"type":"list","member":{}}}}},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"Backups":{"type":"list","member":{"shape":"Sd"}},"NextToken":{}}}},"DescribeDataRepositoryTasks":{"input":{"type":"structure","members":{"TaskIds":{"type":"list","member":{}},"Filters":{"type":"list","member":{"type":"structure","members":{"Name":{},"Values":{"type":"list","member":{}}}}},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"DataRepositoryTasks":{"type":"list","member":{"shape":"S26"}},"NextToken":{}}}},"DescribeFileSystems":{"input":{"type":"structure","members":{"FileSystemIds":{"type":"list","member":{}},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"FileSystems":{"type":"list","member":{"shape":"Sn"}},"NextToken":{}}}},"ListTagsForResource":{"input":{"type":"structure","required":["ResourceARN"],"members":{"ResourceARN":{},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"Tags":{"shape":"S8"},"NextToken":{}}}},"TagResource":{"input":{"type":"structure","required":["ResourceARN","Tags"],"members":{"ResourceARN":{},"Tags":{"shape":"S8"}}},"output":{"type":"structure","members":{}},"idempotent":true},"UntagResource":{"input":{"type":"structure","required":["ResourceARN","TagKeys"],"members":{"ResourceARN":{},"TagKeys":{"type":"list","member":{}}}},"output":{"type":"structure","members":{}},"idempotent":true},"UpdateFileSystem":{"input":{"type":"structure","required":["FileSystemId"],"members":{"FileSystemId":{},"ClientRequestToken":{"idempotencyToken":true},"StorageCapacity":{"type":"integer"},"WindowsConfiguration":{"type":"structure","members":{"WeeklyMaintenanceStartTime":{},"DailyAutomaticBackupStartTime":{},"AutomaticBackupRetentionDays":{"type":"integer"},"ThroughputCapacity":{"type":"integer"},"SelfManagedActiveDirectoryConfiguration":{"type":"structure","members":{"UserName":{},"Password":{"shape":"S2k"},"DnsIps":{"shape":"S17"}}}}},"LustreConfiguration":{"type":"structure","members":{"WeeklyMaintenanceStartTime":{},"DailyAutomaticBackupStartTime":{},"AutomaticBackupRetentionDays":{"type":"integer"},"AutoImportPolicy":{}}}}},"output":{"type":"structure","members":{"FileSystem":{"shape":"Sn"}}}}},"shapes":{"S8":{"type":"list","member":{"type":"structure","required":["Key","Value"],"members":{"Key":{},"Value":{}}}},"Sd":{"type":"structure","required":["BackupId","Lifecycle","Type","CreationTime","FileSystem"],"members":{"BackupId":{},"Lifecycle":{},"FailureDetails":{"type":"structure","members":{"Message":{}}},"Type":{},"ProgressPercent":{"type":"integer"},"CreationTime":{"type":"timestamp"},"KmsKeyId":{},"ResourceARN":{},"Tags":{"shape":"S8"},"FileSystem":{"shape":"Sn"},"DirectoryInformation":{"type":"structure","members":{"DomainName":{},"ActiveDirectoryId":{}}}}},"Sn":{"type":"structure","members":{"OwnerId":{},"CreationTime":{"type":"timestamp"},"FileSystemId":{},"FileSystemType":{},"Lifecycle":{},"FailureDetails":{"type":"structure","members":{"Message":{}}},"StorageCapacity":{"type":"integer"},"StorageType":{},"VpcId":{},"SubnetIds":{"shape":"Sv"},"NetworkInterfaceIds":{"type":"list","member":{}},"DNSName":{},"KmsKeyId":{},"ResourceARN":{},"Tags":{"shape":"S8"},"WindowsConfiguration":{"type":"structure","members":{"ActiveDirectoryId":{},"SelfManagedActiveDirectoryConfiguration":{"type":"structure","members":{"DomainName":{},"OrganizationalUnitDistinguishedName":{},"FileSystemAdministratorsGroup":{},"UserName":{},"DnsIps":{"shape":"S17"}}},"DeploymentType":{},"RemoteAdministrationEndpoint":{},"PreferredSubnetId":{},"PreferredFileServerIp":{},"ThroughputCapacity":{"type":"integer"},"MaintenanceOperationsInProgress":{"type":"list","member":{}},"WeeklyMaintenanceStartTime":{},"DailyAutomaticBackupStartTime":{},"AutomaticBackupRetentionDays":{"type":"integer"},"CopyTagsToBackups":{"type":"boolean"}}},"LustreConfiguration":{"type":"structure","members":{"WeeklyMaintenanceStartTime":{},"DataRepositoryConfiguration":{"type":"structure","members":{"Lifecycle":{},"ImportPath":{},"ExportPath":{},"ImportedFileChunkSize":{"type":"integer"},"AutoImportPolicy":{},"FailureDetails":{"type":"structure","members":{"Message":{}}}}},"DeploymentType":{},"PerUnitStorageThroughput":{"type":"integer"},"MountName":{},"DailyAutomaticBackupStartTime":{},"AutomaticBackupRetentionDays":{"type":"integer"},"CopyTagsToBackups":{"type":"boolean"}}},"AdministrativeActions":{"type":"list","member":{"type":"structure","members":{"AdministrativeActionType":{},"ProgressPercent":{"type":"integer"},"RequestTime":{"type":"timestamp"},"Status":{},"TargetFileSystemValues":{"shape":"Sn"},"FailureDetails":{"type":"structure","members":{"Message":{}}}}}}}},"Sv":{"type":"list","member":{}},"S17":{"type":"list","member":{}},"S20":{"type":"list","member":{}},"S22":{"type":"structure","required":["Enabled"],"members":{"Enabled":{"type":"boolean"},"Path":{},"Format":{},"Scope":{}}},"S26":{"type":"structure","required":["TaskId","Lifecycle","Type","CreationTime","FileSystemId"],"members":{"TaskId":{},"Lifecycle":{},"Type":{},"CreationTime":{"type":"timestamp"},"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"ResourceARN":{},"Tags":{"shape":"S8"},"FileSystemId":{},"Paths":{"shape":"S20"},"FailureDetails":{"type":"structure","members":{"Message":{}}},"Status":{"type":"structure","members":{"TotalCount":{"type":"long"},"SucceededCount":{"type":"long"},"FailedCount":{"type":"long"},"LastUpdatedTime":{"type":"timestamp"}}},"Report":{"shape":"S22"}}},"S2g":{"type":"list","member":{}},"S2i":{"type":"structure","required":["ThroughputCapacity"],"members":{"ActiveDirectoryId":{},"SelfManagedActiveDirectoryConfiguration":{"type":"structure","required":["DomainName","UserName","Password","DnsIps"],"members":{"DomainName":{},"OrganizationalUnitDistinguishedName":{},"FileSystemAdministratorsGroup":{},"UserName":{},"Password":{"shape":"S2k"},"DnsIps":{"shape":"S17"}}},"DeploymentType":{},"PreferredSubnetId":{},"ThroughputCapacity":{"type":"integer"},"WeeklyMaintenanceStartTime":{},"DailyAutomaticBackupStartTime":{},"AutomaticBackupRetentionDays":{"type":"integer"},"CopyTagsToBackups":{"type":"boolean"}}},"S2k":{"type":"string","sensitive":true},"S2l":{"type":"structure","members":{"WeeklyMaintenanceStartTime":{},"ImportPath":{},"ExportPath":{},"ImportedFileChunkSize":{"type":"integer"},"DeploymentType":{},"AutoImportPolicy":{},"PerUnitStorageThroughput":{"type":"integer"},"DailyAutomaticBackupStartTime":{},"AutomaticBackupRetentionDays":{"type":"integer"},"CopyTagsToBackups":{"type":"boolean"}}}}}; +"use strict"; -/***/ }), -/***/ 1904: -/***/ (function(module) { +var utilStream = __nccwpck_require__(4252); +var schema = __nccwpck_require__(6890); +var serde = __nccwpck_require__(2430); +var protocolHttp = __nccwpck_require__(2356); +var utilBase64 = __nccwpck_require__(8385); +var utilUtf8 = __nccwpck_require__(1577); -module.exports = {"version":"2.0","metadata":{"apiVersion":"2012-08-10","endpointPrefix":"dynamodb","jsonVersion":"1.0","protocol":"json","serviceAbbreviation":"DynamoDB","serviceFullName":"Amazon DynamoDB","serviceId":"DynamoDB","signatureVersion":"v4","targetPrefix":"DynamoDB_20120810","uid":"dynamodb-2012-08-10"},"operations":{"BatchGetItem":{"input":{"type":"structure","required":["RequestItems"],"members":{"RequestItems":{"shape":"S2"},"ReturnConsumedCapacity":{}}},"output":{"type":"structure","members":{"Responses":{"type":"map","key":{},"value":{"shape":"Sr"}},"UnprocessedKeys":{"shape":"S2"},"ConsumedCapacity":{"shape":"St"}}},"endpointdiscovery":{}},"BatchWriteItem":{"input":{"type":"structure","required":["RequestItems"],"members":{"RequestItems":{"shape":"S10"},"ReturnConsumedCapacity":{},"ReturnItemCollectionMetrics":{}}},"output":{"type":"structure","members":{"UnprocessedItems":{"shape":"S10"},"ItemCollectionMetrics":{"shape":"S18"},"ConsumedCapacity":{"shape":"St"}}},"endpointdiscovery":{}},"CreateBackup":{"input":{"type":"structure","required":["TableName","BackupName"],"members":{"TableName":{},"BackupName":{}}},"output":{"type":"structure","members":{"BackupDetails":{"shape":"S1h"}}},"endpointdiscovery":{}},"CreateGlobalTable":{"input":{"type":"structure","required":["GlobalTableName","ReplicationGroup"],"members":{"GlobalTableName":{},"ReplicationGroup":{"shape":"S1p"}}},"output":{"type":"structure","members":{"GlobalTableDescription":{"shape":"S1t"}}},"endpointdiscovery":{}},"CreateTable":{"input":{"type":"structure","required":["AttributeDefinitions","TableName","KeySchema"],"members":{"AttributeDefinitions":{"shape":"S27"},"TableName":{},"KeySchema":{"shape":"S2b"},"LocalSecondaryIndexes":{"shape":"S2e"},"GlobalSecondaryIndexes":{"shape":"S2k"},"BillingMode":{},"ProvisionedThroughput":{"shape":"S2m"},"StreamSpecification":{"shape":"S2o"},"SSESpecification":{"shape":"S2r"},"Tags":{"shape":"S2u"}}},"output":{"type":"structure","members":{"TableDescription":{"shape":"S2z"}}},"endpointdiscovery":{}},"DeleteBackup":{"input":{"type":"structure","required":["BackupArn"],"members":{"BackupArn":{}}},"output":{"type":"structure","members":{"BackupDescription":{"shape":"S3o"}}},"endpointdiscovery":{}},"DeleteItem":{"input":{"type":"structure","required":["TableName","Key"],"members":{"TableName":{},"Key":{"shape":"S6"},"Expected":{"shape":"S41"},"ConditionalOperator":{},"ReturnValues":{},"ReturnConsumedCapacity":{},"ReturnItemCollectionMetrics":{},"ConditionExpression":{},"ExpressionAttributeNames":{"shape":"Sm"},"ExpressionAttributeValues":{"shape":"S49"}}},"output":{"type":"structure","members":{"Attributes":{"shape":"Ss"},"ConsumedCapacity":{"shape":"Su"},"ItemCollectionMetrics":{"shape":"S1a"}}},"endpointdiscovery":{}},"DeleteTable":{"input":{"type":"structure","required":["TableName"],"members":{"TableName":{}}},"output":{"type":"structure","members":{"TableDescription":{"shape":"S2z"}}},"endpointdiscovery":{}},"DescribeBackup":{"input":{"type":"structure","required":["BackupArn"],"members":{"BackupArn":{}}},"output":{"type":"structure","members":{"BackupDescription":{"shape":"S3o"}}},"endpointdiscovery":{}},"DescribeContinuousBackups":{"input":{"type":"structure","required":["TableName"],"members":{"TableName":{}}},"output":{"type":"structure","members":{"ContinuousBackupsDescription":{"shape":"S4i"}}},"endpointdiscovery":{}},"DescribeContributorInsights":{"input":{"type":"structure","required":["TableName"],"members":{"TableName":{},"IndexName":{}}},"output":{"type":"structure","members":{"TableName":{},"IndexName":{},"ContributorInsightsRuleList":{"type":"list","member":{}},"ContributorInsightsStatus":{},"LastUpdateDateTime":{"type":"timestamp"},"FailureException":{"type":"structure","members":{"ExceptionName":{},"ExceptionDescription":{}}}}}},"DescribeEndpoints":{"input":{"type":"structure","members":{}},"output":{"type":"structure","required":["Endpoints"],"members":{"Endpoints":{"type":"list","member":{"type":"structure","required":["Address","CachePeriodInMinutes"],"members":{"Address":{},"CachePeriodInMinutes":{"type":"long"}}}}}},"endpointoperation":true},"DescribeGlobalTable":{"input":{"type":"structure","required":["GlobalTableName"],"members":{"GlobalTableName":{}}},"output":{"type":"structure","members":{"GlobalTableDescription":{"shape":"S1t"}}},"endpointdiscovery":{}},"DescribeGlobalTableSettings":{"input":{"type":"structure","required":["GlobalTableName"],"members":{"GlobalTableName":{}}},"output":{"type":"structure","members":{"GlobalTableName":{},"ReplicaSettings":{"shape":"S53"}}},"endpointdiscovery":{}},"DescribeLimits":{"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"AccountMaxReadCapacityUnits":{"type":"long"},"AccountMaxWriteCapacityUnits":{"type":"long"},"TableMaxReadCapacityUnits":{"type":"long"},"TableMaxWriteCapacityUnits":{"type":"long"}}},"endpointdiscovery":{}},"DescribeTable":{"input":{"type":"structure","required":["TableName"],"members":{"TableName":{}}},"output":{"type":"structure","members":{"Table":{"shape":"S2z"}}},"endpointdiscovery":{}},"DescribeTableReplicaAutoScaling":{"input":{"type":"structure","required":["TableName"],"members":{"TableName":{}}},"output":{"type":"structure","members":{"TableAutoScalingDescription":{"shape":"S5k"}}}},"DescribeTimeToLive":{"input":{"type":"structure","required":["TableName"],"members":{"TableName":{}}},"output":{"type":"structure","members":{"TimeToLiveDescription":{"shape":"S3x"}}},"endpointdiscovery":{}},"GetItem":{"input":{"type":"structure","required":["TableName","Key"],"members":{"TableName":{},"Key":{"shape":"S6"},"AttributesToGet":{"shape":"Sj"},"ConsistentRead":{"type":"boolean"},"ReturnConsumedCapacity":{},"ProjectionExpression":{},"ExpressionAttributeNames":{"shape":"Sm"}}},"output":{"type":"structure","members":{"Item":{"shape":"Ss"},"ConsumedCapacity":{"shape":"Su"}}},"endpointdiscovery":{}},"ListBackups":{"input":{"type":"structure","members":{"TableName":{},"Limit":{"type":"integer"},"TimeRangeLowerBound":{"type":"timestamp"},"TimeRangeUpperBound":{"type":"timestamp"},"ExclusiveStartBackupArn":{},"BackupType":{}}},"output":{"type":"structure","members":{"BackupSummaries":{"type":"list","member":{"type":"structure","members":{"TableName":{},"TableId":{},"TableArn":{},"BackupArn":{},"BackupName":{},"BackupCreationDateTime":{"type":"timestamp"},"BackupExpiryDateTime":{"type":"timestamp"},"BackupStatus":{},"BackupType":{},"BackupSizeBytes":{"type":"long"}}}},"LastEvaluatedBackupArn":{}}},"endpointdiscovery":{}},"ListContributorInsights":{"input":{"type":"structure","members":{"TableName":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"ContributorInsightsSummaries":{"type":"list","member":{"type":"structure","members":{"TableName":{},"IndexName":{},"ContributorInsightsStatus":{}}}},"NextToken":{}}}},"ListGlobalTables":{"input":{"type":"structure","members":{"ExclusiveStartGlobalTableName":{},"Limit":{"type":"integer"},"RegionName":{}}},"output":{"type":"structure","members":{"GlobalTables":{"type":"list","member":{"type":"structure","members":{"GlobalTableName":{},"ReplicationGroup":{"shape":"S1p"}}}},"LastEvaluatedGlobalTableName":{}}},"endpointdiscovery":{}},"ListTables":{"input":{"type":"structure","members":{"ExclusiveStartTableName":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"TableNames":{"type":"list","member":{}},"LastEvaluatedTableName":{}}},"endpointdiscovery":{}},"ListTagsOfResource":{"input":{"type":"structure","required":["ResourceArn"],"members":{"ResourceArn":{},"NextToken":{}}},"output":{"type":"structure","members":{"Tags":{"shape":"S2u"},"NextToken":{}}},"endpointdiscovery":{}},"PutItem":{"input":{"type":"structure","required":["TableName","Item"],"members":{"TableName":{},"Item":{"shape":"S14"},"Expected":{"shape":"S41"},"ReturnValues":{},"ReturnConsumedCapacity":{},"ReturnItemCollectionMetrics":{},"ConditionalOperator":{},"ConditionExpression":{},"ExpressionAttributeNames":{"shape":"Sm"},"ExpressionAttributeValues":{"shape":"S49"}}},"output":{"type":"structure","members":{"Attributes":{"shape":"Ss"},"ConsumedCapacity":{"shape":"Su"},"ItemCollectionMetrics":{"shape":"S1a"}}},"endpointdiscovery":{}},"Query":{"input":{"type":"structure","required":["TableName"],"members":{"TableName":{},"IndexName":{},"Select":{},"AttributesToGet":{"shape":"Sj"},"Limit":{"type":"integer"},"ConsistentRead":{"type":"boolean"},"KeyConditions":{"type":"map","key":{},"value":{"shape":"S6o"}},"QueryFilter":{"shape":"S6p"},"ConditionalOperator":{},"ScanIndexForward":{"type":"boolean"},"ExclusiveStartKey":{"shape":"S6"},"ReturnConsumedCapacity":{},"ProjectionExpression":{},"FilterExpression":{},"KeyConditionExpression":{},"ExpressionAttributeNames":{"shape":"Sm"},"ExpressionAttributeValues":{"shape":"S49"}}},"output":{"type":"structure","members":{"Items":{"shape":"Sr"},"Count":{"type":"integer"},"ScannedCount":{"type":"integer"},"LastEvaluatedKey":{"shape":"S6"},"ConsumedCapacity":{"shape":"Su"}}},"endpointdiscovery":{}},"RestoreTableFromBackup":{"input":{"type":"structure","required":["TargetTableName","BackupArn"],"members":{"TargetTableName":{},"BackupArn":{},"BillingModeOverride":{},"GlobalSecondaryIndexOverride":{"shape":"S2k"},"LocalSecondaryIndexOverride":{"shape":"S2e"},"ProvisionedThroughputOverride":{"shape":"S2m"},"SSESpecificationOverride":{"shape":"S2r"}}},"output":{"type":"structure","members":{"TableDescription":{"shape":"S2z"}}},"endpointdiscovery":{}},"RestoreTableToPointInTime":{"input":{"type":"structure","required":["TargetTableName"],"members":{"SourceTableArn":{},"SourceTableName":{},"TargetTableName":{},"UseLatestRestorableTime":{"type":"boolean"},"RestoreDateTime":{"type":"timestamp"},"BillingModeOverride":{},"GlobalSecondaryIndexOverride":{"shape":"S2k"},"LocalSecondaryIndexOverride":{"shape":"S2e"},"ProvisionedThroughputOverride":{"shape":"S2m"},"SSESpecificationOverride":{"shape":"S2r"}}},"output":{"type":"structure","members":{"TableDescription":{"shape":"S2z"}}},"endpointdiscovery":{}},"Scan":{"input":{"type":"structure","required":["TableName"],"members":{"TableName":{},"IndexName":{},"AttributesToGet":{"shape":"Sj"},"Limit":{"type":"integer"},"Select":{},"ScanFilter":{"shape":"S6p"},"ConditionalOperator":{},"ExclusiveStartKey":{"shape":"S6"},"ReturnConsumedCapacity":{},"TotalSegments":{"type":"integer"},"Segment":{"type":"integer"},"ProjectionExpression":{},"FilterExpression":{},"ExpressionAttributeNames":{"shape":"Sm"},"ExpressionAttributeValues":{"shape":"S49"},"ConsistentRead":{"type":"boolean"}}},"output":{"type":"structure","members":{"Items":{"shape":"Sr"},"Count":{"type":"integer"},"ScannedCount":{"type":"integer"},"LastEvaluatedKey":{"shape":"S6"},"ConsumedCapacity":{"shape":"Su"}}},"endpointdiscovery":{}},"TagResource":{"input":{"type":"structure","required":["ResourceArn","Tags"],"members":{"ResourceArn":{},"Tags":{"shape":"S2u"}}},"endpointdiscovery":{}},"TransactGetItems":{"input":{"type":"structure","required":["TransactItems"],"members":{"TransactItems":{"type":"list","member":{"type":"structure","required":["Get"],"members":{"Get":{"type":"structure","required":["Key","TableName"],"members":{"Key":{"shape":"S6"},"TableName":{},"ProjectionExpression":{},"ExpressionAttributeNames":{"shape":"Sm"}}}}}},"ReturnConsumedCapacity":{}}},"output":{"type":"structure","members":{"ConsumedCapacity":{"shape":"St"},"Responses":{"type":"list","member":{"type":"structure","members":{"Item":{"shape":"Ss"}}}}}},"endpointdiscovery":{}},"TransactWriteItems":{"input":{"type":"structure","required":["TransactItems"],"members":{"TransactItems":{"type":"list","member":{"type":"structure","members":{"ConditionCheck":{"type":"structure","required":["Key","TableName","ConditionExpression"],"members":{"Key":{"shape":"S6"},"TableName":{},"ConditionExpression":{},"ExpressionAttributeNames":{"shape":"Sm"},"ExpressionAttributeValues":{"shape":"S49"},"ReturnValuesOnConditionCheckFailure":{}}},"Put":{"type":"structure","required":["Item","TableName"],"members":{"Item":{"shape":"S14"},"TableName":{},"ConditionExpression":{},"ExpressionAttributeNames":{"shape":"Sm"},"ExpressionAttributeValues":{"shape":"S49"},"ReturnValuesOnConditionCheckFailure":{}}},"Delete":{"type":"structure","required":["Key","TableName"],"members":{"Key":{"shape":"S6"},"TableName":{},"ConditionExpression":{},"ExpressionAttributeNames":{"shape":"Sm"},"ExpressionAttributeValues":{"shape":"S49"},"ReturnValuesOnConditionCheckFailure":{}}},"Update":{"type":"structure","required":["Key","UpdateExpression","TableName"],"members":{"Key":{"shape":"S6"},"UpdateExpression":{},"TableName":{},"ConditionExpression":{},"ExpressionAttributeNames":{"shape":"Sm"},"ExpressionAttributeValues":{"shape":"S49"},"ReturnValuesOnConditionCheckFailure":{}}}}}},"ReturnConsumedCapacity":{},"ReturnItemCollectionMetrics":{},"ClientRequestToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"ConsumedCapacity":{"shape":"St"},"ItemCollectionMetrics":{"shape":"S18"}}},"endpointdiscovery":{}},"UntagResource":{"input":{"type":"structure","required":["ResourceArn","TagKeys"],"members":{"ResourceArn":{},"TagKeys":{"type":"list","member":{}}}},"endpointdiscovery":{}},"UpdateContinuousBackups":{"input":{"type":"structure","required":["TableName","PointInTimeRecoverySpecification"],"members":{"TableName":{},"PointInTimeRecoverySpecification":{"type":"structure","required":["PointInTimeRecoveryEnabled"],"members":{"PointInTimeRecoveryEnabled":{"type":"boolean"}}}}},"output":{"type":"structure","members":{"ContinuousBackupsDescription":{"shape":"S4i"}}},"endpointdiscovery":{}},"UpdateContributorInsights":{"input":{"type":"structure","required":["TableName","ContributorInsightsAction"],"members":{"TableName":{},"IndexName":{},"ContributorInsightsAction":{}}},"output":{"type":"structure","members":{"TableName":{},"IndexName":{},"ContributorInsightsStatus":{}}}},"UpdateGlobalTable":{"input":{"type":"structure","required":["GlobalTableName","ReplicaUpdates"],"members":{"GlobalTableName":{},"ReplicaUpdates":{"type":"list","member":{"type":"structure","members":{"Create":{"type":"structure","required":["RegionName"],"members":{"RegionName":{}}},"Delete":{"type":"structure","required":["RegionName"],"members":{"RegionName":{}}}}}}}},"output":{"type":"structure","members":{"GlobalTableDescription":{"shape":"S1t"}}},"endpointdiscovery":{}},"UpdateGlobalTableSettings":{"input":{"type":"structure","required":["GlobalTableName"],"members":{"GlobalTableName":{},"GlobalTableBillingMode":{},"GlobalTableProvisionedWriteCapacityUnits":{"type":"long"},"GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate":{"shape":"S7z"},"GlobalTableGlobalSecondaryIndexSettingsUpdate":{"type":"list","member":{"type":"structure","required":["IndexName"],"members":{"IndexName":{},"ProvisionedWriteCapacityUnits":{"type":"long"},"ProvisionedWriteCapacityAutoScalingSettingsUpdate":{"shape":"S7z"}}}},"ReplicaSettingsUpdate":{"type":"list","member":{"type":"structure","required":["RegionName"],"members":{"RegionName":{},"ReplicaProvisionedReadCapacityUnits":{"type":"long"},"ReplicaProvisionedReadCapacityAutoScalingSettingsUpdate":{"shape":"S7z"},"ReplicaGlobalSecondaryIndexSettingsUpdate":{"type":"list","member":{"type":"structure","required":["IndexName"],"members":{"IndexName":{},"ProvisionedReadCapacityUnits":{"type":"long"},"ProvisionedReadCapacityAutoScalingSettingsUpdate":{"shape":"S7z"}}}}}}}}},"output":{"type":"structure","members":{"GlobalTableName":{},"ReplicaSettings":{"shape":"S53"}}},"endpointdiscovery":{}},"UpdateItem":{"input":{"type":"structure","required":["TableName","Key"],"members":{"TableName":{},"Key":{"shape":"S6"},"AttributeUpdates":{"type":"map","key":{},"value":{"type":"structure","members":{"Value":{"shape":"S8"},"Action":{}}}},"Expected":{"shape":"S41"},"ConditionalOperator":{},"ReturnValues":{},"ReturnConsumedCapacity":{},"ReturnItemCollectionMetrics":{},"UpdateExpression":{},"ConditionExpression":{},"ExpressionAttributeNames":{"shape":"Sm"},"ExpressionAttributeValues":{"shape":"S49"}}},"output":{"type":"structure","members":{"Attributes":{"shape":"Ss"},"ConsumedCapacity":{"shape":"Su"},"ItemCollectionMetrics":{"shape":"S1a"}}},"endpointdiscovery":{}},"UpdateTable":{"input":{"type":"structure","required":["TableName"],"members":{"AttributeDefinitions":{"shape":"S27"},"TableName":{},"BillingMode":{},"ProvisionedThroughput":{"shape":"S2m"},"GlobalSecondaryIndexUpdates":{"type":"list","member":{"type":"structure","members":{"Update":{"type":"structure","required":["IndexName","ProvisionedThroughput"],"members":{"IndexName":{},"ProvisionedThroughput":{"shape":"S2m"}}},"Create":{"type":"structure","required":["IndexName","KeySchema","Projection"],"members":{"IndexName":{},"KeySchema":{"shape":"S2b"},"Projection":{"shape":"S2g"},"ProvisionedThroughput":{"shape":"S2m"}}},"Delete":{"type":"structure","required":["IndexName"],"members":{"IndexName":{}}}}}},"StreamSpecification":{"shape":"S2o"},"SSESpecification":{"shape":"S2r"},"ReplicaUpdates":{"type":"list","member":{"type":"structure","members":{"Create":{"type":"structure","required":["RegionName"],"members":{"RegionName":{},"KMSMasterKeyId":{},"ProvisionedThroughputOverride":{"shape":"S20"},"GlobalSecondaryIndexes":{"shape":"S8o"}}},"Update":{"type":"structure","required":["RegionName"],"members":{"RegionName":{},"KMSMasterKeyId":{},"ProvisionedThroughputOverride":{"shape":"S20"},"GlobalSecondaryIndexes":{"shape":"S8o"}}},"Delete":{"type":"structure","required":["RegionName"],"members":{"RegionName":{}}}}}}}},"output":{"type":"structure","members":{"TableDescription":{"shape":"S2z"}}},"endpointdiscovery":{}},"UpdateTableReplicaAutoScaling":{"input":{"type":"structure","required":["TableName"],"members":{"GlobalSecondaryIndexUpdates":{"type":"list","member":{"type":"structure","members":{"IndexName":{},"ProvisionedWriteCapacityAutoScalingUpdate":{"shape":"S7z"}}}},"TableName":{},"ProvisionedWriteCapacityAutoScalingUpdate":{"shape":"S7z"},"ReplicaUpdates":{"type":"list","member":{"type":"structure","required":["RegionName"],"members":{"RegionName":{},"ReplicaGlobalSecondaryIndexUpdates":{"type":"list","member":{"type":"structure","members":{"IndexName":{},"ProvisionedReadCapacityAutoScalingUpdate":{"shape":"S7z"}}}},"ReplicaProvisionedReadCapacityAutoScalingUpdate":{"shape":"S7z"}}}}}},"output":{"type":"structure","members":{"TableAutoScalingDescription":{"shape":"S5k"}}}},"UpdateTimeToLive":{"input":{"type":"structure","required":["TableName","TimeToLiveSpecification"],"members":{"TableName":{},"TimeToLiveSpecification":{"shape":"S92"}}},"output":{"type":"structure","members":{"TimeToLiveSpecification":{"shape":"S92"}}},"endpointdiscovery":{}}},"shapes":{"S2":{"type":"map","key":{},"value":{"type":"structure","required":["Keys"],"members":{"Keys":{"type":"list","member":{"shape":"S6"}},"AttributesToGet":{"shape":"Sj"},"ConsistentRead":{"type":"boolean"},"ProjectionExpression":{},"ExpressionAttributeNames":{"shape":"Sm"}}}},"S6":{"type":"map","key":{},"value":{"shape":"S8"}},"S8":{"type":"structure","members":{"S":{},"N":{},"B":{"type":"blob"},"SS":{"type":"list","member":{}},"NS":{"type":"list","member":{}},"BS":{"type":"list","member":{"type":"blob"}},"M":{"type":"map","key":{},"value":{"shape":"S8"}},"L":{"type":"list","member":{"shape":"S8"}},"NULL":{"type":"boolean"},"BOOL":{"type":"boolean"}}},"Sj":{"type":"list","member":{}},"Sm":{"type":"map","key":{},"value":{}},"Sr":{"type":"list","member":{"shape":"Ss"}},"Ss":{"type":"map","key":{},"value":{"shape":"S8"}},"St":{"type":"list","member":{"shape":"Su"}},"Su":{"type":"structure","members":{"TableName":{},"CapacityUnits":{"type":"double"},"ReadCapacityUnits":{"type":"double"},"WriteCapacityUnits":{"type":"double"},"Table":{"shape":"Sw"},"LocalSecondaryIndexes":{"shape":"Sx"},"GlobalSecondaryIndexes":{"shape":"Sx"}}},"Sw":{"type":"structure","members":{"ReadCapacityUnits":{"type":"double"},"WriteCapacityUnits":{"type":"double"},"CapacityUnits":{"type":"double"}}},"Sx":{"type":"map","key":{},"value":{"shape":"Sw"}},"S10":{"type":"map","key":{},"value":{"type":"list","member":{"type":"structure","members":{"PutRequest":{"type":"structure","required":["Item"],"members":{"Item":{"shape":"S14"}}},"DeleteRequest":{"type":"structure","required":["Key"],"members":{"Key":{"shape":"S6"}}}}}}},"S14":{"type":"map","key":{},"value":{"shape":"S8"}},"S18":{"type":"map","key":{},"value":{"type":"list","member":{"shape":"S1a"}}},"S1a":{"type":"structure","members":{"ItemCollectionKey":{"type":"map","key":{},"value":{"shape":"S8"}},"SizeEstimateRangeGB":{"type":"list","member":{"type":"double"}}}},"S1h":{"type":"structure","required":["BackupArn","BackupName","BackupStatus","BackupType","BackupCreationDateTime"],"members":{"BackupArn":{},"BackupName":{},"BackupSizeBytes":{"type":"long"},"BackupStatus":{},"BackupType":{},"BackupCreationDateTime":{"type":"timestamp"},"BackupExpiryDateTime":{"type":"timestamp"}}},"S1p":{"type":"list","member":{"type":"structure","members":{"RegionName":{}}}},"S1t":{"type":"structure","members":{"ReplicationGroup":{"shape":"S1u"},"GlobalTableArn":{},"CreationDateTime":{"type":"timestamp"},"GlobalTableStatus":{},"GlobalTableName":{}}},"S1u":{"type":"list","member":{"type":"structure","members":{"RegionName":{},"ReplicaStatus":{},"ReplicaStatusDescription":{},"ReplicaStatusPercentProgress":{},"KMSMasterKeyId":{},"ProvisionedThroughputOverride":{"shape":"S20"},"GlobalSecondaryIndexes":{"type":"list","member":{"type":"structure","members":{"IndexName":{},"ProvisionedThroughputOverride":{"shape":"S20"}}}}}}},"S20":{"type":"structure","members":{"ReadCapacityUnits":{"type":"long"}}},"S27":{"type":"list","member":{"type":"structure","required":["AttributeName","AttributeType"],"members":{"AttributeName":{},"AttributeType":{}}}},"S2b":{"type":"list","member":{"type":"structure","required":["AttributeName","KeyType"],"members":{"AttributeName":{},"KeyType":{}}}},"S2e":{"type":"list","member":{"type":"structure","required":["IndexName","KeySchema","Projection"],"members":{"IndexName":{},"KeySchema":{"shape":"S2b"},"Projection":{"shape":"S2g"}}}},"S2g":{"type":"structure","members":{"ProjectionType":{},"NonKeyAttributes":{"type":"list","member":{}}}},"S2k":{"type":"list","member":{"type":"structure","required":["IndexName","KeySchema","Projection"],"members":{"IndexName":{},"KeySchema":{"shape":"S2b"},"Projection":{"shape":"S2g"},"ProvisionedThroughput":{"shape":"S2m"}}}},"S2m":{"type":"structure","required":["ReadCapacityUnits","WriteCapacityUnits"],"members":{"ReadCapacityUnits":{"type":"long"},"WriteCapacityUnits":{"type":"long"}}},"S2o":{"type":"structure","required":["StreamEnabled"],"members":{"StreamEnabled":{"type":"boolean"},"StreamViewType":{}}},"S2r":{"type":"structure","members":{"Enabled":{"type":"boolean"},"SSEType":{},"KMSMasterKeyId":{}}},"S2u":{"type":"list","member":{"type":"structure","required":["Key","Value"],"members":{"Key":{},"Value":{}}}},"S2z":{"type":"structure","members":{"AttributeDefinitions":{"shape":"S27"},"TableName":{},"KeySchema":{"shape":"S2b"},"TableStatus":{},"CreationDateTime":{"type":"timestamp"},"ProvisionedThroughput":{"shape":"S31"},"TableSizeBytes":{"type":"long"},"ItemCount":{"type":"long"},"TableArn":{},"TableId":{},"BillingModeSummary":{"shape":"S36"},"LocalSecondaryIndexes":{"type":"list","member":{"type":"structure","members":{"IndexName":{},"KeySchema":{"shape":"S2b"},"Projection":{"shape":"S2g"},"IndexSizeBytes":{"type":"long"},"ItemCount":{"type":"long"},"IndexArn":{}}}},"GlobalSecondaryIndexes":{"type":"list","member":{"type":"structure","members":{"IndexName":{},"KeySchema":{"shape":"S2b"},"Projection":{"shape":"S2g"},"IndexStatus":{},"Backfilling":{"type":"boolean"},"ProvisionedThroughput":{"shape":"S31"},"IndexSizeBytes":{"type":"long"},"ItemCount":{"type":"long"},"IndexArn":{}}}},"StreamSpecification":{"shape":"S2o"},"LatestStreamLabel":{},"LatestStreamArn":{},"GlobalTableVersion":{},"Replicas":{"shape":"S1u"},"RestoreSummary":{"type":"structure","required":["RestoreDateTime","RestoreInProgress"],"members":{"SourceBackupArn":{},"SourceTableArn":{},"RestoreDateTime":{"type":"timestamp"},"RestoreInProgress":{"type":"boolean"}}},"SSEDescription":{"shape":"S3h"},"ArchivalSummary":{"type":"structure","members":{"ArchivalDateTime":{"type":"timestamp"},"ArchivalReason":{},"ArchivalBackupArn":{}}}}},"S31":{"type":"structure","members":{"LastIncreaseDateTime":{"type":"timestamp"},"LastDecreaseDateTime":{"type":"timestamp"},"NumberOfDecreasesToday":{"type":"long"},"ReadCapacityUnits":{"type":"long"},"WriteCapacityUnits":{"type":"long"}}},"S36":{"type":"structure","members":{"BillingMode":{},"LastUpdateToPayPerRequestDateTime":{"type":"timestamp"}}},"S3h":{"type":"structure","members":{"Status":{},"SSEType":{},"KMSMasterKeyArn":{},"InaccessibleEncryptionDateTime":{"type":"timestamp"}}},"S3o":{"type":"structure","members":{"BackupDetails":{"shape":"S1h"},"SourceTableDetails":{"type":"structure","required":["TableName","TableId","KeySchema","TableCreationDateTime","ProvisionedThroughput"],"members":{"TableName":{},"TableId":{},"TableArn":{},"TableSizeBytes":{"type":"long"},"KeySchema":{"shape":"S2b"},"TableCreationDateTime":{"type":"timestamp"},"ProvisionedThroughput":{"shape":"S2m"},"ItemCount":{"type":"long"},"BillingMode":{}}},"SourceTableFeatureDetails":{"type":"structure","members":{"LocalSecondaryIndexes":{"type":"list","member":{"type":"structure","members":{"IndexName":{},"KeySchema":{"shape":"S2b"},"Projection":{"shape":"S2g"}}}},"GlobalSecondaryIndexes":{"type":"list","member":{"type":"structure","members":{"IndexName":{},"KeySchema":{"shape":"S2b"},"Projection":{"shape":"S2g"},"ProvisionedThroughput":{"shape":"S2m"}}}},"StreamDescription":{"shape":"S2o"},"TimeToLiveDescription":{"shape":"S3x"},"SSEDescription":{"shape":"S3h"}}}}},"S3x":{"type":"structure","members":{"TimeToLiveStatus":{},"AttributeName":{}}},"S41":{"type":"map","key":{},"value":{"type":"structure","members":{"Value":{"shape":"S8"},"Exists":{"type":"boolean"},"ComparisonOperator":{},"AttributeValueList":{"shape":"S45"}}}},"S45":{"type":"list","member":{"shape":"S8"}},"S49":{"type":"map","key":{},"value":{"shape":"S8"}},"S4i":{"type":"structure","required":["ContinuousBackupsStatus"],"members":{"ContinuousBackupsStatus":{},"PointInTimeRecoveryDescription":{"type":"structure","members":{"PointInTimeRecoveryStatus":{},"EarliestRestorableDateTime":{"type":"timestamp"},"LatestRestorableDateTime":{"type":"timestamp"}}}}},"S53":{"type":"list","member":{"type":"structure","required":["RegionName"],"members":{"RegionName":{},"ReplicaStatus":{},"ReplicaBillingModeSummary":{"shape":"S36"},"ReplicaProvisionedReadCapacityUnits":{"type":"long"},"ReplicaProvisionedReadCapacityAutoScalingSettings":{"shape":"S55"},"ReplicaProvisionedWriteCapacityUnits":{"type":"long"},"ReplicaProvisionedWriteCapacityAutoScalingSettings":{"shape":"S55"},"ReplicaGlobalSecondaryIndexSettings":{"type":"list","member":{"type":"structure","required":["IndexName"],"members":{"IndexName":{},"IndexStatus":{},"ProvisionedReadCapacityUnits":{"type":"long"},"ProvisionedReadCapacityAutoScalingSettings":{"shape":"S55"},"ProvisionedWriteCapacityUnits":{"type":"long"},"ProvisionedWriteCapacityAutoScalingSettings":{"shape":"S55"}}}}}}},"S55":{"type":"structure","members":{"MinimumUnits":{"type":"long"},"MaximumUnits":{"type":"long"},"AutoScalingDisabled":{"type":"boolean"},"AutoScalingRoleArn":{},"ScalingPolicies":{"type":"list","member":{"type":"structure","members":{"PolicyName":{},"TargetTrackingScalingPolicyConfiguration":{"type":"structure","required":["TargetValue"],"members":{"DisableScaleIn":{"type":"boolean"},"ScaleInCooldown":{"type":"integer"},"ScaleOutCooldown":{"type":"integer"},"TargetValue":{"type":"double"}}}}}}}},"S5k":{"type":"structure","members":{"TableName":{},"TableStatus":{},"Replicas":{"type":"list","member":{"type":"structure","members":{"RegionName":{},"GlobalSecondaryIndexes":{"type":"list","member":{"type":"structure","members":{"IndexName":{},"IndexStatus":{},"ProvisionedReadCapacityAutoScalingSettings":{"shape":"S55"},"ProvisionedWriteCapacityAutoScalingSettings":{"shape":"S55"}}}},"ReplicaProvisionedReadCapacityAutoScalingSettings":{"shape":"S55"},"ReplicaProvisionedWriteCapacityAutoScalingSettings":{"shape":"S55"},"ReplicaStatus":{}}}}}},"S6o":{"type":"structure","required":["ComparisonOperator"],"members":{"AttributeValueList":{"shape":"S45"},"ComparisonOperator":{}}},"S6p":{"type":"map","key":{},"value":{"shape":"S6o"}},"S7z":{"type":"structure","members":{"MinimumUnits":{"type":"long"},"MaximumUnits":{"type":"long"},"AutoScalingDisabled":{"type":"boolean"},"AutoScalingRoleArn":{},"ScalingPolicyUpdate":{"type":"structure","required":["TargetTrackingScalingPolicyConfiguration"],"members":{"PolicyName":{},"TargetTrackingScalingPolicyConfiguration":{"type":"structure","required":["TargetValue"],"members":{"DisableScaleIn":{"type":"boolean"},"ScaleInCooldown":{"type":"integer"},"ScaleOutCooldown":{"type":"integer"},"TargetValue":{"type":"double"}}}}}}},"S8o":{"type":"list","member":{"type":"structure","required":["IndexName"],"members":{"IndexName":{},"ProvisionedThroughputOverride":{"shape":"S20"}}}},"S92":{"type":"structure","required":["Enabled","AttributeName"],"members":{"Enabled":{"type":"boolean"},"AttributeName":{}}}}}; +const collectBody = async (streamBody = new Uint8Array(), context) => { + if (streamBody instanceof Uint8Array) { + return utilStream.Uint8ArrayBlobAdapter.mutate(streamBody); + } + if (!streamBody) { + return utilStream.Uint8ArrayBlobAdapter.mutate(new Uint8Array()); + } + const fromContext = context.streamCollector(streamBody); + return utilStream.Uint8ArrayBlobAdapter.mutate(await fromContext); +}; -/***/ }), +function extendedEncodeURIComponent(str) { + return encodeURIComponent(str).replace(/[!'()*]/g, function (c) { + return "%" + c.charCodeAt(0).toString(16).toUpperCase(); + }); +} -/***/ 1917: -/***/ (function(module, __unusedexports, __webpack_require__) { +class SerdeContext { + serdeContext; + setSerdeContext(serdeContext) { + this.serdeContext = serdeContext; + } +} -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +class HttpProtocol extends SerdeContext { + options; + constructor(options) { + super(); + this.options = options; + } + getRequestType() { + return protocolHttp.HttpRequest; + } + getResponseType() { + return protocolHttp.HttpResponse; + } + setSerdeContext(serdeContext) { + this.serdeContext = serdeContext; + this.serializer.setSerdeContext(serdeContext); + this.deserializer.setSerdeContext(serdeContext); + if (this.getPayloadCodec()) { + this.getPayloadCodec().setSerdeContext(serdeContext); + } + } + updateServiceEndpoint(request, endpoint) { + if ("url" in endpoint) { + request.protocol = endpoint.url.protocol; + request.hostname = endpoint.url.hostname; + request.port = endpoint.url.port ? Number(endpoint.url.port) : undefined; + request.path = endpoint.url.pathname; + request.fragment = endpoint.url.hash || void 0; + request.username = endpoint.url.username || void 0; + request.password = endpoint.url.password || void 0; + if (!request.query) { + request.query = {}; + } + for (const [k, v] of endpoint.url.searchParams.entries()) { + request.query[k] = v; + } + return request; + } + else { + request.protocol = endpoint.protocol; + request.hostname = endpoint.hostname; + request.port = endpoint.port ? Number(endpoint.port) : undefined; + request.path = endpoint.path; + request.query = { + ...endpoint.query, + }; + return request; + } + } + setHostPrefix(request, operationSchema, input) { + if (this.serdeContext?.disableHostPrefix) { + return; + } + const inputNs = schema.NormalizedSchema.of(operationSchema.input); + const opTraits = schema.translateTraits(operationSchema.traits ?? {}); + if (opTraits.endpoint) { + let hostPrefix = opTraits.endpoint?.[0]; + if (typeof hostPrefix === "string") { + const hostLabelInputs = [...inputNs.structIterator()].filter(([, member]) => member.getMergedTraits().hostLabel); + for (const [name] of hostLabelInputs) { + const replacement = input[name]; + if (typeof replacement !== "string") { + throw new Error(`@smithy/core/schema - ${name} in input must be a string as hostLabel.`); + } + hostPrefix = hostPrefix.replace(`{${name}}`, replacement); + } + request.hostname = hostPrefix + request.hostname; + } + } + } + deserializeMetadata(output) { + return { + httpStatusCode: output.statusCode, + requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"], + extendedRequestId: output.headers["x-amz-id-2"], + cfId: output.headers["x-amz-cf-id"], + }; + } + async serializeEventStream({ eventStream, requestSchema, initialRequest, }) { + const eventStreamSerde = await this.loadEventStreamCapability(); + return eventStreamSerde.serializeEventStream({ + eventStream, + requestSchema, + initialRequest, + }); + } + async deserializeEventStream({ response, responseSchema, initialResponseContainer, }) { + const eventStreamSerde = await this.loadEventStreamCapability(); + return eventStreamSerde.deserializeEventStream({ + response, + responseSchema, + initialResponseContainer, + }); + } + async loadEventStreamCapability() { + const { EventStreamSerde } = await __nccwpck_require__.e(/* import() */ 579).then(__nccwpck_require__.t.bind(__nccwpck_require__, 6579, 19)); + return new EventStreamSerde({ + marshaller: this.getEventStreamMarshaller(), + serializer: this.serializer, + deserializer: this.deserializer, + serdeContext: this.serdeContext, + defaultContentType: this.getDefaultContentType(), + }); + } + getDefaultContentType() { + throw new Error(`@smithy/core/protocols - ${this.constructor.name} getDefaultContentType() implementation missing.`); + } + async deserializeHttpMessage(schema, context, response, arg4, arg5) { + return []; + } + getEventStreamMarshaller() { + const context = this.serdeContext; + if (!context.eventStreamMarshaller) { + throw new Error("@smithy/core - HttpProtocol: eventStreamMarshaller missing in serdeContext."); + } + return context.eventStreamMarshaller; + } +} -apiLoader.services['codegurureviewer'] = {}; -AWS.CodeGuruReviewer = Service.defineService('codegurureviewer', ['2019-09-19']); -Object.defineProperty(apiLoader.services['codegurureviewer'], '2019-09-19', { - get: function get() { - var model = __webpack_require__(4912); - model.paginators = __webpack_require__(5388).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.CodeGuruReviewer; - - -/***/ }), - -/***/ 1920: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['es'] = {}; -AWS.ES = Service.defineService('es', ['2015-01-01']); -Object.defineProperty(apiLoader.services['es'], '2015-01-01', { - get: function get() { - var model = __webpack_require__(9307); - model.paginators = __webpack_require__(9743).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.ES; +class HttpBindingProtocol extends HttpProtocol { + async serializeRequest(operationSchema, _input, context) { + const input = { + ...(_input ?? {}), + }; + const serializer = this.serializer; + const query = {}; + const headers = {}; + const endpoint = await context.endpoint(); + const ns = schema.NormalizedSchema.of(operationSchema?.input); + const schema$1 = ns.getSchema(); + let hasNonHttpBindingMember = false; + let payload; + const request = new protocolHttp.HttpRequest({ + protocol: "", + hostname: "", + port: undefined, + path: "", + fragment: undefined, + query: query, + headers: headers, + body: undefined, + }); + if (endpoint) { + this.updateServiceEndpoint(request, endpoint); + this.setHostPrefix(request, operationSchema, input); + const opTraits = schema.translateTraits(operationSchema.traits); + if (opTraits.http) { + request.method = opTraits.http[0]; + const [path, search] = opTraits.http[1].split("?"); + if (request.path == "/") { + request.path = path; + } + else { + request.path += path; + } + const traitSearchParams = new URLSearchParams(search ?? ""); + Object.assign(query, Object.fromEntries(traitSearchParams)); + } + } + for (const [memberName, memberNs] of ns.structIterator()) { + const memberTraits = memberNs.getMergedTraits() ?? {}; + const inputMemberValue = input[memberName]; + if (inputMemberValue == null && !memberNs.isIdempotencyToken()) { + if (memberTraits.httpLabel) { + if (request.path.includes(`{${memberName}+}`) || request.path.includes(`{${memberName}}`)) { + throw new Error(`No value provided for input HTTP label: ${memberName}.`); + } + } + continue; + } + if (memberTraits.httpPayload) { + const isStreaming = memberNs.isStreaming(); + if (isStreaming) { + const isEventStream = memberNs.isStructSchema(); + if (isEventStream) { + if (input[memberName]) { + payload = await this.serializeEventStream({ + eventStream: input[memberName], + requestSchema: ns, + }); + } + } + else { + payload = inputMemberValue; + } + } + else { + serializer.write(memberNs, inputMemberValue); + payload = serializer.flush(); + } + delete input[memberName]; + } + else if (memberTraits.httpLabel) { + serializer.write(memberNs, inputMemberValue); + const replacement = serializer.flush(); + if (request.path.includes(`{${memberName}+}`)) { + request.path = request.path.replace(`{${memberName}+}`, replacement.split("/").map(extendedEncodeURIComponent).join("/")); + } + else if (request.path.includes(`{${memberName}}`)) { + request.path = request.path.replace(`{${memberName}}`, extendedEncodeURIComponent(replacement)); + } + delete input[memberName]; + } + else if (memberTraits.httpHeader) { + serializer.write(memberNs, inputMemberValue); + headers[memberTraits.httpHeader.toLowerCase()] = String(serializer.flush()); + delete input[memberName]; + } + else if (typeof memberTraits.httpPrefixHeaders === "string") { + for (const [key, val] of Object.entries(inputMemberValue)) { + const amalgam = memberTraits.httpPrefixHeaders + key; + serializer.write([memberNs.getValueSchema(), { httpHeader: amalgam }], val); + headers[amalgam.toLowerCase()] = serializer.flush(); + } + delete input[memberName]; + } + else if (memberTraits.httpQuery || memberTraits.httpQueryParams) { + this.serializeQuery(memberNs, inputMemberValue, query); + delete input[memberName]; + } + else { + hasNonHttpBindingMember = true; + } + } + if (hasNonHttpBindingMember && input) { + serializer.write(schema$1, input); + payload = serializer.flush(); + } + request.headers = headers; + request.query = query; + request.body = payload; + return request; + } + serializeQuery(ns, data, query) { + const serializer = this.serializer; + const traits = ns.getMergedTraits(); + if (traits.httpQueryParams) { + for (const [key, val] of Object.entries(data)) { + if (!(key in query)) { + const valueSchema = ns.getValueSchema(); + Object.assign(valueSchema.getMergedTraits(), { + ...traits, + httpQuery: key, + httpQueryParams: undefined, + }); + this.serializeQuery(valueSchema, val, query); + } + } + return; + } + if (ns.isListSchema()) { + const sparse = !!ns.getMergedTraits().sparse; + const buffer = []; + for (const item of data) { + serializer.write([ns.getValueSchema(), traits], item); + const serializable = serializer.flush(); + if (sparse || serializable !== undefined) { + buffer.push(serializable); + } + } + query[traits.httpQuery] = buffer; + } + else { + serializer.write([ns, traits], data); + query[traits.httpQuery] = serializer.flush(); + } + } + async deserializeResponse(operationSchema, context, response) { + const deserializer = this.deserializer; + const ns = schema.NormalizedSchema.of(operationSchema.output); + const dataObject = {}; + if (response.statusCode >= 300) { + const bytes = await collectBody(response.body, context); + if (bytes.byteLength > 0) { + Object.assign(dataObject, await deserializer.read(15, bytes)); + } + await this.handleError(operationSchema, context, response, dataObject, this.deserializeMetadata(response)); + throw new Error("@smithy/core/protocols - HTTP Protocol error handler failed to throw."); + } + for (const header in response.headers) { + const value = response.headers[header]; + delete response.headers[header]; + response.headers[header.toLowerCase()] = value; + } + const nonHttpBindingMembers = await this.deserializeHttpMessage(ns, context, response, dataObject); + if (nonHttpBindingMembers.length) { + const bytes = await collectBody(response.body, context); + if (bytes.byteLength > 0) { + const dataFromBody = await deserializer.read(ns, bytes); + for (const member of nonHttpBindingMembers) { + dataObject[member] = dataFromBody[member]; + } + } + } + else if (nonHttpBindingMembers.discardResponseBody) { + await collectBody(response.body, context); + } + dataObject.$metadata = this.deserializeMetadata(response); + return dataObject; + } + async deserializeHttpMessage(schema$1, context, response, arg4, arg5) { + let dataObject; + if (arg4 instanceof Set) { + dataObject = arg5; + } + else { + dataObject = arg4; + } + let discardResponseBody = true; + const deserializer = this.deserializer; + const ns = schema.NormalizedSchema.of(schema$1); + const nonHttpBindingMembers = []; + for (const [memberName, memberSchema] of ns.structIterator()) { + const memberTraits = memberSchema.getMemberTraits(); + if (memberTraits.httpPayload) { + discardResponseBody = false; + const isStreaming = memberSchema.isStreaming(); + if (isStreaming) { + const isEventStream = memberSchema.isStructSchema(); + if (isEventStream) { + dataObject[memberName] = await this.deserializeEventStream({ + response, + responseSchema: ns, + }); + } + else { + dataObject[memberName] = utilStream.sdkStreamMixin(response.body); + } + } + else if (response.body) { + const bytes = await collectBody(response.body, context); + if (bytes.byteLength > 0) { + dataObject[memberName] = await deserializer.read(memberSchema, bytes); + } + } + } + else if (memberTraits.httpHeader) { + const key = String(memberTraits.httpHeader).toLowerCase(); + const value = response.headers[key]; + if (null != value) { + if (memberSchema.isListSchema()) { + const headerListValueSchema = memberSchema.getValueSchema(); + headerListValueSchema.getMergedTraits().httpHeader = key; + let sections; + if (headerListValueSchema.isTimestampSchema() && + headerListValueSchema.getSchema() === 4) { + sections = serde.splitEvery(value, ",", 2); + } + else { + sections = serde.splitHeader(value); + } + const list = []; + for (const section of sections) { + list.push(await deserializer.read(headerListValueSchema, section.trim())); + } + dataObject[memberName] = list; + } + else { + dataObject[memberName] = await deserializer.read(memberSchema, value); + } + } + } + else if (memberTraits.httpPrefixHeaders !== undefined) { + dataObject[memberName] = {}; + for (const [header, value] of Object.entries(response.headers)) { + if (header.startsWith(memberTraits.httpPrefixHeaders)) { + const valueSchema = memberSchema.getValueSchema(); + valueSchema.getMergedTraits().httpHeader = header; + dataObject[memberName][header.slice(memberTraits.httpPrefixHeaders.length)] = await deserializer.read(valueSchema, value); + } + } + } + else if (memberTraits.httpResponseCode) { + dataObject[memberName] = response.statusCode; + } + else { + nonHttpBindingMembers.push(memberName); + } + } + nonHttpBindingMembers.discardResponseBody = discardResponseBody; + return nonHttpBindingMembers; + } +} +class RpcProtocol extends HttpProtocol { + async serializeRequest(operationSchema, input, context) { + const serializer = this.serializer; + const query = {}; + const headers = {}; + const endpoint = await context.endpoint(); + const ns = schema.NormalizedSchema.of(operationSchema?.input); + const schema$1 = ns.getSchema(); + let payload; + const request = new protocolHttp.HttpRequest({ + protocol: "", + hostname: "", + port: undefined, + path: "/", + fragment: undefined, + query: query, + headers: headers, + body: undefined, + }); + if (endpoint) { + this.updateServiceEndpoint(request, endpoint); + this.setHostPrefix(request, operationSchema, input); + } + const _input = { + ...input, + }; + if (input) { + const eventStreamMember = ns.getEventStreamMember(); + if (eventStreamMember) { + if (_input[eventStreamMember]) { + const initialRequest = {}; + for (const [memberName, memberSchema] of ns.structIterator()) { + if (memberName !== eventStreamMember && _input[memberName]) { + serializer.write(memberSchema, _input[memberName]); + initialRequest[memberName] = serializer.flush(); + } + } + payload = await this.serializeEventStream({ + eventStream: _input[eventStreamMember], + requestSchema: ns, + initialRequest, + }); + } + } + else { + serializer.write(schema$1, _input); + payload = serializer.flush(); + } + } + request.headers = headers; + request.query = query; + request.body = payload; + request.method = "POST"; + return request; + } + async deserializeResponse(operationSchema, context, response) { + const deserializer = this.deserializer; + const ns = schema.NormalizedSchema.of(operationSchema.output); + const dataObject = {}; + if (response.statusCode >= 300) { + const bytes = await collectBody(response.body, context); + if (bytes.byteLength > 0) { + Object.assign(dataObject, await deserializer.read(15, bytes)); + } + await this.handleError(operationSchema, context, response, dataObject, this.deserializeMetadata(response)); + throw new Error("@smithy/core/protocols - RPC Protocol error handler failed to throw."); + } + for (const header in response.headers) { + const value = response.headers[header]; + delete response.headers[header]; + response.headers[header.toLowerCase()] = value; + } + const eventStreamMember = ns.getEventStreamMember(); + if (eventStreamMember) { + dataObject[eventStreamMember] = await this.deserializeEventStream({ + response, + responseSchema: ns, + initialResponseContainer: dataObject, + }); + } + else { + const bytes = await collectBody(response.body, context); + if (bytes.byteLength > 0) { + Object.assign(dataObject, await deserializer.read(ns, bytes)); + } + } + dataObject.$metadata = this.deserializeMetadata(response); + return dataObject; + } +} -/***/ }), +const resolvedPath = (resolvedPath, input, memberName, labelValueProvider, uriLabel, isGreedyLabel) => { + if (input != null && input[memberName] !== undefined) { + const labelValue = labelValueProvider(); + if (labelValue.length <= 0) { + throw new Error("Empty value provided for input HTTP label: " + memberName + "."); + } + resolvedPath = resolvedPath.replace(uriLabel, isGreedyLabel + ? labelValue + .split("/") + .map((segment) => extendedEncodeURIComponent(segment)) + .join("/") + : extendedEncodeURIComponent(labelValue)); + } + else { + throw new Error("No value provided for input HTTP label: " + memberName + "."); + } + return resolvedPath; +}; -/***/ 1928: -/***/ (function(module, __unusedexports, __webpack_require__) { +function requestBuilder(input, context) { + return new RequestBuilder(input, context); +} +class RequestBuilder { + input; + context; + query = {}; + method = ""; + headers = {}; + path = ""; + body = null; + hostname = ""; + resolvePathStack = []; + constructor(input, context) { + this.input = input; + this.context = context; + } + async build() { + const { hostname, protocol = "https", port, path: basePath } = await this.context.endpoint(); + this.path = basePath; + for (const resolvePath of this.resolvePathStack) { + resolvePath(this.path); + } + return new protocolHttp.HttpRequest({ + protocol, + hostname: this.hostname || hostname, + port, + method: this.method, + path: this.path, + query: this.query, + body: this.body, + headers: this.headers, + }); + } + hn(hostname) { + this.hostname = hostname; + return this; + } + bp(uriLabel) { + this.resolvePathStack.push((basePath) => { + this.path = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + uriLabel; + }); + return this; + } + p(memberName, labelValueProvider, uriLabel, isGreedyLabel) { + this.resolvePathStack.push((path) => { + this.path = resolvedPath(path, this.input, memberName, labelValueProvider, uriLabel, isGreedyLabel); + }); + return this; + } + h(headers) { + this.headers = headers; + return this; + } + q(query) { + this.query = query; + return this; + } + b(body) { + this.body = body; + return this; + } + m(method) { + this.method = method; + return this; + } +} -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +function determineTimestampFormat(ns, settings) { + if (settings.timestampFormat.useTrait) { + if (ns.isTimestampSchema() && + (ns.getSchema() === 5 || + ns.getSchema() === 6 || + ns.getSchema() === 7)) { + return ns.getSchema(); + } + } + const { httpLabel, httpPrefixHeaders, httpHeader, httpQuery } = ns.getMergedTraits(); + const bindingFormat = settings.httpBindings + ? typeof httpPrefixHeaders === "string" || Boolean(httpHeader) + ? 6 + : Boolean(httpQuery) || Boolean(httpLabel) + ? 5 + : undefined + : undefined; + return bindingFormat ?? settings.timestampFormat.default; +} -apiLoader.services['emr'] = {}; -AWS.EMR = Service.defineService('emr', ['2009-03-31']); -Object.defineProperty(apiLoader.services['emr'], '2009-03-31', { - get: function get() { - var model = __webpack_require__(437); - model.paginators = __webpack_require__(240).pagination; - model.waiters = __webpack_require__(6023).waiters; - return model; - }, - enumerable: true, - configurable: true -}); +class FromStringShapeDeserializer extends SerdeContext { + settings; + constructor(settings) { + super(); + this.settings = settings; + } + read(_schema, data) { + const ns = schema.NormalizedSchema.of(_schema); + if (ns.isListSchema()) { + return serde.splitHeader(data).map((item) => this.read(ns.getValueSchema(), item)); + } + if (ns.isBlobSchema()) { + return (this.serdeContext?.base64Decoder ?? utilBase64.fromBase64)(data); + } + if (ns.isTimestampSchema()) { + const format = determineTimestampFormat(ns, this.settings); + switch (format) { + case 5: + return serde._parseRfc3339DateTimeWithOffset(data); + case 6: + return serde._parseRfc7231DateTime(data); + case 7: + return serde._parseEpochTimestamp(data); + default: + console.warn("Missing timestamp format, parsing value with Date constructor:", data); + return new Date(data); + } + } + if (ns.isStringSchema()) { + const mediaType = ns.getMergedTraits().mediaType; + let intermediateValue = data; + if (mediaType) { + if (ns.getMergedTraits().httpHeader) { + intermediateValue = this.base64ToUtf8(intermediateValue); + } + const isJson = mediaType === "application/json" || mediaType.endsWith("+json"); + if (isJson) { + intermediateValue = serde.LazyJsonString.from(intermediateValue); + } + return intermediateValue; + } + } + if (ns.isNumericSchema()) { + return Number(data); + } + if (ns.isBigIntegerSchema()) { + return BigInt(data); + } + if (ns.isBigDecimalSchema()) { + return new serde.NumericValue(data, "bigDecimal"); + } + if (ns.isBooleanSchema()) { + return String(data).toLowerCase() === "true"; + } + return data; + } + base64ToUtf8(base64String) { + return (this.serdeContext?.utf8Encoder ?? utilUtf8.toUtf8)((this.serdeContext?.base64Decoder ?? utilBase64.fromBase64)(base64String)); + } +} -module.exports = AWS.EMR; +class HttpInterceptingShapeDeserializer extends SerdeContext { + codecDeserializer; + stringDeserializer; + constructor(codecDeserializer, codecSettings) { + super(); + this.codecDeserializer = codecDeserializer; + this.stringDeserializer = new FromStringShapeDeserializer(codecSettings); + } + setSerdeContext(serdeContext) { + this.stringDeserializer.setSerdeContext(serdeContext); + this.codecDeserializer.setSerdeContext(serdeContext); + this.serdeContext = serdeContext; + } + read(schema$1, data) { + const ns = schema.NormalizedSchema.of(schema$1); + const traits = ns.getMergedTraits(); + const toString = this.serdeContext?.utf8Encoder ?? utilUtf8.toUtf8; + if (traits.httpHeader || traits.httpResponseCode) { + return this.stringDeserializer.read(ns, toString(data)); + } + if (traits.httpPayload) { + if (ns.isBlobSchema()) { + const toBytes = this.serdeContext?.utf8Decoder ?? utilUtf8.fromUtf8; + if (typeof data === "string") { + return toBytes(data); + } + return data; + } + else if (ns.isStringSchema()) { + if ("byteLength" in data) { + return toString(data); + } + return data; + } + } + return this.codecDeserializer.read(ns, data); + } +} +class ToStringShapeSerializer extends SerdeContext { + settings; + stringBuffer = ""; + constructor(settings) { + super(); + this.settings = settings; + } + write(schema$1, value) { + const ns = schema.NormalizedSchema.of(schema$1); + switch (typeof value) { + case "object": + if (value === null) { + this.stringBuffer = "null"; + return; + } + if (ns.isTimestampSchema()) { + if (!(value instanceof Date)) { + throw new Error(`@smithy/core/protocols - received non-Date value ${value} when schema expected Date in ${ns.getName(true)}`); + } + const format = determineTimestampFormat(ns, this.settings); + switch (format) { + case 5: + this.stringBuffer = value.toISOString().replace(".000Z", "Z"); + break; + case 6: + this.stringBuffer = serde.dateToUtcString(value); + break; + case 7: + this.stringBuffer = String(value.getTime() / 1000); + break; + default: + console.warn("Missing timestamp format, using epoch seconds", value); + this.stringBuffer = String(value.getTime() / 1000); + } + return; + } + if (ns.isBlobSchema() && "byteLength" in value) { + this.stringBuffer = (this.serdeContext?.base64Encoder ?? utilBase64.toBase64)(value); + return; + } + if (ns.isListSchema() && Array.isArray(value)) { + let buffer = ""; + for (const item of value) { + this.write([ns.getValueSchema(), ns.getMergedTraits()], item); + const headerItem = this.flush(); + const serialized = ns.getValueSchema().isTimestampSchema() ? headerItem : serde.quoteHeader(headerItem); + if (buffer !== "") { + buffer += ", "; + } + buffer += serialized; + } + this.stringBuffer = buffer; + return; + } + this.stringBuffer = JSON.stringify(value, null, 2); + break; + case "string": + const mediaType = ns.getMergedTraits().mediaType; + let intermediateValue = value; + if (mediaType) { + const isJson = mediaType === "application/json" || mediaType.endsWith("+json"); + if (isJson) { + intermediateValue = serde.LazyJsonString.from(intermediateValue); + } + if (ns.getMergedTraits().httpHeader) { + this.stringBuffer = (this.serdeContext?.base64Encoder ?? utilBase64.toBase64)(intermediateValue.toString()); + return; + } + } + this.stringBuffer = value; + break; + default: + if (ns.isIdempotencyToken()) { + this.stringBuffer = serde.generateIdempotencyToken(); + } + else { + this.stringBuffer = String(value); + } + } + } + flush() { + const buffer = this.stringBuffer; + this.stringBuffer = ""; + return buffer; + } +} -/***/ }), +class HttpInterceptingShapeSerializer { + codecSerializer; + stringSerializer; + buffer; + constructor(codecSerializer, codecSettings, stringSerializer = new ToStringShapeSerializer(codecSettings)) { + this.codecSerializer = codecSerializer; + this.stringSerializer = stringSerializer; + } + setSerdeContext(serdeContext) { + this.codecSerializer.setSerdeContext(serdeContext); + this.stringSerializer.setSerdeContext(serdeContext); + } + write(schema$1, value) { + const ns = schema.NormalizedSchema.of(schema$1); + const traits = ns.getMergedTraits(); + if (traits.httpHeader || traits.httpLabel || traits.httpQuery) { + this.stringSerializer.write(ns, value); + this.buffer = this.stringSerializer.flush(); + return; + } + return this.codecSerializer.write(ns, value); + } + flush() { + if (this.buffer !== undefined) { + const buffer = this.buffer; + this.buffer = undefined; + return buffer; + } + return this.codecSerializer.flush(); + } +} -/***/ 1944: -/***/ (function(module) { +exports.FromStringShapeDeserializer = FromStringShapeDeserializer; +exports.HttpBindingProtocol = HttpBindingProtocol; +exports.HttpInterceptingShapeDeserializer = HttpInterceptingShapeDeserializer; +exports.HttpInterceptingShapeSerializer = HttpInterceptingShapeSerializer; +exports.HttpProtocol = HttpProtocol; +exports.RequestBuilder = RequestBuilder; +exports.RpcProtocol = RpcProtocol; +exports.SerdeContext = SerdeContext; +exports.ToStringShapeSerializer = ToStringShapeSerializer; +exports.collectBody = collectBody; +exports.determineTimestampFormat = determineTimestampFormat; +exports.extendedEncodeURIComponent = extendedEncodeURIComponent; +exports.requestBuilder = requestBuilder; +exports.resolvedPath = resolvedPath; -module.exports = {"pagination":{"ListConfigs":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults","result_key":"configList"},"ListContacts":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults","result_key":"contactList"},"ListDataflowEndpointGroups":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults","result_key":"dataflowEndpointGroupList"},"ListGroundStations":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults","result_key":"groundStationList"},"ListMissionProfiles":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults","result_key":"missionProfileList"},"ListSatellites":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults","result_key":"satellites"}}}; /***/ }), -/***/ 1947: -/***/ (function(module, __unusedexports, __webpack_require__) { +/***/ 6890: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; -var Type = __webpack_require__(4945); - -var _toString = Object.prototype.toString; - -function resolveYamlPairs(data) { - if (data === null) return true; - - var index, length, pair, keys, result, - object = data; - - result = new Array(object.length); - - for (index = 0, length = object.length; index < length; index += 1) { - pair = object[index]; +var protocolHttp = __nccwpck_require__(2356); +var utilMiddleware = __nccwpck_require__(6324); - if (_toString.call(pair) !== '[object Object]') return false; +const deref = (schemaRef) => { + if (typeof schemaRef === "function") { + return schemaRef(); + } + return schemaRef; +}; - keys = Object.keys(pair); +const operation = (namespace, name, traits, input, output) => ({ + name, + namespace, + traits, + input, + output, +}); - if (keys.length !== 1) return false; +const schemaDeserializationMiddleware = (config) => (next, context) => async (args) => { + const { response } = await next(args); + const { operationSchema } = utilMiddleware.getSmithyContext(context); + const [, ns, n, t, i, o] = operationSchema ?? []; + try { + const parsed = await config.protocol.deserializeResponse(operation(ns, n, t, i, o), { + ...config, + ...context, + }, response); + return { + response, + output: parsed, + }; + } + catch (error) { + Object.defineProperty(error, "$response", { + value: response, + enumerable: false, + writable: false, + configurable: false, + }); + if (!("$metadata" in error)) { + const hint = `Deserialization error: to see the raw response, inspect the hidden field {error}.$response on this object.`; + try { + error.message += "\n " + hint; + } + catch (e) { + if (!context.logger || context.logger?.constructor?.name === "NoOpLogger") { + console.warn(hint); + } + else { + context.logger?.warn?.(hint); + } + } + if (typeof error.$responseBodyText !== "undefined") { + if (error.$response) { + error.$response.body = error.$responseBodyText; + } + } + try { + if (protocolHttp.HttpResponse.isInstance(response)) { + const { headers = {} } = response; + const headerEntries = Object.entries(headers); + error.$metadata = { + httpStatusCode: response.statusCode, + requestId: findHeader(/^x-[\w-]+-request-?id$/, headerEntries), + extendedRequestId: findHeader(/^x-[\w-]+-id-2$/, headerEntries), + cfId: findHeader(/^x-[\w-]+-cf-id$/, headerEntries), + }; + } + } + catch (e) { + } + } + throw error; + } +}; +const findHeader = (pattern, headers) => { + return (headers.find(([k]) => { + return k.match(pattern); + }) || [void 0, void 0])[1]; +}; - result[index] = [ keys[0], pair[keys[0]] ]; - } +const schemaSerializationMiddleware = (config) => (next, context) => async (args) => { + const { operationSchema } = utilMiddleware.getSmithyContext(context); + const [, ns, n, t, i, o] = operationSchema ?? []; + const endpoint = context.endpointV2?.url && config.urlParser + ? async () => config.urlParser(context.endpointV2.url) + : config.endpoint; + const request = await config.protocol.serializeRequest(operation(ns, n, t, i, o), args.input, { + ...config, + ...context, + endpoint, + }); + return next({ + ...args, + request, + }); +}; - return true; +const deserializerMiddlewareOption = { + name: "deserializerMiddleware", + step: "deserialize", + tags: ["DESERIALIZER"], + override: true, +}; +const serializerMiddlewareOption = { + name: "serializerMiddleware", + step: "serialize", + tags: ["SERIALIZER"], + override: true, +}; +function getSchemaSerdePlugin(config) { + return { + applyToStack: (commandStack) => { + commandStack.add(schemaSerializationMiddleware(config), serializerMiddlewareOption); + commandStack.add(schemaDeserializationMiddleware(config), deserializerMiddlewareOption); + config.protocol.setSerdeContext(config); + }, + }; } -function constructYamlPairs(data) { - if (data === null) return []; - - var index, length, pair, keys, result, - object = data; +class Schema { + name; + namespace; + traits; + static assign(instance, values) { + const schema = Object.assign(instance, values); + return schema; + } + static [Symbol.hasInstance](lhs) { + const isPrototype = this.prototype.isPrototypeOf(lhs); + if (!isPrototype && typeof lhs === "object" && lhs !== null) { + const list = lhs; + return list.symbol === this.symbol; + } + return isPrototype; + } + getName() { + return this.namespace + "#" + this.name; + } +} - result = new Array(object.length); +class ListSchema extends Schema { + static symbol = Symbol.for("@smithy/lis"); + name; + traits; + valueSchema; + symbol = ListSchema.symbol; +} +const list = (namespace, name, traits, valueSchema) => Schema.assign(new ListSchema(), { + name, + namespace, + traits, + valueSchema, +}); - for (index = 0, length = object.length; index < length; index += 1) { - pair = object[index]; +class MapSchema extends Schema { + static symbol = Symbol.for("@smithy/map"); + name; + traits; + keySchema; + valueSchema; + symbol = MapSchema.symbol; +} +const map = (namespace, name, traits, keySchema, valueSchema) => Schema.assign(new MapSchema(), { + name, + namespace, + traits, + keySchema, + valueSchema, +}); - keys = Object.keys(pair); +class OperationSchema extends Schema { + static symbol = Symbol.for("@smithy/ope"); + name; + traits; + input; + output; + symbol = OperationSchema.symbol; +} +const op = (namespace, name, traits, input, output) => Schema.assign(new OperationSchema(), { + name, + namespace, + traits, + input, + output, +}); - result[index] = [ keys[0], pair[keys[0]] ]; - } +class StructureSchema extends Schema { + static symbol = Symbol.for("@smithy/str"); + name; + traits; + memberNames; + memberList; + symbol = StructureSchema.symbol; +} +const struct = (namespace, name, traits, memberNames, memberList) => Schema.assign(new StructureSchema(), { + name, + namespace, + traits, + memberNames, + memberList, +}); - return result; +class ErrorSchema extends StructureSchema { + static symbol = Symbol.for("@smithy/err"); + ctor; + symbol = ErrorSchema.symbol; } +const error = (namespace, name, traits, memberNames, memberList, ctor) => Schema.assign(new ErrorSchema(), { + name, + namespace, + traits, + memberNames, + memberList, + ctor: null, +}); -module.exports = new Type('tag:yaml.org,2002:pairs', { - kind: 'sequence', - resolve: resolveYamlPairs, - construct: constructYamlPairs -}); - - -/***/ }), +function translateTraits(indicator) { + if (typeof indicator === "object") { + return indicator; + } + indicator = indicator | 0; + const traits = {}; + let i = 0; + for (const trait of [ + "httpLabel", + "idempotent", + "idempotencyToken", + "sensitive", + "httpPayload", + "httpResponseCode", + "httpQueryParams", + ]) { + if (((indicator >> i++) & 1) === 1) { + traits[trait] = 1; + } + } + return traits; +} -/***/ 1957: -/***/ (function(module) { +const anno = { + it: Symbol.for("@smithy/nor-struct-it"), +}; +class NormalizedSchema { + ref; + memberName; + static symbol = Symbol.for("@smithy/nor"); + symbol = NormalizedSchema.symbol; + name; + schema; + _isMemberSchema; + traits; + memberTraits; + normalizedTraits; + constructor(ref, memberName) { + this.ref = ref; + this.memberName = memberName; + const traitStack = []; + let _ref = ref; + let schema = ref; + this._isMemberSchema = false; + while (isMemberSchema(_ref)) { + traitStack.push(_ref[1]); + _ref = _ref[0]; + schema = deref(_ref); + this._isMemberSchema = true; + } + if (traitStack.length > 0) { + this.memberTraits = {}; + for (let i = traitStack.length - 1; i >= 0; --i) { + const traitSet = traitStack[i]; + Object.assign(this.memberTraits, translateTraits(traitSet)); + } + } + else { + this.memberTraits = 0; + } + if (schema instanceof NormalizedSchema) { + const computedMemberTraits = this.memberTraits; + Object.assign(this, schema); + this.memberTraits = Object.assign({}, computedMemberTraits, schema.getMemberTraits(), this.getMemberTraits()); + this.normalizedTraits = void 0; + this.memberName = memberName ?? schema.memberName; + return; + } + this.schema = deref(schema); + if (isStaticSchema(this.schema)) { + this.name = `${this.schema[1]}#${this.schema[2]}`; + this.traits = this.schema[3]; + } + else { + this.name = this.memberName ?? String(schema); + this.traits = 0; + } + if (this._isMemberSchema && !memberName) { + throw new Error(`@smithy/core/schema - NormalizedSchema member init ${this.getName(true)} missing member name.`); + } + } + static [Symbol.hasInstance](lhs) { + const isPrototype = this.prototype.isPrototypeOf(lhs); + if (!isPrototype && typeof lhs === "object" && lhs !== null) { + const ns = lhs; + return ns.symbol === this.symbol; + } + return isPrototype; + } + static of(ref) { + const sc = deref(ref); + if (sc instanceof NormalizedSchema) { + return sc; + } + if (isMemberSchema(sc)) { + const [ns, traits] = sc; + if (ns instanceof NormalizedSchema) { + Object.assign(ns.getMergedTraits(), translateTraits(traits)); + return ns; + } + throw new Error(`@smithy/core/schema - may not init unwrapped member schema=${JSON.stringify(ref, null, 2)}.`); + } + return new NormalizedSchema(sc); + } + getSchema() { + const sc = this.schema; + if (Array.isArray(sc) && sc[0] === 0) { + return sc[4]; + } + return sc; + } + getName(withNamespace = false) { + const { name } = this; + const short = !withNamespace && name && name.includes("#"); + return short ? name.split("#")[1] : name || undefined; + } + getMemberName() { + return this.memberName; + } + isMemberSchema() { + return this._isMemberSchema; + } + isListSchema() { + const sc = this.getSchema(); + return typeof sc === "number" + ? sc >= 64 && sc < 128 + : sc[0] === 1; + } + isMapSchema() { + const sc = this.getSchema(); + return typeof sc === "number" + ? sc >= 128 && sc <= 0b1111_1111 + : sc[0] === 2; + } + isStructSchema() { + const sc = this.getSchema(); + if (typeof sc !== "object") { + return false; + } + const id = sc[0]; + return (id === 3 || + id === -3 || + id === 4); + } + isUnionSchema() { + const sc = this.getSchema(); + if (typeof sc !== "object") { + return false; + } + return sc[0] === 4; + } + isBlobSchema() { + const sc = this.getSchema(); + return sc === 21 || sc === 42; + } + isTimestampSchema() { + const sc = this.getSchema(); + return (typeof sc === "number" && + sc >= 4 && + sc <= 7); + } + isUnitSchema() { + return this.getSchema() === "unit"; + } + isDocumentSchema() { + return this.getSchema() === 15; + } + isStringSchema() { + return this.getSchema() === 0; + } + isBooleanSchema() { + return this.getSchema() === 2; + } + isNumericSchema() { + return this.getSchema() === 1; + } + isBigIntegerSchema() { + return this.getSchema() === 17; + } + isBigDecimalSchema() { + return this.getSchema() === 19; + } + isStreaming() { + const { streaming } = this.getMergedTraits(); + return !!streaming || this.getSchema() === 42; + } + isIdempotencyToken() { + return !!this.getMergedTraits().idempotencyToken; + } + getMergedTraits() { + return (this.normalizedTraits ?? + (this.normalizedTraits = { + ...this.getOwnTraits(), + ...this.getMemberTraits(), + })); + } + getMemberTraits() { + return translateTraits(this.memberTraits); + } + getOwnTraits() { + return translateTraits(this.traits); + } + getKeySchema() { + const [isDoc, isMap] = [this.isDocumentSchema(), this.isMapSchema()]; + if (!isDoc && !isMap) { + throw new Error(`@smithy/core/schema - cannot get key for non-map: ${this.getName(true)}`); + } + const schema = this.getSchema(); + const memberSchema = isDoc + ? 15 + : schema[4] ?? 0; + return member([memberSchema, 0], "key"); + } + getValueSchema() { + const sc = this.getSchema(); + const [isDoc, isMap, isList] = [this.isDocumentSchema(), this.isMapSchema(), this.isListSchema()]; + const memberSchema = typeof sc === "number" + ? 0b0011_1111 & sc + : sc && typeof sc === "object" && (isMap || isList) + ? sc[3 + sc[0]] + : isDoc + ? 15 + : void 0; + if (memberSchema != null) { + return member([memberSchema, 0], isMap ? "value" : "member"); + } + throw new Error(`@smithy/core/schema - ${this.getName(true)} has no value member.`); + } + getMemberSchema(memberName) { + const struct = this.getSchema(); + if (this.isStructSchema() && struct[4].includes(memberName)) { + const i = struct[4].indexOf(memberName); + const memberSchema = struct[5][i]; + return member(isMemberSchema(memberSchema) ? memberSchema : [memberSchema, 0], memberName); + } + if (this.isDocumentSchema()) { + return member([15, 0], memberName); + } + throw new Error(`@smithy/core/schema - ${this.getName(true)} has no no member=${memberName}.`); + } + getMemberSchemas() { + const buffer = {}; + try { + for (const [k, v] of this.structIterator()) { + buffer[k] = v; + } + } + catch (ignored) { } + return buffer; + } + getEventStreamMember() { + if (this.isStructSchema()) { + for (const [memberName, memberSchema] of this.structIterator()) { + if (memberSchema.isStreaming() && memberSchema.isStructSchema()) { + return memberName; + } + } + } + return ""; + } + *structIterator() { + if (this.isUnitSchema()) { + return; + } + if (!this.isStructSchema()) { + throw new Error("@smithy/core/schema - cannot iterate non-struct schema."); + } + const struct = this.getSchema(); + const z = struct[4].length; + let it = struct[anno.it]; + if (it && z === it.length) { + yield* it; + return; + } + it = Array(z); + for (let i = 0; i < z; ++i) { + const k = struct[4][i]; + const v = member([struct[5][i], 0], k); + yield (it[i] = [k, v]); + } + struct[anno.it] = it; + } +} +function member(memberSchema, memberName) { + if (memberSchema instanceof NormalizedSchema) { + return Object.assign(memberSchema, { + memberName, + _isMemberSchema: true, + }); + } + const internalCtorAccess = NormalizedSchema; + return new internalCtorAccess(memberSchema, memberName); +} +const isMemberSchema = (sc) => Array.isArray(sc) && sc.length === 2; +const isStaticSchema = (sc) => Array.isArray(sc) && sc.length >= 5; + +class SimpleSchema extends Schema { + static symbol = Symbol.for("@smithy/sim"); + name; + schemaRef; + traits; + symbol = SimpleSchema.symbol; +} +const sim = (namespace, name, schemaRef, traits) => Schema.assign(new SimpleSchema(), { + name, + namespace, + traits, + schemaRef, +}); +const simAdapter = (namespace, name, traits, schemaRef) => Schema.assign(new SimpleSchema(), { + name, + namespace, + traits, + schemaRef, +}); -module.exports = {"pagination":{"ListClusters":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults","result_key":"ClusterInfoList"},"ListConfigurations":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults","result_key":"Configurations"},"ListKafkaVersions":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults","result_key":"KafkaVersions"},"ListNodes":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults","result_key":"NodeInfoList"},"ListClusterOperations":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults","result_key":"ClusterOperationInfoList"},"ListConfigurationRevisions":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults","result_key":"Revisions"}}}; +const SCHEMA = { + BLOB: 0b0001_0101, + STREAMING_BLOB: 0b0010_1010, + BOOLEAN: 0b0000_0010, + STRING: 0b0000_0000, + NUMERIC: 0b0000_0001, + BIG_INTEGER: 0b0001_0001, + BIG_DECIMAL: 0b0001_0011, + DOCUMENT: 0b0000_1111, + TIMESTAMP_DEFAULT: 0b0000_0100, + TIMESTAMP_DATE_TIME: 0b0000_0101, + TIMESTAMP_HTTP_DATE: 0b0000_0110, + TIMESTAMP_EPOCH_SECONDS: 0b0000_0111, + LIST_MODIFIER: 0b0100_0000, + MAP_MODIFIER: 0b1000_0000, +}; -/***/ }), +class TypeRegistry { + namespace; + schemas; + exceptions; + static registries = new Map(); + constructor(namespace, schemas = new Map(), exceptions = new Map()) { + this.namespace = namespace; + this.schemas = schemas; + this.exceptions = exceptions; + } + static for(namespace) { + if (!TypeRegistry.registries.has(namespace)) { + TypeRegistry.registries.set(namespace, new TypeRegistry(namespace)); + } + return TypeRegistry.registries.get(namespace); + } + register(shapeId, schema) { + const qualifiedName = this.normalizeShapeId(shapeId); + const registry = TypeRegistry.for(qualifiedName.split("#")[0]); + registry.schemas.set(qualifiedName, schema); + } + getSchema(shapeId) { + const id = this.normalizeShapeId(shapeId); + if (!this.schemas.has(id)) { + throw new Error(`@smithy/core/schema - schema not found for ${id}`); + } + return this.schemas.get(id); + } + registerError(es, ctor) { + const $error = es; + const registry = TypeRegistry.for($error[1]); + registry.schemas.set($error[1] + "#" + $error[2], $error); + registry.exceptions.set($error, ctor); + } + getErrorCtor(es) { + const $error = es; + const registry = TypeRegistry.for($error[1]); + return registry.exceptions.get($error); + } + getBaseException() { + for (const exceptionKey of this.exceptions.keys()) { + if (Array.isArray(exceptionKey)) { + const [, ns, name] = exceptionKey; + const id = ns + "#" + name; + if (id.startsWith("smithy.ts.sdk.synthetic.") && id.endsWith("ServiceException")) { + return exceptionKey; + } + } + } + return undefined; + } + find(predicate) { + return [...this.schemas.values()].find(predicate); + } + clear() { + this.schemas.clear(); + this.exceptions.clear(); + } + normalizeShapeId(shapeId) { + if (shapeId.includes("#")) { + return shapeId; + } + return this.namespace + "#" + shapeId; + } +} -/***/ 1969: -/***/ (function(module) { +exports.ErrorSchema = ErrorSchema; +exports.ListSchema = ListSchema; +exports.MapSchema = MapSchema; +exports.NormalizedSchema = NormalizedSchema; +exports.OperationSchema = OperationSchema; +exports.SCHEMA = SCHEMA; +exports.Schema = Schema; +exports.SimpleSchema = SimpleSchema; +exports.StructureSchema = StructureSchema; +exports.TypeRegistry = TypeRegistry; +exports.deref = deref; +exports.deserializerMiddlewareOption = deserializerMiddlewareOption; +exports.error = error; +exports.getSchemaSerdePlugin = getSchemaSerdePlugin; +exports.isStaticSchema = isStaticSchema; +exports.list = list; +exports.map = map; +exports.op = op; +exports.operation = operation; +exports.serializerMiddlewareOption = serializerMiddlewareOption; +exports.sim = sim; +exports.simAdapter = simAdapter; +exports.struct = struct; +exports.translateTraits = translateTraits; -module.exports = {"pagination":{}}; /***/ }), -/***/ 1971: -/***/ (function(module) { +/***/ 2430: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -module.exports = {"version":"2.0","metadata":{"apiVersion":"2016-11-01","endpointPrefix":"opsworks-cm","jsonVersion":"1.1","protocol":"json","serviceAbbreviation":"OpsWorksCM","serviceFullName":"AWS OpsWorks CM","serviceId":"OpsWorksCM","signatureVersion":"v4","signingName":"opsworks-cm","targetPrefix":"OpsWorksCM_V2016_11_01","uid":"opsworkscm-2016-11-01"},"operations":{"AssociateNode":{"input":{"type":"structure","required":["ServerName","NodeName","EngineAttributes"],"members":{"ServerName":{},"NodeName":{},"EngineAttributes":{"shape":"S4"}}},"output":{"type":"structure","members":{"NodeAssociationStatusToken":{}}}},"CreateBackup":{"input":{"type":"structure","required":["ServerName"],"members":{"ServerName":{},"Description":{},"Tags":{"shape":"Sc"}}},"output":{"type":"structure","members":{"Backup":{"shape":"Sh"}}}},"CreateServer":{"input":{"type":"structure","required":["Engine","ServerName","InstanceProfileArn","InstanceType","ServiceRoleArn"],"members":{"AssociatePublicIpAddress":{"type":"boolean"},"CustomDomain":{},"CustomCertificate":{},"CustomPrivateKey":{"type":"string","sensitive":true},"DisableAutomatedBackup":{"type":"boolean"},"Engine":{},"EngineModel":{},"EngineVersion":{},"EngineAttributes":{"shape":"S4"},"BackupRetentionCount":{"type":"integer"},"ServerName":{},"InstanceProfileArn":{},"InstanceType":{},"KeyPair":{},"PreferredMaintenanceWindow":{},"PreferredBackupWindow":{},"SecurityGroupIds":{"shape":"Sn"},"ServiceRoleArn":{},"SubnetIds":{"shape":"Sn"},"Tags":{"shape":"Sc"},"BackupId":{}}},"output":{"type":"structure","members":{"Server":{"shape":"Sz"}}}},"DeleteBackup":{"input":{"type":"structure","required":["BackupId"],"members":{"BackupId":{}}},"output":{"type":"structure","members":{}}},"DeleteServer":{"input":{"type":"structure","required":["ServerName"],"members":{"ServerName":{}}},"output":{"type":"structure","members":{}}},"DescribeAccountAttributes":{"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"Attributes":{"type":"list","member":{"type":"structure","members":{"Name":{},"Maximum":{"type":"integer"},"Used":{"type":"integer"}}}}}}},"DescribeBackups":{"input":{"type":"structure","members":{"BackupId":{},"ServerName":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"Backups":{"type":"list","member":{"shape":"Sh"}},"NextToken":{}}}},"DescribeEvents":{"input":{"type":"structure","required":["ServerName"],"members":{"ServerName":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"ServerEvents":{"type":"list","member":{"type":"structure","members":{"CreatedAt":{"type":"timestamp"},"ServerName":{},"Message":{},"LogUrl":{}}}},"NextToken":{}}}},"DescribeNodeAssociationStatus":{"input":{"type":"structure","required":["NodeAssociationStatusToken","ServerName"],"members":{"NodeAssociationStatusToken":{},"ServerName":{}}},"output":{"type":"structure","members":{"NodeAssociationStatus":{},"EngineAttributes":{"shape":"S4"}}}},"DescribeServers":{"input":{"type":"structure","members":{"ServerName":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"Servers":{"type":"list","member":{"shape":"Sz"}},"NextToken":{}}}},"DisassociateNode":{"input":{"type":"structure","required":["ServerName","NodeName"],"members":{"ServerName":{},"NodeName":{},"EngineAttributes":{"shape":"S4"}}},"output":{"type":"structure","members":{"NodeAssociationStatusToken":{}}}},"ExportServerEngineAttribute":{"input":{"type":"structure","required":["ExportAttributeName","ServerName"],"members":{"ExportAttributeName":{},"ServerName":{},"InputAttributes":{"shape":"S4"}}},"output":{"type":"structure","members":{"EngineAttribute":{"shape":"S5"},"ServerName":{}}}},"ListTagsForResource":{"input":{"type":"structure","required":["ResourceArn"],"members":{"ResourceArn":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"Tags":{"shape":"Sc"},"NextToken":{}}}},"RestoreServer":{"input":{"type":"structure","required":["BackupId","ServerName"],"members":{"BackupId":{},"ServerName":{},"InstanceType":{},"KeyPair":{}}},"output":{"type":"structure","members":{}}},"StartMaintenance":{"input":{"type":"structure","required":["ServerName"],"members":{"ServerName":{},"EngineAttributes":{"shape":"S4"}}},"output":{"type":"structure","members":{"Server":{"shape":"Sz"}}}},"TagResource":{"input":{"type":"structure","required":["ResourceArn","Tags"],"members":{"ResourceArn":{},"Tags":{"shape":"Sc"}}},"output":{"type":"structure","members":{}}},"UntagResource":{"input":{"type":"structure","required":["ResourceArn","TagKeys"],"members":{"ResourceArn":{},"TagKeys":{"type":"list","member":{}}}},"output":{"type":"structure","members":{}}},"UpdateServer":{"input":{"type":"structure","required":["ServerName"],"members":{"DisableAutomatedBackup":{"type":"boolean"},"BackupRetentionCount":{"type":"integer"},"ServerName":{},"PreferredMaintenanceWindow":{},"PreferredBackupWindow":{}}},"output":{"type":"structure","members":{"Server":{"shape":"Sz"}}}},"UpdateServerEngineAttributes":{"input":{"type":"structure","required":["ServerName","AttributeName"],"members":{"ServerName":{},"AttributeName":{},"AttributeValue":{}}},"output":{"type":"structure","members":{"Server":{"shape":"Sz"}}}}},"shapes":{"S4":{"type":"list","member":{"shape":"S5"}},"S5":{"type":"structure","members":{"Name":{},"Value":{"type":"string","sensitive":true}}},"Sc":{"type":"list","member":{"type":"structure","required":["Key","Value"],"members":{"Key":{},"Value":{}}}},"Sh":{"type":"structure","members":{"BackupArn":{},"BackupId":{},"BackupType":{},"CreatedAt":{"type":"timestamp"},"Description":{},"Engine":{},"EngineModel":{},"EngineVersion":{},"InstanceProfileArn":{},"InstanceType":{},"KeyPair":{},"PreferredBackupWindow":{},"PreferredMaintenanceWindow":{},"S3DataSize":{"deprecated":true,"type":"integer"},"S3DataUrl":{"deprecated":true},"S3LogUrl":{},"SecurityGroupIds":{"shape":"Sn"},"ServerName":{},"ServiceRoleArn":{},"Status":{},"StatusDescription":{},"SubnetIds":{"shape":"Sn"},"ToolsVersion":{},"UserArn":{}}},"Sn":{"type":"list","member":{}},"Sz":{"type":"structure","members":{"AssociatePublicIpAddress":{"type":"boolean"},"BackupRetentionCount":{"type":"integer"},"ServerName":{},"CreatedAt":{"type":"timestamp"},"CloudFormationStackArn":{},"CustomDomain":{},"DisableAutomatedBackup":{"type":"boolean"},"Endpoint":{},"Engine":{},"EngineModel":{},"EngineAttributes":{"shape":"S4"},"EngineVersion":{},"InstanceProfileArn":{},"InstanceType":{},"KeyPair":{},"MaintenanceStatus":{},"PreferredMaintenanceWindow":{},"PreferredBackupWindow":{},"SecurityGroupIds":{"shape":"Sn"},"ServiceRoleArn":{},"Status":{},"StatusReason":{},"SubnetIds":{"shape":"Sn"},"ServerArn":{}}}}}; - -/***/ }), +"use strict"; -/***/ 1986: -/***/ (function(module) { -module.exports = {"pagination":{"DescribeHomeRegionControls":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"}}}; +var uuid = __nccwpck_require__(266); -/***/ }), +const copyDocumentWithTransform = (source, schemaRef, transform = (_) => _) => source; -/***/ 2007: -/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) { +const parseBoolean = (value) => { + switch (value) { + case "true": + return true; + case "false": + return false; + default: + throw new Error(`Unable to parse boolean value "${value}"`); + } +}; +const expectBoolean = (value) => { + if (value === null || value === undefined) { + return undefined; + } + if (typeof value === "number") { + if (value === 0 || value === 1) { + logger.warn(stackTraceWarning(`Expected boolean, got ${typeof value}: ${value}`)); + } + if (value === 0) { + return false; + } + if (value === 1) { + return true; + } + } + if (typeof value === "string") { + const lower = value.toLowerCase(); + if (lower === "false" || lower === "true") { + logger.warn(stackTraceWarning(`Expected boolean, got ${typeof value}: ${value}`)); + } + if (lower === "false") { + return false; + } + if (lower === "true") { + return true; + } + } + if (typeof value === "boolean") { + return value; + } + throw new TypeError(`Expected boolean, got ${typeof value}: ${value}`); +}; +const expectNumber = (value) => { + if (value === null || value === undefined) { + return undefined; + } + if (typeof value === "string") { + const parsed = parseFloat(value); + if (!Number.isNaN(parsed)) { + if (String(parsed) !== String(value)) { + logger.warn(stackTraceWarning(`Expected number but observed string: ${value}`)); + } + return parsed; + } + } + if (typeof value === "number") { + return value; + } + throw new TypeError(`Expected number, got ${typeof value}: ${value}`); +}; +const MAX_FLOAT = Math.ceil(2 ** 127 * (2 - 2 ** -23)); +const expectFloat32 = (value) => { + const expected = expectNumber(value); + if (expected !== undefined && !Number.isNaN(expected) && expected !== Infinity && expected !== -Infinity) { + if (Math.abs(expected) > MAX_FLOAT) { + throw new TypeError(`Expected 32-bit float, got ${value}`); + } + } + return expected; +}; +const expectLong = (value) => { + if (value === null || value === undefined) { + return undefined; + } + if (Number.isInteger(value) && !Number.isNaN(value)) { + return value; + } + throw new TypeError(`Expected integer, got ${typeof value}: ${value}`); +}; +const expectInt = expectLong; +const expectInt32 = (value) => expectSizedInt(value, 32); +const expectShort = (value) => expectSizedInt(value, 16); +const expectByte = (value) => expectSizedInt(value, 8); +const expectSizedInt = (value, size) => { + const expected = expectLong(value); + if (expected !== undefined && castInt(expected, size) !== expected) { + throw new TypeError(`Expected ${size}-bit integer, got ${value}`); + } + return expected; +}; +const castInt = (value, size) => { + switch (size) { + case 32: + return Int32Array.of(value)[0]; + case 16: + return Int16Array.of(value)[0]; + case 8: + return Int8Array.of(value)[0]; + } +}; +const expectNonNull = (value, location) => { + if (value === null || value === undefined) { + if (location) { + throw new TypeError(`Expected a non-null value for ${location}`); + } + throw new TypeError("Expected a non-null value"); + } + return value; +}; +const expectObject = (value) => { + if (value === null || value === undefined) { + return undefined; + } + if (typeof value === "object" && !Array.isArray(value)) { + return value; + } + const receivedType = Array.isArray(value) ? "array" : typeof value; + throw new TypeError(`Expected object, got ${receivedType}: ${value}`); +}; +const expectString = (value) => { + if (value === null || value === undefined) { + return undefined; + } + if (typeof value === "string") { + return value; + } + if (["boolean", "number", "bigint"].includes(typeof value)) { + logger.warn(stackTraceWarning(`Expected string, got ${typeof value}: ${value}`)); + return String(value); + } + throw new TypeError(`Expected string, got ${typeof value}: ${value}`); +}; +const expectUnion = (value) => { + if (value === null || value === undefined) { + return undefined; + } + const asObject = expectObject(value); + const setKeys = Object.entries(asObject) + .filter(([, v]) => v != null) + .map(([k]) => k); + if (setKeys.length === 0) { + throw new TypeError(`Unions must have exactly one non-null member. None were found.`); + } + if (setKeys.length > 1) { + throw new TypeError(`Unions must have exactly one non-null member. Keys ${setKeys} were not null.`); + } + return asObject; +}; +const strictParseDouble = (value) => { + if (typeof value == "string") { + return expectNumber(parseNumber(value)); + } + return expectNumber(value); +}; +const strictParseFloat = strictParseDouble; +const strictParseFloat32 = (value) => { + if (typeof value == "string") { + return expectFloat32(parseNumber(value)); + } + return expectFloat32(value); +}; +const NUMBER_REGEX = /(-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)|(-?Infinity)|(NaN)/g; +const parseNumber = (value) => { + const matches = value.match(NUMBER_REGEX); + if (matches === null || matches[0].length !== value.length) { + throw new TypeError(`Expected real number, got implicit NaN`); + } + return parseFloat(value); +}; +const limitedParseDouble = (value) => { + if (typeof value == "string") { + return parseFloatString(value); + } + return expectNumber(value); +}; +const handleFloat = limitedParseDouble; +const limitedParseFloat = limitedParseDouble; +const limitedParseFloat32 = (value) => { + if (typeof value == "string") { + return parseFloatString(value); + } + return expectFloat32(value); +}; +const parseFloatString = (value) => { + switch (value) { + case "NaN": + return NaN; + case "Infinity": + return Infinity; + case "-Infinity": + return -Infinity; + default: + throw new Error(`Unable to parse float value: ${value}`); + } +}; +const strictParseLong = (value) => { + if (typeof value === "string") { + return expectLong(parseNumber(value)); + } + return expectLong(value); +}; +const strictParseInt = strictParseLong; +const strictParseInt32 = (value) => { + if (typeof value === "string") { + return expectInt32(parseNumber(value)); + } + return expectInt32(value); +}; +const strictParseShort = (value) => { + if (typeof value === "string") { + return expectShort(parseNumber(value)); + } + return expectShort(value); +}; +const strictParseByte = (value) => { + if (typeof value === "string") { + return expectByte(parseNumber(value)); + } + return expectByte(value); +}; +const stackTraceWarning = (message) => { + return String(new TypeError(message).stack || message) + .split("\n") + .slice(0, 5) + .filter((s) => !s.includes("stackTraceWarning")) + .join("\n"); +}; +const logger = { + warn: console.warn, +}; -var AWS = __webpack_require__(395); -__webpack_require__(1371); +const DAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]; +const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]; +function dateToUtcString(date) { + const year = date.getUTCFullYear(); + const month = date.getUTCMonth(); + const dayOfWeek = date.getUTCDay(); + const dayOfMonthInt = date.getUTCDate(); + const hoursInt = date.getUTCHours(); + const minutesInt = date.getUTCMinutes(); + const secondsInt = date.getUTCSeconds(); + const dayOfMonthString = dayOfMonthInt < 10 ? `0${dayOfMonthInt}` : `${dayOfMonthInt}`; + const hoursString = hoursInt < 10 ? `0${hoursInt}` : `${hoursInt}`; + const minutesString = minutesInt < 10 ? `0${minutesInt}` : `${minutesInt}`; + const secondsString = secondsInt < 10 ? `0${secondsInt}` : `${secondsInt}`; + return `${DAYS[dayOfWeek]}, ${dayOfMonthString} ${MONTHS[month]} ${year} ${hoursString}:${minutesString}:${secondsString} GMT`; +} +const RFC3339 = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?[zZ]$/); +const parseRfc3339DateTime = (value) => { + if (value === null || value === undefined) { + return undefined; + } + if (typeof value !== "string") { + throw new TypeError("RFC-3339 date-times must be expressed as strings"); + } + const match = RFC3339.exec(value); + if (!match) { + throw new TypeError("Invalid RFC-3339 date-time value"); + } + const [_, yearStr, monthStr, dayStr, hours, minutes, seconds, fractionalMilliseconds] = match; + const year = strictParseShort(stripLeadingZeroes(yearStr)); + const month = parseDateValue(monthStr, "month", 1, 12); + const day = parseDateValue(dayStr, "day", 1, 31); + return buildDate(year, month, day, { hours, minutes, seconds, fractionalMilliseconds }); +}; +const RFC3339_WITH_OFFSET$1 = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(([-+]\d{2}\:\d{2})|[zZ])$/); +const parseRfc3339DateTimeWithOffset = (value) => { + if (value === null || value === undefined) { + return undefined; + } + if (typeof value !== "string") { + throw new TypeError("RFC-3339 date-times must be expressed as strings"); + } + const match = RFC3339_WITH_OFFSET$1.exec(value); + if (!match) { + throw new TypeError("Invalid RFC-3339 date-time value"); + } + const [_, yearStr, monthStr, dayStr, hours, minutes, seconds, fractionalMilliseconds, offsetStr] = match; + const year = strictParseShort(stripLeadingZeroes(yearStr)); + const month = parseDateValue(monthStr, "month", 1, 12); + const day = parseDateValue(dayStr, "day", 1, 31); + const date = buildDate(year, month, day, { hours, minutes, seconds, fractionalMilliseconds }); + if (offsetStr.toUpperCase() != "Z") { + date.setTime(date.getTime() - parseOffsetToMilliseconds(offsetStr)); + } + return date; +}; +const IMF_FIXDATE$1 = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d{2}) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/); +const RFC_850_DATE$1 = new RegExp(/^(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\d{2})-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/); +const ASC_TIME$1 = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( [1-9]|\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? (\d{4})$/); +const parseRfc7231DateTime = (value) => { + if (value === null || value === undefined) { + return undefined; + } + if (typeof value !== "string") { + throw new TypeError("RFC-7231 date-times must be expressed as strings"); + } + let match = IMF_FIXDATE$1.exec(value); + if (match) { + const [_, dayStr, monthStr, yearStr, hours, minutes, seconds, fractionalMilliseconds] = match; + return buildDate(strictParseShort(stripLeadingZeroes(yearStr)), parseMonthByShortName(monthStr), parseDateValue(dayStr, "day", 1, 31), { hours, minutes, seconds, fractionalMilliseconds }); + } + match = RFC_850_DATE$1.exec(value); + if (match) { + const [_, dayStr, monthStr, yearStr, hours, minutes, seconds, fractionalMilliseconds] = match; + return adjustRfc850Year(buildDate(parseTwoDigitYear(yearStr), parseMonthByShortName(monthStr), parseDateValue(dayStr, "day", 1, 31), { + hours, + minutes, + seconds, + fractionalMilliseconds, + })); + } + match = ASC_TIME$1.exec(value); + if (match) { + const [_, monthStr, dayStr, hours, minutes, seconds, fractionalMilliseconds, yearStr] = match; + return buildDate(strictParseShort(stripLeadingZeroes(yearStr)), parseMonthByShortName(monthStr), parseDateValue(dayStr.trimLeft(), "day", 1, 31), { hours, minutes, seconds, fractionalMilliseconds }); + } + throw new TypeError("Invalid RFC-7231 date-time value"); +}; +const parseEpochTimestamp = (value) => { + if (value === null || value === undefined) { + return undefined; + } + let valueAsDouble; + if (typeof value === "number") { + valueAsDouble = value; + } + else if (typeof value === "string") { + valueAsDouble = strictParseDouble(value); + } + else if (typeof value === "object" && value.tag === 1) { + valueAsDouble = value.value; + } + else { + throw new TypeError("Epoch timestamps must be expressed as floating point numbers or their string representation"); + } + if (Number.isNaN(valueAsDouble) || valueAsDouble === Infinity || valueAsDouble === -Infinity) { + throw new TypeError("Epoch timestamps must be valid, non-Infinite, non-NaN numerics"); + } + return new Date(Math.round(valueAsDouble * 1000)); +}; +const buildDate = (year, month, day, time) => { + const adjustedMonth = month - 1; + validateDayOfMonth(year, adjustedMonth, day); + return new Date(Date.UTC(year, adjustedMonth, day, parseDateValue(time.hours, "hour", 0, 23), parseDateValue(time.minutes, "minute", 0, 59), parseDateValue(time.seconds, "seconds", 0, 60), parseMilliseconds(time.fractionalMilliseconds))); +}; +const parseTwoDigitYear = (value) => { + const thisYear = new Date().getUTCFullYear(); + const valueInThisCentury = Math.floor(thisYear / 100) * 100 + strictParseShort(stripLeadingZeroes(value)); + if (valueInThisCentury < thisYear) { + return valueInThisCentury + 100; + } + return valueInThisCentury; +}; +const FIFTY_YEARS_IN_MILLIS = 50 * 365 * 24 * 60 * 60 * 1000; +const adjustRfc850Year = (input) => { + if (input.getTime() - new Date().getTime() > FIFTY_YEARS_IN_MILLIS) { + return new Date(Date.UTC(input.getUTCFullYear() - 100, input.getUTCMonth(), input.getUTCDate(), input.getUTCHours(), input.getUTCMinutes(), input.getUTCSeconds(), input.getUTCMilliseconds())); + } + return input; +}; +const parseMonthByShortName = (value) => { + const monthIdx = MONTHS.indexOf(value); + if (monthIdx < 0) { + throw new TypeError(`Invalid month: ${value}`); + } + return monthIdx + 1; +}; +const DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; +const validateDayOfMonth = (year, month, day) => { + let maxDays = DAYS_IN_MONTH[month]; + if (month === 1 && isLeapYear(year)) { + maxDays = 29; + } + if (day > maxDays) { + throw new TypeError(`Invalid day for ${MONTHS[month]} in ${year}: ${day}`); + } +}; +const isLeapYear = (year) => { + return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0); +}; +const parseDateValue = (value, type, lower, upper) => { + const dateVal = strictParseByte(stripLeadingZeroes(value)); + if (dateVal < lower || dateVal > upper) { + throw new TypeError(`${type} must be between ${lower} and ${upper}, inclusive`); + } + return dateVal; +}; +const parseMilliseconds = (value) => { + if (value === null || value === undefined) { + return 0; + } + return strictParseFloat32("0." + value) * 1000; +}; +const parseOffsetToMilliseconds = (value) => { + const directionStr = value[0]; + let direction = 1; + if (directionStr == "+") { + direction = 1; + } + else if (directionStr == "-") { + direction = -1; + } + else { + throw new TypeError(`Offset direction, ${directionStr}, must be "+" or "-"`); + } + const hour = Number(value.substring(1, 3)); + const minute = Number(value.substring(4, 6)); + return direction * (hour * 60 + minute) * 60 * 1000; +}; +const stripLeadingZeroes = (value) => { + let idx = 0; + while (idx < value.length - 1 && value.charAt(idx) === "0") { + idx++; + } + if (idx === 0) { + return value; + } + return value.slice(idx); +}; -AWS.util.update(AWS.DynamoDB.prototype, { - /** - * @api private - */ - setupRequestListeners: function setupRequestListeners(request) { - if (request.service.config.dynamoDbCrc32) { - request.removeListener('extractData', AWS.EventListeners.Json.EXTRACT_DATA); - request.addListener('extractData', this.checkCrc32); - request.addListener('extractData', AWS.EventListeners.Json.EXTRACT_DATA); +const LazyJsonString = function LazyJsonString(val) { + const str = Object.assign(new String(val), { + deserializeJSON() { + return JSON.parse(String(val)); + }, + toString() { + return String(val); + }, + toJSON() { + return String(val); + }, + }); + return str; +}; +LazyJsonString.from = (object) => { + if (object && typeof object === "object" && (object instanceof LazyJsonString || "deserializeJSON" in object)) { + return object; } - }, + else if (typeof object === "string" || Object.getPrototypeOf(object) === String.prototype) { + return LazyJsonString(String(object)); + } + return LazyJsonString(JSON.stringify(object)); +}; +LazyJsonString.fromObject = LazyJsonString.from; - /** - * @api private - */ - checkCrc32: function checkCrc32(resp) { - if (!resp.httpResponse.streaming && !resp.request.service.crc32IsValid(resp)) { - resp.data = null; - resp.error = AWS.util.error(new Error(), { - code: 'CRC32CheckFailed', - message: 'CRC32 integrity check failed', - retryable: true - }); - resp.request.haltHandlersOnError(); - throw (resp.error); +function quoteHeader(part) { + if (part.includes(",") || part.includes('"')) { + part = `"${part.replace(/"/g, '\\"')}"`; } - }, + return part; +} - /** - * @api private - */ - crc32IsValid: function crc32IsValid(resp) { - var crc = resp.httpResponse.headers['x-amz-crc32']; - if (!crc) return true; // no (valid) CRC32 header - return parseInt(crc, 10) === AWS.util.crypto.crc32(resp.httpResponse.body); - }, +const ddd = `(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)(?:[ne|u?r]?s?day)?`; +const mmm = `(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)`; +const time = `(\\d?\\d):(\\d{2}):(\\d{2})(?:\\.(\\d+))?`; +const date = `(\\d?\\d)`; +const year = `(\\d{4})`; +const RFC3339_WITH_OFFSET = new RegExp(/^(\d{4})-(\d\d)-(\d\d)[tT](\d\d):(\d\d):(\d\d)(\.(\d+))?(([-+]\d\d:\d\d)|[zZ])$/); +const IMF_FIXDATE = new RegExp(`^${ddd}, ${date} ${mmm} ${year} ${time} GMT$`); +const RFC_850_DATE = new RegExp(`^${ddd}, ${date}-${mmm}-(\\d\\d) ${time} GMT$`); +const ASC_TIME = new RegExp(`^${ddd} ${mmm} ( [1-9]|\\d\\d) ${time} ${year}$`); +const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]; +const _parseEpochTimestamp = (value) => { + if (value == null) { + return void 0; + } + let num = NaN; + if (typeof value === "number") { + num = value; + } + else if (typeof value === "string") { + if (!/^-?\d*\.?\d+$/.test(value)) { + throw new TypeError(`parseEpochTimestamp - numeric string invalid.`); + } + num = Number.parseFloat(value); + } + else if (typeof value === "object" && value.tag === 1) { + num = value.value; + } + if (isNaN(num) || Math.abs(num) === Infinity) { + throw new TypeError("Epoch timestamps must be valid finite numbers."); + } + return new Date(Math.round(num * 1000)); +}; +const _parseRfc3339DateTimeWithOffset = (value) => { + if (value == null) { + return void 0; + } + if (typeof value !== "string") { + throw new TypeError("RFC3339 timestamps must be strings"); + } + const matches = RFC3339_WITH_OFFSET.exec(value); + if (!matches) { + throw new TypeError(`Invalid RFC3339 timestamp format ${value}`); + } + const [, yearStr, monthStr, dayStr, hours, minutes, seconds, , ms, offsetStr] = matches; + range(monthStr, 1, 12); + range(dayStr, 1, 31); + range(hours, 0, 23); + range(minutes, 0, 59); + range(seconds, 0, 60); + const date = new Date(Date.UTC(Number(yearStr), Number(monthStr) - 1, Number(dayStr), Number(hours), Number(minutes), Number(seconds), Number(ms) ? Math.round(parseFloat(`0.${ms}`) * 1000) : 0)); + date.setUTCFullYear(Number(yearStr)); + if (offsetStr.toUpperCase() != "Z") { + const [, sign, offsetH, offsetM] = /([+-])(\d\d):(\d\d)/.exec(offsetStr) || [void 0, "+", 0, 0]; + const scalar = sign === "-" ? 1 : -1; + date.setTime(date.getTime() + scalar * (Number(offsetH) * 60 * 60 * 1000 + Number(offsetM) * 60 * 1000)); + } + return date; +}; +const _parseRfc7231DateTime = (value) => { + if (value == null) { + return void 0; + } + if (typeof value !== "string") { + throw new TypeError("RFC7231 timestamps must be strings."); + } + let day; + let month; + let year; + let hour; + let minute; + let second; + let fraction; + let matches; + if ((matches = IMF_FIXDATE.exec(value))) { + [, day, month, year, hour, minute, second, fraction] = matches; + } + else if ((matches = RFC_850_DATE.exec(value))) { + [, day, month, year, hour, minute, second, fraction] = matches; + year = (Number(year) + 1900).toString(); + } + else if ((matches = ASC_TIME.exec(value))) { + [, month, day, hour, minute, second, fraction, year] = matches; + } + if (year && second) { + const timestamp = Date.UTC(Number(year), months.indexOf(month), Number(day), Number(hour), Number(minute), Number(second), fraction ? Math.round(parseFloat(`0.${fraction}`) * 1000) : 0); + range(day, 1, 31); + range(hour, 0, 23); + range(minute, 0, 59); + range(second, 0, 60); + const date = new Date(timestamp); + date.setUTCFullYear(Number(year)); + return date; + } + throw new TypeError(`Invalid RFC7231 date-time value ${value}.`); +}; +function range(v, min, max) { + const _v = Number(v); + if (_v < min || _v > max) { + throw new Error(`Value ${_v} out of range [${min}, ${max}]`); + } +} - /** - * @api private - */ - defaultRetryCount: 10, +function splitEvery(value, delimiter, numDelimiters) { + if (numDelimiters <= 0 || !Number.isInteger(numDelimiters)) { + throw new Error("Invalid number of delimiters (" + numDelimiters + ") for splitEvery."); + } + const segments = value.split(delimiter); + if (numDelimiters === 1) { + return segments; + } + const compoundSegments = []; + let currentSegment = ""; + for (let i = 0; i < segments.length; i++) { + if (currentSegment === "") { + currentSegment = segments[i]; + } + else { + currentSegment += delimiter + segments[i]; + } + if ((i + 1) % numDelimiters === 0) { + compoundSegments.push(currentSegment); + currentSegment = ""; + } + } + if (currentSegment !== "") { + compoundSegments.push(currentSegment); + } + return compoundSegments; +} - /** - * @api private - */ - retryDelays: function retryDelays(retryCount, err) { - var retryDelayOptions = AWS.util.copy(this.config.retryDelayOptions); +const splitHeader = (value) => { + const z = value.length; + const values = []; + let withinQuotes = false; + let prevChar = undefined; + let anchor = 0; + for (let i = 0; i < z; ++i) { + const char = value[i]; + switch (char) { + case `"`: + if (prevChar !== "\\") { + withinQuotes = !withinQuotes; + } + break; + case ",": + if (!withinQuotes) { + values.push(value.slice(anchor, i)); + anchor = i + 1; + } + break; + } + prevChar = char; + } + values.push(value.slice(anchor)); + return values.map((v) => { + v = v.trim(); + const z = v.length; + if (z < 2) { + return v; + } + if (v[0] === `"` && v[z - 1] === `"`) { + v = v.slice(1, z - 1); + } + return v.replace(/\\"/g, '"'); + }); +}; - if (typeof retryDelayOptions.base !== 'number') { - retryDelayOptions.base = 50; // default for dynamodb +const format = /^-?\d*(\.\d+)?$/; +class NumericValue { + string; + type; + constructor(string, type) { + this.string = string; + this.type = type; + if (!format.test(string)) { + throw new Error(`@smithy/core/serde - NumericValue must only contain [0-9], at most one decimal point ".", and an optional negation prefix "-".`); + } } - var delay = AWS.util.calculateRetryDelay(retryCount, retryDelayOptions, err); - return delay; - } -}); - - -/***/ }), - -/***/ 2020: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['apigatewayv2'] = {}; -AWS.ApiGatewayV2 = Service.defineService('apigatewayv2', ['2018-11-29']); -Object.defineProperty(apiLoader.services['apigatewayv2'], '2018-11-29', { - get: function get() { - var model = __webpack_require__(5687); - model.paginators = __webpack_require__(4725).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.ApiGatewayV2; - - -/***/ }), - -/***/ 2028: -/***/ (function(module) { + toString() { + return this.string; + } + static [Symbol.hasInstance](object) { + if (!object || typeof object !== "object") { + return false; + } + const _nv = object; + return NumericValue.prototype.isPrototypeOf(object) || (_nv.type === "bigDecimal" && format.test(_nv.string)); + } +} +function nv(input) { + return new NumericValue(String(input), "bigDecimal"); +} -module.exports = {"pagination":{}}; +Object.defineProperty(exports, "generateIdempotencyToken", ({ + enumerable: true, + get: function () { return uuid.v4; } +})); +exports.LazyJsonString = LazyJsonString; +exports.NumericValue = NumericValue; +exports._parseEpochTimestamp = _parseEpochTimestamp; +exports._parseRfc3339DateTimeWithOffset = _parseRfc3339DateTimeWithOffset; +exports._parseRfc7231DateTime = _parseRfc7231DateTime; +exports.copyDocumentWithTransform = copyDocumentWithTransform; +exports.dateToUtcString = dateToUtcString; +exports.expectBoolean = expectBoolean; +exports.expectByte = expectByte; +exports.expectFloat32 = expectFloat32; +exports.expectInt = expectInt; +exports.expectInt32 = expectInt32; +exports.expectLong = expectLong; +exports.expectNonNull = expectNonNull; +exports.expectNumber = expectNumber; +exports.expectObject = expectObject; +exports.expectShort = expectShort; +exports.expectString = expectString; +exports.expectUnion = expectUnion; +exports.handleFloat = handleFloat; +exports.limitedParseDouble = limitedParseDouble; +exports.limitedParseFloat = limitedParseFloat; +exports.limitedParseFloat32 = limitedParseFloat32; +exports.logger = logger; +exports.nv = nv; +exports.parseBoolean = parseBoolean; +exports.parseEpochTimestamp = parseEpochTimestamp; +exports.parseRfc3339DateTime = parseRfc3339DateTime; +exports.parseRfc3339DateTimeWithOffset = parseRfc3339DateTimeWithOffset; +exports.parseRfc7231DateTime = parseRfc7231DateTime; +exports.quoteHeader = quoteHeader; +exports.splitEvery = splitEvery; +exports.splitHeader = splitHeader; +exports.strictParseByte = strictParseByte; +exports.strictParseDouble = strictParseDouble; +exports.strictParseFloat = strictParseFloat; +exports.strictParseFloat32 = strictParseFloat32; +exports.strictParseInt = strictParseInt; +exports.strictParseInt32 = strictParseInt32; +exports.strictParseLong = strictParseLong; +exports.strictParseShort = strictParseShort; + + +/***/ }), + +/***/ 7809: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -/***/ }), +"use strict"; -/***/ 2046: -/***/ (function(module) { -module.exports = {"pagination":{}}; +var protocolHttp = __nccwpck_require__(2356); +var querystringBuilder = __nccwpck_require__(8256); +var utilBase64 = __nccwpck_require__(8385); -/***/ }), +function createRequest(url, requestOptions) { + return new Request(url, requestOptions); +} -/***/ 2053: -/***/ (function(module) { +function requestTimeout(timeoutInMs = 0) { + return new Promise((resolve, reject) => { + if (timeoutInMs) { + setTimeout(() => { + const timeoutError = new Error(`Request did not complete within ${timeoutInMs} ms`); + timeoutError.name = "TimeoutError"; + reject(timeoutError); + }, timeoutInMs); + } + }); +} -module.exports = {"metadata":{"apiVersion":"2017-06-07","endpointPrefix":"greengrass","signingName":"greengrass","serviceFullName":"AWS Greengrass","serviceId":"Greengrass","protocol":"rest-json","jsonVersion":"1.1","uid":"greengrass-2017-06-07","signatureVersion":"v4"},"operations":{"AssociateRoleToGroup":{"http":{"method":"PUT","requestUri":"/greengrass/groups/{GroupId}/role","responseCode":200},"input":{"type":"structure","members":{"GroupId":{"location":"uri","locationName":"GroupId"},"RoleArn":{}},"required":["GroupId","RoleArn"]},"output":{"type":"structure","members":{"AssociatedAt":{}}}},"AssociateServiceRoleToAccount":{"http":{"method":"PUT","requestUri":"/greengrass/servicerole","responseCode":200},"input":{"type":"structure","members":{"RoleArn":{}},"required":["RoleArn"]},"output":{"type":"structure","members":{"AssociatedAt":{}}}},"CreateConnectorDefinition":{"http":{"requestUri":"/greengrass/definition/connectors","responseCode":200},"input":{"type":"structure","members":{"AmznClientToken":{"location":"header","locationName":"X-Amzn-Client-Token"},"InitialVersion":{"shape":"S7"},"Name":{},"tags":{"shape":"Sb"}}},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Id":{},"LastUpdatedTimestamp":{},"LatestVersion":{},"LatestVersionArn":{},"Name":{}}}},"CreateConnectorDefinitionVersion":{"http":{"requestUri":"/greengrass/definition/connectors/{ConnectorDefinitionId}/versions","responseCode":200},"input":{"type":"structure","members":{"AmznClientToken":{"location":"header","locationName":"X-Amzn-Client-Token"},"ConnectorDefinitionId":{"location":"uri","locationName":"ConnectorDefinitionId"},"Connectors":{"shape":"S8"}},"required":["ConnectorDefinitionId"]},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Id":{},"Version":{}}}},"CreateCoreDefinition":{"http":{"requestUri":"/greengrass/definition/cores","responseCode":200},"input":{"type":"structure","members":{"AmznClientToken":{"location":"header","locationName":"X-Amzn-Client-Token"},"InitialVersion":{"shape":"Sg"},"Name":{},"tags":{"shape":"Sb"}}},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Id":{},"LastUpdatedTimestamp":{},"LatestVersion":{},"LatestVersionArn":{},"Name":{}}}},"CreateCoreDefinitionVersion":{"http":{"requestUri":"/greengrass/definition/cores/{CoreDefinitionId}/versions","responseCode":200},"input":{"type":"structure","members":{"AmznClientToken":{"location":"header","locationName":"X-Amzn-Client-Token"},"CoreDefinitionId":{"location":"uri","locationName":"CoreDefinitionId"},"Cores":{"shape":"Sh"}},"required":["CoreDefinitionId"]},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Id":{},"Version":{}}}},"CreateDeployment":{"http":{"requestUri":"/greengrass/groups/{GroupId}/deployments","responseCode":200},"input":{"type":"structure","members":{"AmznClientToken":{"location":"header","locationName":"X-Amzn-Client-Token"},"DeploymentId":{},"DeploymentType":{},"GroupId":{"location":"uri","locationName":"GroupId"},"GroupVersionId":{}},"required":["GroupId","DeploymentType"]},"output":{"type":"structure","members":{"DeploymentArn":{},"DeploymentId":{}}}},"CreateDeviceDefinition":{"http":{"requestUri":"/greengrass/definition/devices","responseCode":200},"input":{"type":"structure","members":{"AmznClientToken":{"location":"header","locationName":"X-Amzn-Client-Token"},"InitialVersion":{"shape":"Sr"},"Name":{},"tags":{"shape":"Sb"}}},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Id":{},"LastUpdatedTimestamp":{},"LatestVersion":{},"LatestVersionArn":{},"Name":{}}}},"CreateDeviceDefinitionVersion":{"http":{"requestUri":"/greengrass/definition/devices/{DeviceDefinitionId}/versions","responseCode":200},"input":{"type":"structure","members":{"AmznClientToken":{"location":"header","locationName":"X-Amzn-Client-Token"},"DeviceDefinitionId":{"location":"uri","locationName":"DeviceDefinitionId"},"Devices":{"shape":"Ss"}},"required":["DeviceDefinitionId"]},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Id":{},"Version":{}}}},"CreateFunctionDefinition":{"http":{"requestUri":"/greengrass/definition/functions","responseCode":200},"input":{"type":"structure","members":{"AmznClientToken":{"location":"header","locationName":"X-Amzn-Client-Token"},"InitialVersion":{"shape":"Sy"},"Name":{},"tags":{"shape":"Sb"}}},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Id":{},"LastUpdatedTimestamp":{},"LatestVersion":{},"LatestVersionArn":{},"Name":{}}}},"CreateFunctionDefinitionVersion":{"http":{"requestUri":"/greengrass/definition/functions/{FunctionDefinitionId}/versions","responseCode":200},"input":{"type":"structure","members":{"AmznClientToken":{"location":"header","locationName":"X-Amzn-Client-Token"},"DefaultConfig":{"shape":"Sz"},"FunctionDefinitionId":{"location":"uri","locationName":"FunctionDefinitionId"},"Functions":{"shape":"S14"}},"required":["FunctionDefinitionId"]},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Id":{},"Version":{}}}},"CreateGroup":{"http":{"requestUri":"/greengrass/groups","responseCode":200},"input":{"type":"structure","members":{"AmznClientToken":{"location":"header","locationName":"X-Amzn-Client-Token"},"InitialVersion":{"shape":"S1h"},"Name":{},"tags":{"shape":"Sb"}}},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Id":{},"LastUpdatedTimestamp":{},"LatestVersion":{},"LatestVersionArn":{},"Name":{}}}},"CreateGroupCertificateAuthority":{"http":{"requestUri":"/greengrass/groups/{GroupId}/certificateauthorities","responseCode":200},"input":{"type":"structure","members":{"AmznClientToken":{"location":"header","locationName":"X-Amzn-Client-Token"},"GroupId":{"location":"uri","locationName":"GroupId"}},"required":["GroupId"]},"output":{"type":"structure","members":{"GroupCertificateAuthorityArn":{}}}},"CreateGroupVersion":{"http":{"requestUri":"/greengrass/groups/{GroupId}/versions","responseCode":200},"input":{"type":"structure","members":{"AmznClientToken":{"location":"header","locationName":"X-Amzn-Client-Token"},"ConnectorDefinitionVersionArn":{},"CoreDefinitionVersionArn":{},"DeviceDefinitionVersionArn":{},"FunctionDefinitionVersionArn":{},"GroupId":{"location":"uri","locationName":"GroupId"},"LoggerDefinitionVersionArn":{},"ResourceDefinitionVersionArn":{},"SubscriptionDefinitionVersionArn":{}},"required":["GroupId"]},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Id":{},"Version":{}}}},"CreateLoggerDefinition":{"http":{"requestUri":"/greengrass/definition/loggers","responseCode":200},"input":{"type":"structure","members":{"AmznClientToken":{"location":"header","locationName":"X-Amzn-Client-Token"},"InitialVersion":{"shape":"S1o"},"Name":{},"tags":{"shape":"Sb"}}},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Id":{},"LastUpdatedTimestamp":{},"LatestVersion":{},"LatestVersionArn":{},"Name":{}}}},"CreateLoggerDefinitionVersion":{"http":{"requestUri":"/greengrass/definition/loggers/{LoggerDefinitionId}/versions","responseCode":200},"input":{"type":"structure","members":{"AmznClientToken":{"location":"header","locationName":"X-Amzn-Client-Token"},"LoggerDefinitionId":{"location":"uri","locationName":"LoggerDefinitionId"},"Loggers":{"shape":"S1p"}},"required":["LoggerDefinitionId"]},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Id":{},"Version":{}}}},"CreateResourceDefinition":{"http":{"requestUri":"/greengrass/definition/resources","responseCode":200},"input":{"type":"structure","members":{"AmznClientToken":{"location":"header","locationName":"X-Amzn-Client-Token"},"InitialVersion":{"shape":"S1y"},"Name":{},"tags":{"shape":"Sb"}}},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Id":{},"LastUpdatedTimestamp":{},"LatestVersion":{},"LatestVersionArn":{},"Name":{}}}},"CreateResourceDefinitionVersion":{"http":{"requestUri":"/greengrass/definition/resources/{ResourceDefinitionId}/versions","responseCode":200},"input":{"type":"structure","members":{"AmznClientToken":{"location":"header","locationName":"X-Amzn-Client-Token"},"ResourceDefinitionId":{"location":"uri","locationName":"ResourceDefinitionId"},"Resources":{"shape":"S1z"}},"required":["ResourceDefinitionId"]},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Id":{},"Version":{}}}},"CreateSoftwareUpdateJob":{"http":{"requestUri":"/greengrass/updates","responseCode":200},"input":{"type":"structure","members":{"AmznClientToken":{"location":"header","locationName":"X-Amzn-Client-Token"},"S3UrlSignerRole":{},"SoftwareToUpdate":{},"UpdateAgentLogLevel":{},"UpdateTargets":{"type":"list","member":{}},"UpdateTargetsArchitecture":{},"UpdateTargetsOperatingSystem":{}},"required":["S3UrlSignerRole","UpdateTargetsArchitecture","SoftwareToUpdate","UpdateTargets","UpdateTargetsOperatingSystem"]},"output":{"type":"structure","members":{"IotJobArn":{},"IotJobId":{},"PlatformSoftwareVersion":{}}}},"CreateSubscriptionDefinition":{"http":{"requestUri":"/greengrass/definition/subscriptions","responseCode":200},"input":{"type":"structure","members":{"AmznClientToken":{"location":"header","locationName":"X-Amzn-Client-Token"},"InitialVersion":{"shape":"S2m"},"Name":{},"tags":{"shape":"Sb"}}},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Id":{},"LastUpdatedTimestamp":{},"LatestVersion":{},"LatestVersionArn":{},"Name":{}}}},"CreateSubscriptionDefinitionVersion":{"http":{"requestUri":"/greengrass/definition/subscriptions/{SubscriptionDefinitionId}/versions","responseCode":200},"input":{"type":"structure","members":{"AmznClientToken":{"location":"header","locationName":"X-Amzn-Client-Token"},"SubscriptionDefinitionId":{"location":"uri","locationName":"SubscriptionDefinitionId"},"Subscriptions":{"shape":"S2n"}},"required":["SubscriptionDefinitionId"]},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Id":{},"Version":{}}}},"DeleteConnectorDefinition":{"http":{"method":"DELETE","requestUri":"/greengrass/definition/connectors/{ConnectorDefinitionId}","responseCode":200},"input":{"type":"structure","members":{"ConnectorDefinitionId":{"location":"uri","locationName":"ConnectorDefinitionId"}},"required":["ConnectorDefinitionId"]},"output":{"type":"structure","members":{}}},"DeleteCoreDefinition":{"http":{"method":"DELETE","requestUri":"/greengrass/definition/cores/{CoreDefinitionId}","responseCode":200},"input":{"type":"structure","members":{"CoreDefinitionId":{"location":"uri","locationName":"CoreDefinitionId"}},"required":["CoreDefinitionId"]},"output":{"type":"structure","members":{}}},"DeleteDeviceDefinition":{"http":{"method":"DELETE","requestUri":"/greengrass/definition/devices/{DeviceDefinitionId}","responseCode":200},"input":{"type":"structure","members":{"DeviceDefinitionId":{"location":"uri","locationName":"DeviceDefinitionId"}},"required":["DeviceDefinitionId"]},"output":{"type":"structure","members":{}}},"DeleteFunctionDefinition":{"http":{"method":"DELETE","requestUri":"/greengrass/definition/functions/{FunctionDefinitionId}","responseCode":200},"input":{"type":"structure","members":{"FunctionDefinitionId":{"location":"uri","locationName":"FunctionDefinitionId"}},"required":["FunctionDefinitionId"]},"output":{"type":"structure","members":{}}},"DeleteGroup":{"http":{"method":"DELETE","requestUri":"/greengrass/groups/{GroupId}","responseCode":200},"input":{"type":"structure","members":{"GroupId":{"location":"uri","locationName":"GroupId"}},"required":["GroupId"]},"output":{"type":"structure","members":{}}},"DeleteLoggerDefinition":{"http":{"method":"DELETE","requestUri":"/greengrass/definition/loggers/{LoggerDefinitionId}","responseCode":200},"input":{"type":"structure","members":{"LoggerDefinitionId":{"location":"uri","locationName":"LoggerDefinitionId"}},"required":["LoggerDefinitionId"]},"output":{"type":"structure","members":{}}},"DeleteResourceDefinition":{"http":{"method":"DELETE","requestUri":"/greengrass/definition/resources/{ResourceDefinitionId}","responseCode":200},"input":{"type":"structure","members":{"ResourceDefinitionId":{"location":"uri","locationName":"ResourceDefinitionId"}},"required":["ResourceDefinitionId"]},"output":{"type":"structure","members":{}}},"DeleteSubscriptionDefinition":{"http":{"method":"DELETE","requestUri":"/greengrass/definition/subscriptions/{SubscriptionDefinitionId}","responseCode":200},"input":{"type":"structure","members":{"SubscriptionDefinitionId":{"location":"uri","locationName":"SubscriptionDefinitionId"}},"required":["SubscriptionDefinitionId"]},"output":{"type":"structure","members":{}}},"DisassociateRoleFromGroup":{"http":{"method":"DELETE","requestUri":"/greengrass/groups/{GroupId}/role","responseCode":200},"input":{"type":"structure","members":{"GroupId":{"location":"uri","locationName":"GroupId"}},"required":["GroupId"]},"output":{"type":"structure","members":{"DisassociatedAt":{}}}},"DisassociateServiceRoleFromAccount":{"http":{"method":"DELETE","requestUri":"/greengrass/servicerole","responseCode":200},"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"DisassociatedAt":{}}}},"GetAssociatedRole":{"http":{"method":"GET","requestUri":"/greengrass/groups/{GroupId}/role","responseCode":200},"input":{"type":"structure","members":{"GroupId":{"location":"uri","locationName":"GroupId"}},"required":["GroupId"]},"output":{"type":"structure","members":{"AssociatedAt":{},"RoleArn":{}}}},"GetBulkDeploymentStatus":{"http":{"method":"GET","requestUri":"/greengrass/bulk/deployments/{BulkDeploymentId}/status","responseCode":200},"input":{"type":"structure","members":{"BulkDeploymentId":{"location":"uri","locationName":"BulkDeploymentId"}},"required":["BulkDeploymentId"]},"output":{"type":"structure","members":{"BulkDeploymentMetrics":{"type":"structure","members":{"InvalidInputRecords":{"type":"integer"},"RecordsProcessed":{"type":"integer"},"RetryAttempts":{"type":"integer"}}},"BulkDeploymentStatus":{},"CreatedAt":{},"ErrorDetails":{"shape":"S3i"},"ErrorMessage":{},"tags":{"shape":"Sb"}}}},"GetConnectivityInfo":{"http":{"method":"GET","requestUri":"/greengrass/things/{ThingName}/connectivityInfo","responseCode":200},"input":{"type":"structure","members":{"ThingName":{"location":"uri","locationName":"ThingName"}},"required":["ThingName"]},"output":{"type":"structure","members":{"ConnectivityInfo":{"shape":"S3m"},"Message":{"locationName":"message"}}}},"GetConnectorDefinition":{"http":{"method":"GET","requestUri":"/greengrass/definition/connectors/{ConnectorDefinitionId}","responseCode":200},"input":{"type":"structure","members":{"ConnectorDefinitionId":{"location":"uri","locationName":"ConnectorDefinitionId"}},"required":["ConnectorDefinitionId"]},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Id":{},"LastUpdatedTimestamp":{},"LatestVersion":{},"LatestVersionArn":{},"Name":{},"tags":{"shape":"Sb"}}}},"GetConnectorDefinitionVersion":{"http":{"method":"GET","requestUri":"/greengrass/definition/connectors/{ConnectorDefinitionId}/versions/{ConnectorDefinitionVersionId}","responseCode":200},"input":{"type":"structure","members":{"ConnectorDefinitionId":{"location":"uri","locationName":"ConnectorDefinitionId"},"ConnectorDefinitionVersionId":{"location":"uri","locationName":"ConnectorDefinitionVersionId"},"NextToken":{"location":"querystring","locationName":"NextToken"}},"required":["ConnectorDefinitionId","ConnectorDefinitionVersionId"]},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Definition":{"shape":"S7"},"Id":{},"NextToken":{},"Version":{}}}},"GetCoreDefinition":{"http":{"method":"GET","requestUri":"/greengrass/definition/cores/{CoreDefinitionId}","responseCode":200},"input":{"type":"structure","members":{"CoreDefinitionId":{"location":"uri","locationName":"CoreDefinitionId"}},"required":["CoreDefinitionId"]},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Id":{},"LastUpdatedTimestamp":{},"LatestVersion":{},"LatestVersionArn":{},"Name":{},"tags":{"shape":"Sb"}}}},"GetCoreDefinitionVersion":{"http":{"method":"GET","requestUri":"/greengrass/definition/cores/{CoreDefinitionId}/versions/{CoreDefinitionVersionId}","responseCode":200},"input":{"type":"structure","members":{"CoreDefinitionId":{"location":"uri","locationName":"CoreDefinitionId"},"CoreDefinitionVersionId":{"location":"uri","locationName":"CoreDefinitionVersionId"}},"required":["CoreDefinitionId","CoreDefinitionVersionId"]},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Definition":{"shape":"Sg"},"Id":{},"NextToken":{},"Version":{}}}},"GetDeploymentStatus":{"http":{"method":"GET","requestUri":"/greengrass/groups/{GroupId}/deployments/{DeploymentId}/status","responseCode":200},"input":{"type":"structure","members":{"DeploymentId":{"location":"uri","locationName":"DeploymentId"},"GroupId":{"location":"uri","locationName":"GroupId"}},"required":["GroupId","DeploymentId"]},"output":{"type":"structure","members":{"DeploymentStatus":{},"DeploymentType":{},"ErrorDetails":{"shape":"S3i"},"ErrorMessage":{},"UpdatedAt":{}}}},"GetDeviceDefinition":{"http":{"method":"GET","requestUri":"/greengrass/definition/devices/{DeviceDefinitionId}","responseCode":200},"input":{"type":"structure","members":{"DeviceDefinitionId":{"location":"uri","locationName":"DeviceDefinitionId"}},"required":["DeviceDefinitionId"]},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Id":{},"LastUpdatedTimestamp":{},"LatestVersion":{},"LatestVersionArn":{},"Name":{},"tags":{"shape":"Sb"}}}},"GetDeviceDefinitionVersion":{"http":{"method":"GET","requestUri":"/greengrass/definition/devices/{DeviceDefinitionId}/versions/{DeviceDefinitionVersionId}","responseCode":200},"input":{"type":"structure","members":{"DeviceDefinitionId":{"location":"uri","locationName":"DeviceDefinitionId"},"DeviceDefinitionVersionId":{"location":"uri","locationName":"DeviceDefinitionVersionId"},"NextToken":{"location":"querystring","locationName":"NextToken"}},"required":["DeviceDefinitionVersionId","DeviceDefinitionId"]},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Definition":{"shape":"Sr"},"Id":{},"NextToken":{},"Version":{}}}},"GetFunctionDefinition":{"http":{"method":"GET","requestUri":"/greengrass/definition/functions/{FunctionDefinitionId}","responseCode":200},"input":{"type":"structure","members":{"FunctionDefinitionId":{"location":"uri","locationName":"FunctionDefinitionId"}},"required":["FunctionDefinitionId"]},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Id":{},"LastUpdatedTimestamp":{},"LatestVersion":{},"LatestVersionArn":{},"Name":{},"tags":{"shape":"Sb"}}}},"GetFunctionDefinitionVersion":{"http":{"method":"GET","requestUri":"/greengrass/definition/functions/{FunctionDefinitionId}/versions/{FunctionDefinitionVersionId}","responseCode":200},"input":{"type":"structure","members":{"FunctionDefinitionId":{"location":"uri","locationName":"FunctionDefinitionId"},"FunctionDefinitionVersionId":{"location":"uri","locationName":"FunctionDefinitionVersionId"},"NextToken":{"location":"querystring","locationName":"NextToken"}},"required":["FunctionDefinitionId","FunctionDefinitionVersionId"]},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Definition":{"shape":"Sy"},"Id":{},"NextToken":{},"Version":{}}}},"GetGroup":{"http":{"method":"GET","requestUri":"/greengrass/groups/{GroupId}","responseCode":200},"input":{"type":"structure","members":{"GroupId":{"location":"uri","locationName":"GroupId"}},"required":["GroupId"]},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Id":{},"LastUpdatedTimestamp":{},"LatestVersion":{},"LatestVersionArn":{},"Name":{},"tags":{"shape":"Sb"}}}},"GetGroupCertificateAuthority":{"http":{"method":"GET","requestUri":"/greengrass/groups/{GroupId}/certificateauthorities/{CertificateAuthorityId}","responseCode":200},"input":{"type":"structure","members":{"CertificateAuthorityId":{"location":"uri","locationName":"CertificateAuthorityId"},"GroupId":{"location":"uri","locationName":"GroupId"}},"required":["CertificateAuthorityId","GroupId"]},"output":{"type":"structure","members":{"GroupCertificateAuthorityArn":{},"GroupCertificateAuthorityId":{},"PemEncodedCertificate":{}}}},"GetGroupCertificateConfiguration":{"http":{"method":"GET","requestUri":"/greengrass/groups/{GroupId}/certificateauthorities/configuration/expiry","responseCode":200},"input":{"type":"structure","members":{"GroupId":{"location":"uri","locationName":"GroupId"}},"required":["GroupId"]},"output":{"type":"structure","members":{"CertificateAuthorityExpiryInMilliseconds":{},"CertificateExpiryInMilliseconds":{},"GroupId":{}}}},"GetGroupVersion":{"http":{"method":"GET","requestUri":"/greengrass/groups/{GroupId}/versions/{GroupVersionId}","responseCode":200},"input":{"type":"structure","members":{"GroupId":{"location":"uri","locationName":"GroupId"},"GroupVersionId":{"location":"uri","locationName":"GroupVersionId"}},"required":["GroupVersionId","GroupId"]},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Definition":{"shape":"S1h"},"Id":{},"Version":{}}}},"GetLoggerDefinition":{"http":{"method":"GET","requestUri":"/greengrass/definition/loggers/{LoggerDefinitionId}","responseCode":200},"input":{"type":"structure","members":{"LoggerDefinitionId":{"location":"uri","locationName":"LoggerDefinitionId"}},"required":["LoggerDefinitionId"]},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Id":{},"LastUpdatedTimestamp":{},"LatestVersion":{},"LatestVersionArn":{},"Name":{},"tags":{"shape":"Sb"}}}},"GetLoggerDefinitionVersion":{"http":{"method":"GET","requestUri":"/greengrass/definition/loggers/{LoggerDefinitionId}/versions/{LoggerDefinitionVersionId}","responseCode":200},"input":{"type":"structure","members":{"LoggerDefinitionId":{"location":"uri","locationName":"LoggerDefinitionId"},"LoggerDefinitionVersionId":{"location":"uri","locationName":"LoggerDefinitionVersionId"},"NextToken":{"location":"querystring","locationName":"NextToken"}},"required":["LoggerDefinitionVersionId","LoggerDefinitionId"]},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Definition":{"shape":"S1o"},"Id":{},"Version":{}}}},"GetResourceDefinition":{"http":{"method":"GET","requestUri":"/greengrass/definition/resources/{ResourceDefinitionId}","responseCode":200},"input":{"type":"structure","members":{"ResourceDefinitionId":{"location":"uri","locationName":"ResourceDefinitionId"}},"required":["ResourceDefinitionId"]},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Id":{},"LastUpdatedTimestamp":{},"LatestVersion":{},"LatestVersionArn":{},"Name":{},"tags":{"shape":"Sb"}}}},"GetResourceDefinitionVersion":{"http":{"method":"GET","requestUri":"/greengrass/definition/resources/{ResourceDefinitionId}/versions/{ResourceDefinitionVersionId}","responseCode":200},"input":{"type":"structure","members":{"ResourceDefinitionId":{"location":"uri","locationName":"ResourceDefinitionId"},"ResourceDefinitionVersionId":{"location":"uri","locationName":"ResourceDefinitionVersionId"}},"required":["ResourceDefinitionVersionId","ResourceDefinitionId"]},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Definition":{"shape":"S1y"},"Id":{},"Version":{}}}},"GetServiceRoleForAccount":{"http":{"method":"GET","requestUri":"/greengrass/servicerole","responseCode":200},"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"AssociatedAt":{},"RoleArn":{}}}},"GetSubscriptionDefinition":{"http":{"method":"GET","requestUri":"/greengrass/definition/subscriptions/{SubscriptionDefinitionId}","responseCode":200},"input":{"type":"structure","members":{"SubscriptionDefinitionId":{"location":"uri","locationName":"SubscriptionDefinitionId"}},"required":["SubscriptionDefinitionId"]},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Id":{},"LastUpdatedTimestamp":{},"LatestVersion":{},"LatestVersionArn":{},"Name":{},"tags":{"shape":"Sb"}}}},"GetSubscriptionDefinitionVersion":{"http":{"method":"GET","requestUri":"/greengrass/definition/subscriptions/{SubscriptionDefinitionId}/versions/{SubscriptionDefinitionVersionId}","responseCode":200},"input":{"type":"structure","members":{"NextToken":{"location":"querystring","locationName":"NextToken"},"SubscriptionDefinitionId":{"location":"uri","locationName":"SubscriptionDefinitionId"},"SubscriptionDefinitionVersionId":{"location":"uri","locationName":"SubscriptionDefinitionVersionId"}},"required":["SubscriptionDefinitionId","SubscriptionDefinitionVersionId"]},"output":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Definition":{"shape":"S2m"},"Id":{},"NextToken":{},"Version":{}}}},"ListBulkDeploymentDetailedReports":{"http":{"method":"GET","requestUri":"/greengrass/bulk/deployments/{BulkDeploymentId}/detailed-reports","responseCode":200},"input":{"type":"structure","members":{"BulkDeploymentId":{"location":"uri","locationName":"BulkDeploymentId"},"MaxResults":{"location":"querystring","locationName":"MaxResults"},"NextToken":{"location":"querystring","locationName":"NextToken"}},"required":["BulkDeploymentId"]},"output":{"type":"structure","members":{"Deployments":{"type":"list","member":{"type":"structure","members":{"CreatedAt":{},"DeploymentArn":{},"DeploymentId":{},"DeploymentStatus":{},"DeploymentType":{},"ErrorDetails":{"shape":"S3i"},"ErrorMessage":{},"GroupArn":{}}}},"NextToken":{}}}},"ListBulkDeployments":{"http":{"method":"GET","requestUri":"/greengrass/bulk/deployments","responseCode":200},"input":{"type":"structure","members":{"MaxResults":{"location":"querystring","locationName":"MaxResults"},"NextToken":{"location":"querystring","locationName":"NextToken"}}},"output":{"type":"structure","members":{"BulkDeployments":{"type":"list","member":{"type":"structure","members":{"BulkDeploymentArn":{},"BulkDeploymentId":{},"CreatedAt":{}}}},"NextToken":{}}}},"ListConnectorDefinitionVersions":{"http":{"method":"GET","requestUri":"/greengrass/definition/connectors/{ConnectorDefinitionId}/versions","responseCode":200},"input":{"type":"structure","members":{"ConnectorDefinitionId":{"location":"uri","locationName":"ConnectorDefinitionId"},"MaxResults":{"location":"querystring","locationName":"MaxResults"},"NextToken":{"location":"querystring","locationName":"NextToken"}},"required":["ConnectorDefinitionId"]},"output":{"type":"structure","members":{"NextToken":{},"Versions":{"shape":"S52"}}}},"ListConnectorDefinitions":{"http":{"method":"GET","requestUri":"/greengrass/definition/connectors","responseCode":200},"input":{"type":"structure","members":{"MaxResults":{"location":"querystring","locationName":"MaxResults"},"NextToken":{"location":"querystring","locationName":"NextToken"}}},"output":{"type":"structure","members":{"Definitions":{"shape":"S56"},"NextToken":{}}}},"ListCoreDefinitionVersions":{"http":{"method":"GET","requestUri":"/greengrass/definition/cores/{CoreDefinitionId}/versions","responseCode":200},"input":{"type":"structure","members":{"CoreDefinitionId":{"location":"uri","locationName":"CoreDefinitionId"},"MaxResults":{"location":"querystring","locationName":"MaxResults"},"NextToken":{"location":"querystring","locationName":"NextToken"}},"required":["CoreDefinitionId"]},"output":{"type":"structure","members":{"NextToken":{},"Versions":{"shape":"S52"}}}},"ListCoreDefinitions":{"http":{"method":"GET","requestUri":"/greengrass/definition/cores","responseCode":200},"input":{"type":"structure","members":{"MaxResults":{"location":"querystring","locationName":"MaxResults"},"NextToken":{"location":"querystring","locationName":"NextToken"}}},"output":{"type":"structure","members":{"Definitions":{"shape":"S56"},"NextToken":{}}}},"ListDeployments":{"http":{"method":"GET","requestUri":"/greengrass/groups/{GroupId}/deployments","responseCode":200},"input":{"type":"structure","members":{"GroupId":{"location":"uri","locationName":"GroupId"},"MaxResults":{"location":"querystring","locationName":"MaxResults"},"NextToken":{"location":"querystring","locationName":"NextToken"}},"required":["GroupId"]},"output":{"type":"structure","members":{"Deployments":{"type":"list","member":{"type":"structure","members":{"CreatedAt":{},"DeploymentArn":{},"DeploymentId":{},"DeploymentType":{},"GroupArn":{}}}},"NextToken":{}}}},"ListDeviceDefinitionVersions":{"http":{"method":"GET","requestUri":"/greengrass/definition/devices/{DeviceDefinitionId}/versions","responseCode":200},"input":{"type":"structure","members":{"DeviceDefinitionId":{"location":"uri","locationName":"DeviceDefinitionId"},"MaxResults":{"location":"querystring","locationName":"MaxResults"},"NextToken":{"location":"querystring","locationName":"NextToken"}},"required":["DeviceDefinitionId"]},"output":{"type":"structure","members":{"NextToken":{},"Versions":{"shape":"S52"}}}},"ListDeviceDefinitions":{"http":{"method":"GET","requestUri":"/greengrass/definition/devices","responseCode":200},"input":{"type":"structure","members":{"MaxResults":{"location":"querystring","locationName":"MaxResults"},"NextToken":{"location":"querystring","locationName":"NextToken"}}},"output":{"type":"structure","members":{"Definitions":{"shape":"S56"},"NextToken":{}}}},"ListFunctionDefinitionVersions":{"http":{"method":"GET","requestUri":"/greengrass/definition/functions/{FunctionDefinitionId}/versions","responseCode":200},"input":{"type":"structure","members":{"FunctionDefinitionId":{"location":"uri","locationName":"FunctionDefinitionId"},"MaxResults":{"location":"querystring","locationName":"MaxResults"},"NextToken":{"location":"querystring","locationName":"NextToken"}},"required":["FunctionDefinitionId"]},"output":{"type":"structure","members":{"NextToken":{},"Versions":{"shape":"S52"}}}},"ListFunctionDefinitions":{"http":{"method":"GET","requestUri":"/greengrass/definition/functions","responseCode":200},"input":{"type":"structure","members":{"MaxResults":{"location":"querystring","locationName":"MaxResults"},"NextToken":{"location":"querystring","locationName":"NextToken"}}},"output":{"type":"structure","members":{"Definitions":{"shape":"S56"},"NextToken":{}}}},"ListGroupCertificateAuthorities":{"http":{"method":"GET","requestUri":"/greengrass/groups/{GroupId}/certificateauthorities","responseCode":200},"input":{"type":"structure","members":{"GroupId":{"location":"uri","locationName":"GroupId"}},"required":["GroupId"]},"output":{"type":"structure","members":{"GroupCertificateAuthorities":{"type":"list","member":{"type":"structure","members":{"GroupCertificateAuthorityArn":{},"GroupCertificateAuthorityId":{}}}}}}},"ListGroupVersions":{"http":{"method":"GET","requestUri":"/greengrass/groups/{GroupId}/versions","responseCode":200},"input":{"type":"structure","members":{"GroupId":{"location":"uri","locationName":"GroupId"},"MaxResults":{"location":"querystring","locationName":"MaxResults"},"NextToken":{"location":"querystring","locationName":"NextToken"}},"required":["GroupId"]},"output":{"type":"structure","members":{"NextToken":{},"Versions":{"shape":"S52"}}}},"ListGroups":{"http":{"method":"GET","requestUri":"/greengrass/groups","responseCode":200},"input":{"type":"structure","members":{"MaxResults":{"location":"querystring","locationName":"MaxResults"},"NextToken":{"location":"querystring","locationName":"NextToken"}}},"output":{"type":"structure","members":{"Groups":{"type":"list","member":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Id":{},"LastUpdatedTimestamp":{},"LatestVersion":{},"LatestVersionArn":{},"Name":{}}}},"NextToken":{}}}},"ListLoggerDefinitionVersions":{"http":{"method":"GET","requestUri":"/greengrass/definition/loggers/{LoggerDefinitionId}/versions","responseCode":200},"input":{"type":"structure","members":{"LoggerDefinitionId":{"location":"uri","locationName":"LoggerDefinitionId"},"MaxResults":{"location":"querystring","locationName":"MaxResults"},"NextToken":{"location":"querystring","locationName":"NextToken"}},"required":["LoggerDefinitionId"]},"output":{"type":"structure","members":{"NextToken":{},"Versions":{"shape":"S52"}}}},"ListLoggerDefinitions":{"http":{"method":"GET","requestUri":"/greengrass/definition/loggers","responseCode":200},"input":{"type":"structure","members":{"MaxResults":{"location":"querystring","locationName":"MaxResults"},"NextToken":{"location":"querystring","locationName":"NextToken"}}},"output":{"type":"structure","members":{"Definitions":{"shape":"S56"},"NextToken":{}}}},"ListResourceDefinitionVersions":{"http":{"method":"GET","requestUri":"/greengrass/definition/resources/{ResourceDefinitionId}/versions","responseCode":200},"input":{"type":"structure","members":{"MaxResults":{"location":"querystring","locationName":"MaxResults"},"NextToken":{"location":"querystring","locationName":"NextToken"},"ResourceDefinitionId":{"location":"uri","locationName":"ResourceDefinitionId"}},"required":["ResourceDefinitionId"]},"output":{"type":"structure","members":{"NextToken":{},"Versions":{"shape":"S52"}}}},"ListResourceDefinitions":{"http":{"method":"GET","requestUri":"/greengrass/definition/resources","responseCode":200},"input":{"type":"structure","members":{"MaxResults":{"location":"querystring","locationName":"MaxResults"},"NextToken":{"location":"querystring","locationName":"NextToken"}}},"output":{"type":"structure","members":{"Definitions":{"shape":"S56"},"NextToken":{}}}},"ListSubscriptionDefinitionVersions":{"http":{"method":"GET","requestUri":"/greengrass/definition/subscriptions/{SubscriptionDefinitionId}/versions","responseCode":200},"input":{"type":"structure","members":{"MaxResults":{"location":"querystring","locationName":"MaxResults"},"NextToken":{"location":"querystring","locationName":"NextToken"},"SubscriptionDefinitionId":{"location":"uri","locationName":"SubscriptionDefinitionId"}},"required":["SubscriptionDefinitionId"]},"output":{"type":"structure","members":{"NextToken":{},"Versions":{"shape":"S52"}}}},"ListSubscriptionDefinitions":{"http":{"method":"GET","requestUri":"/greengrass/definition/subscriptions","responseCode":200},"input":{"type":"structure","members":{"MaxResults":{"location":"querystring","locationName":"MaxResults"},"NextToken":{"location":"querystring","locationName":"NextToken"}}},"output":{"type":"structure","members":{"Definitions":{"shape":"S56"},"NextToken":{}}}},"ListTagsForResource":{"http":{"method":"GET","requestUri":"/tags/{resource-arn}","responseCode":200},"input":{"type":"structure","members":{"ResourceArn":{"location":"uri","locationName":"resource-arn"}},"required":["ResourceArn"]},"output":{"type":"structure","members":{"tags":{"shape":"Sb"}}}},"ResetDeployments":{"http":{"requestUri":"/greengrass/groups/{GroupId}/deployments/$reset","responseCode":200},"input":{"type":"structure","members":{"AmznClientToken":{"location":"header","locationName":"X-Amzn-Client-Token"},"Force":{"type":"boolean"},"GroupId":{"location":"uri","locationName":"GroupId"}},"required":["GroupId"]},"output":{"type":"structure","members":{"DeploymentArn":{},"DeploymentId":{}}}},"StartBulkDeployment":{"http":{"requestUri":"/greengrass/bulk/deployments","responseCode":200},"input":{"type":"structure","members":{"AmznClientToken":{"location":"header","locationName":"X-Amzn-Client-Token"},"ExecutionRoleArn":{},"InputFileUri":{},"tags":{"shape":"Sb"}},"required":["ExecutionRoleArn","InputFileUri"]},"output":{"type":"structure","members":{"BulkDeploymentArn":{},"BulkDeploymentId":{}}}},"StopBulkDeployment":{"http":{"method":"PUT","requestUri":"/greengrass/bulk/deployments/{BulkDeploymentId}/$stop","responseCode":200},"input":{"type":"structure","members":{"BulkDeploymentId":{"location":"uri","locationName":"BulkDeploymentId"}},"required":["BulkDeploymentId"]},"output":{"type":"structure","members":{}}},"TagResource":{"http":{"requestUri":"/tags/{resource-arn}","responseCode":204},"input":{"type":"structure","members":{"ResourceArn":{"location":"uri","locationName":"resource-arn"},"tags":{"shape":"Sb"}},"required":["ResourceArn"]}},"UntagResource":{"http":{"method":"DELETE","requestUri":"/tags/{resource-arn}","responseCode":204},"input":{"type":"structure","members":{"ResourceArn":{"location":"uri","locationName":"resource-arn"},"TagKeys":{"shape":"S29","location":"querystring","locationName":"tagKeys"}},"required":["TagKeys","ResourceArn"]}},"UpdateConnectivityInfo":{"http":{"method":"PUT","requestUri":"/greengrass/things/{ThingName}/connectivityInfo","responseCode":200},"input":{"type":"structure","members":{"ConnectivityInfo":{"shape":"S3m"},"ThingName":{"location":"uri","locationName":"ThingName"}},"required":["ThingName"]},"output":{"type":"structure","members":{"Message":{"locationName":"message"},"Version":{}}}},"UpdateConnectorDefinition":{"http":{"method":"PUT","requestUri":"/greengrass/definition/connectors/{ConnectorDefinitionId}","responseCode":200},"input":{"type":"structure","members":{"ConnectorDefinitionId":{"location":"uri","locationName":"ConnectorDefinitionId"},"Name":{}},"required":["ConnectorDefinitionId"]},"output":{"type":"structure","members":{}}},"UpdateCoreDefinition":{"http":{"method":"PUT","requestUri":"/greengrass/definition/cores/{CoreDefinitionId}","responseCode":200},"input":{"type":"structure","members":{"CoreDefinitionId":{"location":"uri","locationName":"CoreDefinitionId"},"Name":{}},"required":["CoreDefinitionId"]},"output":{"type":"structure","members":{}}},"UpdateDeviceDefinition":{"http":{"method":"PUT","requestUri":"/greengrass/definition/devices/{DeviceDefinitionId}","responseCode":200},"input":{"type":"structure","members":{"DeviceDefinitionId":{"location":"uri","locationName":"DeviceDefinitionId"},"Name":{}},"required":["DeviceDefinitionId"]},"output":{"type":"structure","members":{}}},"UpdateFunctionDefinition":{"http":{"method":"PUT","requestUri":"/greengrass/definition/functions/{FunctionDefinitionId}","responseCode":200},"input":{"type":"structure","members":{"FunctionDefinitionId":{"location":"uri","locationName":"FunctionDefinitionId"},"Name":{}},"required":["FunctionDefinitionId"]},"output":{"type":"structure","members":{}}},"UpdateGroup":{"http":{"method":"PUT","requestUri":"/greengrass/groups/{GroupId}","responseCode":200},"input":{"type":"structure","members":{"GroupId":{"location":"uri","locationName":"GroupId"},"Name":{}},"required":["GroupId"]},"output":{"type":"structure","members":{}}},"UpdateGroupCertificateConfiguration":{"http":{"method":"PUT","requestUri":"/greengrass/groups/{GroupId}/certificateauthorities/configuration/expiry","responseCode":200},"input":{"type":"structure","members":{"CertificateExpiryInMilliseconds":{},"GroupId":{"location":"uri","locationName":"GroupId"}},"required":["GroupId"]},"output":{"type":"structure","members":{"CertificateAuthorityExpiryInMilliseconds":{},"CertificateExpiryInMilliseconds":{},"GroupId":{}}}},"UpdateLoggerDefinition":{"http":{"method":"PUT","requestUri":"/greengrass/definition/loggers/{LoggerDefinitionId}","responseCode":200},"input":{"type":"structure","members":{"LoggerDefinitionId":{"location":"uri","locationName":"LoggerDefinitionId"},"Name":{}},"required":["LoggerDefinitionId"]},"output":{"type":"structure","members":{}}},"UpdateResourceDefinition":{"http":{"method":"PUT","requestUri":"/greengrass/definition/resources/{ResourceDefinitionId}","responseCode":200},"input":{"type":"structure","members":{"Name":{},"ResourceDefinitionId":{"location":"uri","locationName":"ResourceDefinitionId"}},"required":["ResourceDefinitionId"]},"output":{"type":"structure","members":{}}},"UpdateSubscriptionDefinition":{"http":{"method":"PUT","requestUri":"/greengrass/definition/subscriptions/{SubscriptionDefinitionId}","responseCode":200},"input":{"type":"structure","members":{"Name":{},"SubscriptionDefinitionId":{"location":"uri","locationName":"SubscriptionDefinitionId"}},"required":["SubscriptionDefinitionId"]},"output":{"type":"structure","members":{}}}},"shapes":{"S7":{"type":"structure","members":{"Connectors":{"shape":"S8"}}},"S8":{"type":"list","member":{"type":"structure","members":{"ConnectorArn":{},"Id":{},"Parameters":{"shape":"Sa"}},"required":["ConnectorArn","Id"]}},"Sa":{"type":"map","key":{},"value":{}},"Sb":{"type":"map","key":{},"value":{}},"Sg":{"type":"structure","members":{"Cores":{"shape":"Sh"}}},"Sh":{"type":"list","member":{"type":"structure","members":{"CertificateArn":{},"Id":{},"SyncShadow":{"type":"boolean"},"ThingArn":{}},"required":["ThingArn","Id","CertificateArn"]}},"Sr":{"type":"structure","members":{"Devices":{"shape":"Ss"}}},"Ss":{"type":"list","member":{"type":"structure","members":{"CertificateArn":{},"Id":{},"SyncShadow":{"type":"boolean"},"ThingArn":{}},"required":["ThingArn","Id","CertificateArn"]}},"Sy":{"type":"structure","members":{"DefaultConfig":{"shape":"Sz"},"Functions":{"shape":"S14"}}},"Sz":{"type":"structure","members":{"Execution":{"type":"structure","members":{"IsolationMode":{},"RunAs":{"shape":"S12"}}}}},"S12":{"type":"structure","members":{"Gid":{"type":"integer"},"Uid":{"type":"integer"}}},"S14":{"type":"list","member":{"type":"structure","members":{"FunctionArn":{},"FunctionConfiguration":{"type":"structure","members":{"EncodingType":{},"Environment":{"type":"structure","members":{"AccessSysfs":{"type":"boolean"},"Execution":{"type":"structure","members":{"IsolationMode":{},"RunAs":{"shape":"S12"}}},"ResourceAccessPolicies":{"type":"list","member":{"type":"structure","members":{"Permission":{},"ResourceId":{}},"required":["ResourceId"]}},"Variables":{"shape":"Sa"}}},"ExecArgs":{},"Executable":{},"MemorySize":{"type":"integer"},"Pinned":{"type":"boolean"},"Timeout":{"type":"integer"}}},"Id":{}},"required":["Id"]}},"S1h":{"type":"structure","members":{"ConnectorDefinitionVersionArn":{},"CoreDefinitionVersionArn":{},"DeviceDefinitionVersionArn":{},"FunctionDefinitionVersionArn":{},"LoggerDefinitionVersionArn":{},"ResourceDefinitionVersionArn":{},"SubscriptionDefinitionVersionArn":{}}},"S1o":{"type":"structure","members":{"Loggers":{"shape":"S1p"}}},"S1p":{"type":"list","member":{"type":"structure","members":{"Component":{},"Id":{},"Level":{},"Space":{"type":"integer"},"Type":{}},"required":["Type","Level","Id","Component"]}},"S1y":{"type":"structure","members":{"Resources":{"shape":"S1z"}}},"S1z":{"type":"list","member":{"type":"structure","members":{"Id":{},"Name":{},"ResourceDataContainer":{"type":"structure","members":{"LocalDeviceResourceData":{"type":"structure","members":{"GroupOwnerSetting":{"shape":"S23"},"SourcePath":{}}},"LocalVolumeResourceData":{"type":"structure","members":{"DestinationPath":{},"GroupOwnerSetting":{"shape":"S23"},"SourcePath":{}}},"S3MachineLearningModelResourceData":{"type":"structure","members":{"DestinationPath":{},"OwnerSetting":{"shape":"S26"},"S3Uri":{}}},"SageMakerMachineLearningModelResourceData":{"type":"structure","members":{"DestinationPath":{},"OwnerSetting":{"shape":"S26"},"SageMakerJobArn":{}}},"SecretsManagerSecretResourceData":{"type":"structure","members":{"ARN":{},"AdditionalStagingLabelsToDownload":{"shape":"S29"}}}}}},"required":["ResourceDataContainer","Id","Name"]}},"S23":{"type":"structure","members":{"AutoAddGroupOwner":{"type":"boolean"},"GroupOwner":{}}},"S26":{"type":"structure","members":{"GroupOwner":{},"GroupPermission":{}},"required":["GroupOwner","GroupPermission"]},"S29":{"type":"list","member":{}},"S2m":{"type":"structure","members":{"Subscriptions":{"shape":"S2n"}}},"S2n":{"type":"list","member":{"type":"structure","members":{"Id":{},"Source":{},"Subject":{},"Target":{}},"required":["Target","Id","Subject","Source"]}},"S3i":{"type":"list","member":{"type":"structure","members":{"DetailedErrorCode":{},"DetailedErrorMessage":{}}}},"S3m":{"type":"list","member":{"type":"structure","members":{"HostAddress":{},"Id":{},"Metadata":{},"PortNumber":{"type":"integer"}}}},"S52":{"type":"list","member":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Id":{},"Version":{}}}},"S56":{"type":"list","member":{"type":"structure","members":{"Arn":{},"CreationTimestamp":{},"Id":{},"LastUpdatedTimestamp":{},"LatestVersion":{},"LatestVersionArn":{},"Name":{},"Tags":{"shape":"Sb","locationName":"tags"}}}}}}; +const keepAliveSupport = { + supported: undefined, +}; +class FetchHttpHandler { + config; + configProvider; + static create(instanceOrOptions) { + if (typeof instanceOrOptions?.handle === "function") { + return instanceOrOptions; + } + return new FetchHttpHandler(instanceOrOptions); + } + constructor(options) { + if (typeof options === "function") { + this.configProvider = options().then((opts) => opts || {}); + } + else { + this.config = options ?? {}; + this.configProvider = Promise.resolve(this.config); + } + if (keepAliveSupport.supported === undefined) { + keepAliveSupport.supported = Boolean(typeof Request !== "undefined" && "keepalive" in createRequest("https://[::1]")); + } + } + destroy() { + } + async handle(request, { abortSignal, requestTimeout: requestTimeout$1 } = {}) { + if (!this.config) { + this.config = await this.configProvider; + } + const requestTimeoutInMs = requestTimeout$1 ?? this.config.requestTimeout; + const keepAlive = this.config.keepAlive === true; + const credentials = this.config.credentials; + if (abortSignal?.aborted) { + const abortError = new Error("Request aborted"); + abortError.name = "AbortError"; + return Promise.reject(abortError); + } + let path = request.path; + const queryString = querystringBuilder.buildQueryString(request.query || {}); + if (queryString) { + path += `?${queryString}`; + } + if (request.fragment) { + path += `#${request.fragment}`; + } + let auth = ""; + if (request.username != null || request.password != null) { + const username = request.username ?? ""; + const password = request.password ?? ""; + auth = `${username}:${password}@`; + } + const { port, method } = request; + const url = `${request.protocol}//${auth}${request.hostname}${port ? `:${port}` : ""}${path}`; + const body = method === "GET" || method === "HEAD" ? undefined : request.body; + const requestOptions = { + body, + headers: new Headers(request.headers), + method: method, + credentials, + }; + if (this.config?.cache) { + requestOptions.cache = this.config.cache; + } + if (body) { + requestOptions.duplex = "half"; + } + if (typeof AbortController !== "undefined") { + requestOptions.signal = abortSignal; + } + if (keepAliveSupport.supported) { + requestOptions.keepalive = keepAlive; + } + if (typeof this.config.requestInit === "function") { + Object.assign(requestOptions, this.config.requestInit(request)); + } + let removeSignalEventListener = () => { }; + const fetchRequest = createRequest(url, requestOptions); + const raceOfPromises = [ + fetch(fetchRequest).then((response) => { + const fetchHeaders = response.headers; + const transformedHeaders = {}; + for (const pair of fetchHeaders.entries()) { + transformedHeaders[pair[0]] = pair[1]; + } + const hasReadableStream = response.body != undefined; + if (!hasReadableStream) { + return response.blob().then((body) => ({ + response: new protocolHttp.HttpResponse({ + headers: transformedHeaders, + reason: response.statusText, + statusCode: response.status, + body, + }), + })); + } + return { + response: new protocolHttp.HttpResponse({ + headers: transformedHeaders, + reason: response.statusText, + statusCode: response.status, + body: response.body, + }), + }; + }), + requestTimeout(requestTimeoutInMs), + ]; + if (abortSignal) { + raceOfPromises.push(new Promise((resolve, reject) => { + const onAbort = () => { + const abortError = new Error("Request aborted"); + abortError.name = "AbortError"; + reject(abortError); + }; + if (typeof abortSignal.addEventListener === "function") { + const signal = abortSignal; + signal.addEventListener("abort", onAbort, { once: true }); + removeSignalEventListener = () => signal.removeEventListener("abort", onAbort); + } + else { + abortSignal.onabort = onAbort; + } + })); + } + return Promise.race(raceOfPromises).finally(removeSignalEventListener); + } + updateHttpClientConfig(key, value) { + this.config = undefined; + this.configProvider = this.configProvider.then((config) => { + config[key] = value; + return config; + }); + } + httpHandlerConfigs() { + return this.config ?? {}; + } +} -/***/ }), +const streamCollector = async (stream) => { + if ((typeof Blob === "function" && stream instanceof Blob) || stream.constructor?.name === "Blob") { + if (Blob.prototype.arrayBuffer !== undefined) { + return new Uint8Array(await stream.arrayBuffer()); + } + return collectBlob(stream); + } + return collectStream(stream); +}; +async function collectBlob(blob) { + const base64 = await readToBase64(blob); + const arrayBuffer = utilBase64.fromBase64(base64); + return new Uint8Array(arrayBuffer); +} +async function collectStream(stream) { + const chunks = []; + const reader = stream.getReader(); + let isDone = false; + let length = 0; + while (!isDone) { + const { done, value } = await reader.read(); + if (value) { + chunks.push(value); + length += value.length; + } + isDone = done; + } + const collected = new Uint8Array(length); + let offset = 0; + for (const chunk of chunks) { + collected.set(chunk, offset); + offset += chunk.length; + } + return collected; +} +function readToBase64(blob) { + return new Promise((resolve, reject) => { + const reader = new FileReader(); + reader.onloadend = () => { + if (reader.readyState !== 2) { + return reject(new Error("Reader aborted too early")); + } + const result = (reader.result ?? ""); + const commaIndex = result.indexOf(","); + const dataOffset = commaIndex > -1 ? commaIndex + 1 : result.length; + resolve(result.substring(dataOffset)); + }; + reader.onabort = () => reject(new Error("Read aborted")); + reader.onerror = () => reject(reader.error); + reader.readAsDataURL(blob); + }); +} -/***/ 2077: -/***/ (function(module) { +exports.FetchHttpHandler = FetchHttpHandler; +exports.keepAliveSupport = keepAliveSupport; +exports.streamCollector = streamCollector; -module.exports = {"pagination":{}}; /***/ }), -/***/ 2086: -/***/ (function(module, __unusedexports, __webpack_require__) { - -var rng = __webpack_require__(6139); -var bytesToUuid = __webpack_require__(1722); - -// **`v1()` - Generate time-based UUID** -// -// Inspired by https://github.com/LiosK/UUID.js -// and http://docs.python.org/library/uuid.html - -var _nodeId; -var _clockseq; +/***/ 2711: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -// Previous uuid creation time -var _lastMSecs = 0; -var _lastNSecs = 0; +"use strict"; -// See https://github.com/broofa/node-uuid for API details -function v1(options, buf, offset) { - var i = buf && offset || 0; - var b = buf || []; - options = options || {}; - var node = options.node || _nodeId; - var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq; +var utilBufferFrom = __nccwpck_require__(4151); +var utilUtf8 = __nccwpck_require__(1577); +var buffer = __nccwpck_require__(181); +var crypto = __nccwpck_require__(6982); - // node and clockseq need to be initialized to random values if they're not - // specified. We do this lazily to minimize issues related to insufficient - // system entropy. See #189 - if (node == null || clockseq == null) { - var seedBytes = rng(); - if (node == null) { - // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1) - node = _nodeId = [ - seedBytes[0] | 0x01, - seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5] - ]; +class Hash { + algorithmIdentifier; + secret; + hash; + constructor(algorithmIdentifier, secret) { + this.algorithmIdentifier = algorithmIdentifier; + this.secret = secret; + this.reset(); } - if (clockseq == null) { - // Per 4.2.2, randomize (14 bit) clockseq - clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff; + update(toHash, encoding) { + this.hash.update(utilUtf8.toUint8Array(castSourceData(toHash, encoding))); + } + digest() { + return Promise.resolve(this.hash.digest()); + } + reset() { + this.hash = this.secret + ? crypto.createHmac(this.algorithmIdentifier, castSourceData(this.secret)) + : crypto.createHash(this.algorithmIdentifier); } - } - - // UUID timestamps are 100 nano-second units since the Gregorian epoch, - // (1582-10-15 00:00). JSNumbers aren't precise enough for this, so - // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs' - // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00. - var msecs = options.msecs !== undefined ? options.msecs : new Date().getTime(); - - // Per 4.2.1.2, use count of uuid's generated during the current clock - // cycle to simulate higher resolution clock - var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; - - // Time since last uuid creation (in msecs) - var dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs)/10000; - - // Per 4.2.1.2, Bump clockseq on clock regression - if (dt < 0 && options.clockseq === undefined) { - clockseq = clockseq + 1 & 0x3fff; - } - - // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new - // time interval - if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) { - nsecs = 0; - } - - // Per 4.2.1.2 Throw error if too many uuids are requested - if (nsecs >= 10000) { - throw new Error('uuid.v1(): Can\'t create more than 10M uuids/sec'); - } - - _lastMSecs = msecs; - _lastNSecs = nsecs; - _clockseq = clockseq; - - // Per 4.1.4 - Convert from unix epoch to Gregorian epoch - msecs += 12219292800000; - - // `time_low` - var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000; - b[i++] = tl >>> 24 & 0xff; - b[i++] = tl >>> 16 & 0xff; - b[i++] = tl >>> 8 & 0xff; - b[i++] = tl & 0xff; - - // `time_mid` - var tmh = (msecs / 0x100000000 * 10000) & 0xfffffff; - b[i++] = tmh >>> 8 & 0xff; - b[i++] = tmh & 0xff; - - // `time_high_and_version` - b[i++] = tmh >>> 24 & 0xf | 0x10; // include version - b[i++] = tmh >>> 16 & 0xff; - - // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant) - b[i++] = clockseq >>> 8 | 0x80; - - // `clock_seq_low` - b[i++] = clockseq & 0xff; - - // `node` - for (var n = 0; n < 6; ++n) { - b[i + n] = node[n]; - } - - return buf ? buf : bytesToUuid(b); +} +function castSourceData(toCast, encoding) { + if (buffer.Buffer.isBuffer(toCast)) { + return toCast; + } + if (typeof toCast === "string") { + return utilBufferFrom.fromString(toCast, encoding); + } + if (ArrayBuffer.isView(toCast)) { + return utilBufferFrom.fromArrayBuffer(toCast.buffer, toCast.byteOffset, toCast.byteLength); + } + return utilBufferFrom.fromArrayBuffer(toCast); } -module.exports = v1; - - -/***/ }), - -/***/ 2087: -/***/ (function(module) { +exports.Hash = Hash; -module.exports = require("os"); /***/ }), -/***/ 2106: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['migrationhub'] = {}; -AWS.MigrationHub = Service.defineService('migrationhub', ['2017-05-31']); -Object.defineProperty(apiLoader.services['migrationhub'], '2017-05-31', { - get: function get() { - var model = __webpack_require__(6686); - model.paginators = __webpack_require__(370).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.MigrationHub; - - -/***/ }), +/***/ 6130: +/***/ ((__unused_webpack_module, exports) => { -/***/ 2110: -/***/ (function(module, __unusedexports, __webpack_require__) { +"use strict"; -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; -apiLoader.services['synthetics'] = {}; -AWS.Synthetics = Service.defineService('synthetics', ['2017-10-11']); -Object.defineProperty(apiLoader.services['synthetics'], '2017-10-11', { - get: function get() { - var model = __webpack_require__(7717); - model.paginators = __webpack_require__(1340).pagination; - return model; - }, - enumerable: true, - configurable: true -}); +const isArrayBuffer = (arg) => (typeof ArrayBuffer === "function" && arg instanceof ArrayBuffer) || + Object.prototype.toString.call(arg) === "[object ArrayBuffer]"; -module.exports = AWS.Synthetics; +exports.isArrayBuffer = isArrayBuffer; /***/ }), -/***/ 2120: -/***/ (function(module) { +/***/ 7212: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -module.exports = {"pagination":{"GetBotAliases":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"GetBotChannelAssociations":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"GetBotVersions":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"GetBots":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"GetBuiltinIntents":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"GetBuiltinSlotTypes":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"GetIntentVersions":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"GetIntents":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"GetSlotTypeVersions":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"GetSlotTypes":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"}}}; - -/***/ }), - -/***/ 2145: -/***/ (function(module, __unusedexports, __webpack_require__) { +"use strict"; -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; -apiLoader.services['workmailmessageflow'] = {}; -AWS.WorkMailMessageFlow = Service.defineService('workmailmessageflow', ['2019-05-01']); -Object.defineProperty(apiLoader.services['workmailmessageflow'], '2019-05-01', { - get: function get() { - var model = __webpack_require__(3642); - model.paginators = __webpack_require__(2028).pagination; - return model; - }, - enumerable: true, - configurable: true +var protocolHttp = __nccwpck_require__(2356); + +const CONTENT_LENGTH_HEADER = "content-length"; +function contentLengthMiddleware(bodyLengthChecker) { + return (next) => async (args) => { + const request = args.request; + if (protocolHttp.HttpRequest.isInstance(request)) { + const { body, headers } = request; + if (body && + Object.keys(headers) + .map((str) => str.toLowerCase()) + .indexOf(CONTENT_LENGTH_HEADER) === -1) { + try { + const length = bodyLengthChecker(body); + request.headers = { + ...request.headers, + [CONTENT_LENGTH_HEADER]: String(length), + }; + } + catch (error) { + } + } + } + return next({ + ...args, + request, + }); + }; +} +const contentLengthMiddlewareOptions = { + step: "build", + tags: ["SET_CONTENT_LENGTH", "CONTENT_LENGTH"], + name: "contentLengthMiddleware", + override: true, +}; +const getContentLengthPlugin = (options) => ({ + applyToStack: (clientStack) => { + clientStack.add(contentLengthMiddleware(options.bodyLengthChecker), contentLengthMiddlewareOptions); + }, }); -module.exports = AWS.WorkMailMessageFlow; - +exports.contentLengthMiddleware = contentLengthMiddleware; +exports.contentLengthMiddlewareOptions = contentLengthMiddlewareOptions; +exports.getContentLengthPlugin = getContentLengthPlugin; -/***/ }), - -/***/ 2189: -/***/ (function(module) { - -module.exports = {"pagination":{"GetDedicatedIps":{"input_token":"NextToken","output_token":"NextToken","limit_key":"PageSize"},"ListConfigurationSets":{"input_token":"NextToken","output_token":"NextToken","limit_key":"PageSize"},"ListCustomVerificationEmailTemplates":{"input_token":"NextToken","output_token":"NextToken","limit_key":"PageSize"},"ListDedicatedIpPools":{"input_token":"NextToken","output_token":"NextToken","limit_key":"PageSize"},"ListDeliverabilityTestReports":{"input_token":"NextToken","output_token":"NextToken","limit_key":"PageSize"},"ListDomainDeliverabilityCampaigns":{"input_token":"NextToken","output_token":"NextToken","limit_key":"PageSize"},"ListEmailIdentities":{"input_token":"NextToken","output_token":"NextToken","limit_key":"PageSize"},"ListEmailTemplates":{"input_token":"NextToken","output_token":"NextToken","limit_key":"PageSize"},"ListSuppressedDestinations":{"input_token":"NextToken","output_token":"NextToken","limit_key":"PageSize"}}}; /***/ }), -/***/ 2214: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +/***/ 6041: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -apiLoader.services['cognitoidentity'] = {}; -AWS.CognitoIdentity = Service.defineService('cognitoidentity', ['2014-06-30']); -__webpack_require__(2382); -Object.defineProperty(apiLoader.services['cognitoidentity'], '2014-06-30', { - get: function get() { - var model = __webpack_require__(7056); - model.paginators = __webpack_require__(7280).pagination; - return model; - }, - enumerable: true, - configurable: true -}); +"use strict"; -module.exports = AWS.CognitoIdentity; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getEndpointFromConfig = void 0; +const node_config_provider_1 = __nccwpck_require__(5704); +const getEndpointUrlConfig_1 = __nccwpck_require__(8008); +const getEndpointFromConfig = async (serviceId) => (0, node_config_provider_1.loadConfig)((0, getEndpointUrlConfig_1.getEndpointUrlConfig)(serviceId ?? ""))(); +exports.getEndpointFromConfig = getEndpointFromConfig; /***/ }), -/***/ 2221: -/***/ (function(module, __unusedexports, __webpack_require__) { +/***/ 8008: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +"use strict"; -apiLoader.services['iotsitewise'] = {}; -AWS.IoTSiteWise = Service.defineService('iotsitewise', ['2019-12-02']); -Object.defineProperty(apiLoader.services['iotsitewise'], '2019-12-02', { - get: function get() { - var model = __webpack_require__(1872); - model.paginators = __webpack_require__(9090).pagination; - model.waiters = __webpack_require__(9472).waiters; - return model; - }, - enumerable: true, - configurable: true +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getEndpointUrlConfig = void 0; +const shared_ini_file_loader_1 = __nccwpck_require__(4964); +const ENV_ENDPOINT_URL = "AWS_ENDPOINT_URL"; +const CONFIG_ENDPOINT_URL = "endpoint_url"; +const getEndpointUrlConfig = (serviceId) => ({ + environmentVariableSelector: (env) => { + const serviceSuffixParts = serviceId.split(" ").map((w) => w.toUpperCase()); + const serviceEndpointUrl = env[[ENV_ENDPOINT_URL, ...serviceSuffixParts].join("_")]; + if (serviceEndpointUrl) + return serviceEndpointUrl; + const endpointUrl = env[ENV_ENDPOINT_URL]; + if (endpointUrl) + return endpointUrl; + return undefined; + }, + configFileSelector: (profile, config) => { + if (config && profile.services) { + const servicesSection = config[["services", profile.services].join(shared_ini_file_loader_1.CONFIG_PREFIX_SEPARATOR)]; + if (servicesSection) { + const servicePrefixParts = serviceId.split(" ").map((w) => w.toLowerCase()); + const endpointUrl = servicesSection[[servicePrefixParts.join("_"), CONFIG_ENDPOINT_URL].join(shared_ini_file_loader_1.CONFIG_PREFIX_SEPARATOR)]; + if (endpointUrl) + return endpointUrl; + } + } + const endpointUrl = profile[CONFIG_ENDPOINT_URL]; + if (endpointUrl) + return endpointUrl; + return undefined; + }, + default: undefined, }); - -module.exports = AWS.IoTSiteWise; +exports.getEndpointUrlConfig = getEndpointUrlConfig; /***/ }), -/***/ 2225: -/***/ (function(module) { - -module.exports = {"pagination":{}}; - -/***/ }), +/***/ 99: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -/***/ 2230: -/***/ (function(module) { +"use strict"; -module.exports = {"version":2,"waiters":{"ProjectVersionTrainingCompleted":{"description":"Wait until the ProjectVersion training completes.","operation":"DescribeProjectVersions","delay":120,"maxAttempts":360,"acceptors":[{"state":"success","matcher":"pathAll","argument":"ProjectVersionDescriptions[].Status","expected":"TRAINING_COMPLETED"},{"state":"failure","matcher":"pathAny","argument":"ProjectVersionDescriptions[].Status","expected":"TRAINING_FAILED"}]},"ProjectVersionRunning":{"description":"Wait until the ProjectVersion is running.","delay":30,"maxAttempts":40,"operation":"DescribeProjectVersions","acceptors":[{"state":"success","matcher":"pathAll","argument":"ProjectVersionDescriptions[].Status","expected":"RUNNING"},{"state":"failure","matcher":"pathAny","argument":"ProjectVersionDescriptions[].Status","expected":"FAILED"}]}}}; -/***/ }), +var getEndpointFromConfig = __nccwpck_require__(6041); +var urlParser = __nccwpck_require__(4494); +var core = __nccwpck_require__(402); +var utilMiddleware = __nccwpck_require__(6324); +var middlewareSerde = __nccwpck_require__(3255); -/***/ 2241: -/***/ (function(module) { +const resolveParamsForS3 = async (endpointParams) => { + const bucket = endpointParams?.Bucket || ""; + if (typeof endpointParams.Bucket === "string") { + endpointParams.Bucket = bucket.replace(/#/g, encodeURIComponent("#")).replace(/\?/g, encodeURIComponent("?")); + } + if (isArnBucketName(bucket)) { + if (endpointParams.ForcePathStyle === true) { + throw new Error("Path-style addressing cannot be used with ARN buckets"); + } + } + else if (!isDnsCompatibleBucketName(bucket) || + (bucket.indexOf(".") !== -1 && !String(endpointParams.Endpoint).startsWith("http:")) || + bucket.toLowerCase() !== bucket || + bucket.length < 3) { + endpointParams.ForcePathStyle = true; + } + if (endpointParams.DisableMultiRegionAccessPoints) { + endpointParams.disableMultiRegionAccessPoints = true; + endpointParams.DisableMRAP = true; + } + return endpointParams; +}; +const DOMAIN_PATTERN = /^[a-z0-9][a-z0-9\.\-]{1,61}[a-z0-9]$/; +const IP_ADDRESS_PATTERN = /(\d+\.){3}\d+/; +const DOTS_PATTERN = /\.\./; +const isDnsCompatibleBucketName = (bucketName) => DOMAIN_PATTERN.test(bucketName) && !IP_ADDRESS_PATTERN.test(bucketName) && !DOTS_PATTERN.test(bucketName); +const isArnBucketName = (bucketName) => { + const [arn, partition, service, , , bucket] = bucketName.split(":"); + const isArn = arn === "arn" && bucketName.split(":").length >= 6; + const isValidArn = Boolean(isArn && partition && service && bucket); + if (isArn && !isValidArn) { + throw new Error(`Invalid ARN: ${bucketName} was an invalid ARN.`); + } + return isValidArn; +}; -module.exports = {"metadata":{"apiVersion":"2018-09-05","endpointPrefix":"sms-voice.pinpoint","signingName":"sms-voice","serviceAbbreviation":"Pinpoint SMS Voice","serviceFullName":"Amazon Pinpoint SMS and Voice Service","serviceId":"Pinpoint SMS Voice","protocol":"rest-json","jsonVersion":"1.1","uid":"pinpoint-sms-voice-2018-09-05","signatureVersion":"v4"},"operations":{"CreateConfigurationSet":{"http":{"requestUri":"/v1/sms-voice/configuration-sets","responseCode":200},"input":{"type":"structure","members":{"ConfigurationSetName":{}}},"output":{"type":"structure","members":{}}},"CreateConfigurationSetEventDestination":{"http":{"requestUri":"/v1/sms-voice/configuration-sets/{ConfigurationSetName}/event-destinations","responseCode":200},"input":{"type":"structure","members":{"ConfigurationSetName":{"location":"uri","locationName":"ConfigurationSetName"},"EventDestination":{"shape":"S6"},"EventDestinationName":{}},"required":["ConfigurationSetName"]},"output":{"type":"structure","members":{}}},"DeleteConfigurationSet":{"http":{"method":"DELETE","requestUri":"/v1/sms-voice/configuration-sets/{ConfigurationSetName}","responseCode":200},"input":{"type":"structure","members":{"ConfigurationSetName":{"location":"uri","locationName":"ConfigurationSetName"}},"required":["ConfigurationSetName"]},"output":{"type":"structure","members":{}}},"DeleteConfigurationSetEventDestination":{"http":{"method":"DELETE","requestUri":"/v1/sms-voice/configuration-sets/{ConfigurationSetName}/event-destinations/{EventDestinationName}","responseCode":200},"input":{"type":"structure","members":{"ConfigurationSetName":{"location":"uri","locationName":"ConfigurationSetName"},"EventDestinationName":{"location":"uri","locationName":"EventDestinationName"}},"required":["EventDestinationName","ConfigurationSetName"]},"output":{"type":"structure","members":{}}},"GetConfigurationSetEventDestinations":{"http":{"method":"GET","requestUri":"/v1/sms-voice/configuration-sets/{ConfigurationSetName}/event-destinations","responseCode":200},"input":{"type":"structure","members":{"ConfigurationSetName":{"location":"uri","locationName":"ConfigurationSetName"}},"required":["ConfigurationSetName"]},"output":{"type":"structure","members":{"EventDestinations":{"type":"list","member":{"type":"structure","members":{"CloudWatchLogsDestination":{"shape":"S7"},"Enabled":{"type":"boolean"},"KinesisFirehoseDestination":{"shape":"Sa"},"MatchingEventTypes":{"shape":"Sb"},"Name":{},"SnsDestination":{"shape":"Sd"}}}}}}},"ListConfigurationSets":{"http":{"method":"GET","requestUri":"/v1/sms-voice/configuration-sets","responseCode":200},"input":{"type":"structure","members":{"NextToken":{"location":"querystring","locationName":"NextToken"},"PageSize":{"location":"querystring","locationName":"PageSize"}}},"output":{"type":"structure","members":{"ConfigurationSets":{"type":"list","member":{}},"NextToken":{}}}},"SendVoiceMessage":{"http":{"requestUri":"/v1/sms-voice/voice/message","responseCode":200},"input":{"type":"structure","members":{"CallerId":{},"ConfigurationSetName":{},"Content":{"type":"structure","members":{"CallInstructionsMessage":{"type":"structure","members":{"Text":{}},"required":[]},"PlainTextMessage":{"type":"structure","members":{"LanguageCode":{},"Text":{},"VoiceId":{}},"required":[]},"SSMLMessage":{"type":"structure","members":{"LanguageCode":{},"Text":{},"VoiceId":{}},"required":[]}}},"DestinationPhoneNumber":{},"OriginationPhoneNumber":{}}},"output":{"type":"structure","members":{"MessageId":{}}}},"UpdateConfigurationSetEventDestination":{"http":{"method":"PUT","requestUri":"/v1/sms-voice/configuration-sets/{ConfigurationSetName}/event-destinations/{EventDestinationName}","responseCode":200},"input":{"type":"structure","members":{"ConfigurationSetName":{"location":"uri","locationName":"ConfigurationSetName"},"EventDestination":{"shape":"S6"},"EventDestinationName":{"location":"uri","locationName":"EventDestinationName"}},"required":["EventDestinationName","ConfigurationSetName"]},"output":{"type":"structure","members":{}}}},"shapes":{"S6":{"type":"structure","members":{"CloudWatchLogsDestination":{"shape":"S7"},"Enabled":{"type":"boolean"},"KinesisFirehoseDestination":{"shape":"Sa"},"MatchingEventTypes":{"shape":"Sb"},"SnsDestination":{"shape":"Sd"}},"required":[]},"S7":{"type":"structure","members":{"IamRoleArn":{},"LogGroupArn":{}},"required":[]},"Sa":{"type":"structure","members":{"DeliveryStreamArn":{},"IamRoleArn":{}},"required":[]},"Sb":{"type":"list","member":{}},"Sd":{"type":"structure","members":{"TopicArn":{}},"required":[]}}}; +const createConfigValueProvider = (configKey, canonicalEndpointParamKey, config, isClientContextParam = false) => { + const configProvider = async () => { + let configValue; + if (isClientContextParam) { + const clientContextParams = config.clientContextParams; + const nestedValue = clientContextParams?.[configKey]; + configValue = nestedValue ?? config[configKey] ?? config[canonicalEndpointParamKey]; + } + else { + configValue = config[configKey] ?? config[canonicalEndpointParamKey]; + } + if (typeof configValue === "function") { + return configValue(); + } + return configValue; + }; + if (configKey === "credentialScope" || canonicalEndpointParamKey === "CredentialScope") { + return async () => { + const credentials = typeof config.credentials === "function" ? await config.credentials() : config.credentials; + const configValue = credentials?.credentialScope ?? credentials?.CredentialScope; + return configValue; + }; + } + if (configKey === "accountId" || canonicalEndpointParamKey === "AccountId") { + return async () => { + const credentials = typeof config.credentials === "function" ? await config.credentials() : config.credentials; + const configValue = credentials?.accountId ?? credentials?.AccountId; + return configValue; + }; + } + if (configKey === "endpoint" || canonicalEndpointParamKey === "endpoint") { + return async () => { + if (config.isCustomEndpoint === false) { + return undefined; + } + const endpoint = await configProvider(); + if (endpoint && typeof endpoint === "object") { + if ("url" in endpoint) { + return endpoint.url.href; + } + if ("hostname" in endpoint) { + const { protocol, hostname, port, path } = endpoint; + return `${protocol}//${hostname}${port ? ":" + port : ""}${path}`; + } + } + return endpoint; + }; + } + return configProvider; +}; -/***/ }), +const toEndpointV1 = (endpoint) => { + if (typeof endpoint === "object") { + if ("url" in endpoint) { + return urlParser.parseUrl(endpoint.url); + } + return endpoint; + } + return urlParser.parseUrl(endpoint); +}; -/***/ 2259: -/***/ (function(module, __unusedexports, __webpack_require__) { +const getEndpointFromInstructions = async (commandInput, instructionsSupplier, clientConfig, context) => { + if (!clientConfig.isCustomEndpoint) { + let endpointFromConfig; + if (clientConfig.serviceConfiguredEndpoint) { + endpointFromConfig = await clientConfig.serviceConfiguredEndpoint(); + } + else { + endpointFromConfig = await getEndpointFromConfig.getEndpointFromConfig(clientConfig.serviceId); + } + if (endpointFromConfig) { + clientConfig.endpoint = () => Promise.resolve(toEndpointV1(endpointFromConfig)); + clientConfig.isCustomEndpoint = true; + } + } + const endpointParams = await resolveParams(commandInput, instructionsSupplier, clientConfig); + if (typeof clientConfig.endpointProvider !== "function") { + throw new Error("config.endpointProvider is not set."); + } + const endpoint = clientConfig.endpointProvider(endpointParams, context); + return endpoint; +}; +const resolveParams = async (commandInput, instructionsSupplier, clientConfig) => { + const endpointParams = {}; + const instructions = instructionsSupplier?.getEndpointParameterInstructions?.() || {}; + for (const [name, instruction] of Object.entries(instructions)) { + switch (instruction.type) { + case "staticContextParams": + endpointParams[name] = instruction.value; + break; + case "contextParams": + endpointParams[name] = commandInput[instruction.name]; + break; + case "clientContextParams": + case "builtInParams": + endpointParams[name] = await createConfigValueProvider(instruction.name, name, clientConfig, instruction.type !== "builtInParams")(); + break; + case "operationContextParams": + endpointParams[name] = instruction.get(commandInput); + break; + default: + throw new Error("Unrecognized endpoint parameter instruction: " + JSON.stringify(instruction)); + } + } + if (Object.keys(instructions).length === 0) { + Object.assign(endpointParams, clientConfig); + } + if (String(clientConfig.serviceId).toLowerCase() === "s3") { + await resolveParamsForS3(endpointParams); + } + return endpointParams; +}; -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +const endpointMiddleware = ({ config, instructions, }) => { + return (next, context) => async (args) => { + if (config.isCustomEndpoint) { + core.setFeature(context, "ENDPOINT_OVERRIDE", "N"); + } + const endpoint = await getEndpointFromInstructions(args.input, { + getEndpointParameterInstructions() { + return instructions; + }, + }, { ...config }, context); + context.endpointV2 = endpoint; + context.authSchemes = endpoint.properties?.authSchemes; + const authScheme = context.authSchemes?.[0]; + if (authScheme) { + context["signing_region"] = authScheme.signingRegion; + context["signing_service"] = authScheme.signingName; + const smithyContext = utilMiddleware.getSmithyContext(context); + const httpAuthOption = smithyContext?.selectedHttpAuthScheme?.httpAuthOption; + if (httpAuthOption) { + httpAuthOption.signingProperties = Object.assign(httpAuthOption.signingProperties || {}, { + signing_region: authScheme.signingRegion, + signingRegion: authScheme.signingRegion, + signing_service: authScheme.signingName, + signingName: authScheme.signingName, + signingRegionSet: authScheme.signingRegionSet, + }, authScheme.properties); + } + } + return next({ + ...args, + }); + }; +}; -apiLoader.services['snowball'] = {}; -AWS.Snowball = Service.defineService('snowball', ['2016-06-30']); -Object.defineProperty(apiLoader.services['snowball'], '2016-06-30', { - get: function get() { - var model = __webpack_require__(4887); - model.paginators = __webpack_require__(184).pagination; - return model; - }, - enumerable: true, - configurable: true +const endpointMiddlewareOptions = { + step: "serialize", + tags: ["ENDPOINT_PARAMETERS", "ENDPOINT_V2", "ENDPOINT"], + name: "endpointV2Middleware", + override: true, + relation: "before", + toMiddleware: middlewareSerde.serializerMiddlewareOption.name, +}; +const getEndpointPlugin = (config, instructions) => ({ + applyToStack: (clientStack) => { + clientStack.addRelativeTo(endpointMiddleware({ + config, + instructions, + }), endpointMiddlewareOptions); + }, }); -module.exports = AWS.Snowball; - - -/***/ }), - -/***/ 2261: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2016-10-20","endpointPrefix":"budgets","jsonVersion":"1.1","protocol":"json","serviceAbbreviation":"AWSBudgets","serviceFullName":"AWS Budgets","serviceId":"Budgets","signatureVersion":"v4","targetPrefix":"AWSBudgetServiceGateway","uid":"budgets-2016-10-20"},"operations":{"CreateBudget":{"input":{"type":"structure","required":["AccountId","Budget"],"members":{"AccountId":{},"Budget":{"shape":"S3"},"NotificationsWithSubscribers":{"type":"list","member":{"type":"structure","required":["Notification","Subscribers"],"members":{"Notification":{"shape":"Sl"},"Subscribers":{"shape":"Sr"}}}}}},"output":{"type":"structure","members":{}}},"CreateNotification":{"input":{"type":"structure","required":["AccountId","BudgetName","Notification","Subscribers"],"members":{"AccountId":{},"BudgetName":{},"Notification":{"shape":"Sl"},"Subscribers":{"shape":"Sr"}}},"output":{"type":"structure","members":{}}},"CreateSubscriber":{"input":{"type":"structure","required":["AccountId","BudgetName","Notification","Subscriber"],"members":{"AccountId":{},"BudgetName":{},"Notification":{"shape":"Sl"},"Subscriber":{"shape":"Ss"}}},"output":{"type":"structure","members":{}}},"DeleteBudget":{"input":{"type":"structure","required":["AccountId","BudgetName"],"members":{"AccountId":{},"BudgetName":{}}},"output":{"type":"structure","members":{}}},"DeleteNotification":{"input":{"type":"structure","required":["AccountId","BudgetName","Notification"],"members":{"AccountId":{},"BudgetName":{},"Notification":{"shape":"Sl"}}},"output":{"type":"structure","members":{}}},"DeleteSubscriber":{"input":{"type":"structure","required":["AccountId","BudgetName","Notification","Subscriber"],"members":{"AccountId":{},"BudgetName":{},"Notification":{"shape":"Sl"},"Subscriber":{"shape":"Ss"}}},"output":{"type":"structure","members":{}}},"DescribeBudget":{"input":{"type":"structure","required":["AccountId","BudgetName"],"members":{"AccountId":{},"BudgetName":{}}},"output":{"type":"structure","members":{"Budget":{"shape":"S3"}}}},"DescribeBudgetPerformanceHistory":{"input":{"type":"structure","required":["AccountId","BudgetName"],"members":{"AccountId":{},"BudgetName":{},"TimePeriod":{"shape":"Sf"},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"BudgetPerformanceHistory":{"type":"structure","members":{"BudgetName":{},"BudgetType":{},"CostFilters":{"shape":"Sa"},"CostTypes":{"shape":"Sc"},"TimeUnit":{},"BudgetedAndActualAmountsList":{"type":"list","member":{"type":"structure","members":{"BudgetedAmount":{"shape":"S5"},"ActualAmount":{"shape":"S5"},"TimePeriod":{"shape":"Sf"}}}}}},"NextToken":{}}}},"DescribeBudgets":{"input":{"type":"structure","required":["AccountId"],"members":{"AccountId":{},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"Budgets":{"type":"list","member":{"shape":"S3"}},"NextToken":{}}}},"DescribeNotificationsForBudget":{"input":{"type":"structure","required":["AccountId","BudgetName"],"members":{"AccountId":{},"BudgetName":{},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"Notifications":{"type":"list","member":{"shape":"Sl"}},"NextToken":{}}}},"DescribeSubscribersForNotification":{"input":{"type":"structure","required":["AccountId","BudgetName","Notification"],"members":{"AccountId":{},"BudgetName":{},"Notification":{"shape":"Sl"},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"Subscribers":{"shape":"Sr"},"NextToken":{}}}},"UpdateBudget":{"input":{"type":"structure","required":["AccountId","NewBudget"],"members":{"AccountId":{},"NewBudget":{"shape":"S3"}}},"output":{"type":"structure","members":{}}},"UpdateNotification":{"input":{"type":"structure","required":["AccountId","BudgetName","OldNotification","NewNotification"],"members":{"AccountId":{},"BudgetName":{},"OldNotification":{"shape":"Sl"},"NewNotification":{"shape":"Sl"}}},"output":{"type":"structure","members":{}}},"UpdateSubscriber":{"input":{"type":"structure","required":["AccountId","BudgetName","Notification","OldSubscriber","NewSubscriber"],"members":{"AccountId":{},"BudgetName":{},"Notification":{"shape":"Sl"},"OldSubscriber":{"shape":"Ss"},"NewSubscriber":{"shape":"Ss"}}},"output":{"type":"structure","members":{}}}},"shapes":{"S3":{"type":"structure","required":["BudgetName","TimeUnit","BudgetType"],"members":{"BudgetName":{},"BudgetLimit":{"shape":"S5"},"PlannedBudgetLimits":{"type":"map","key":{},"value":{"shape":"S5"}},"CostFilters":{"shape":"Sa"},"CostTypes":{"shape":"Sc"},"TimeUnit":{},"TimePeriod":{"shape":"Sf"},"CalculatedSpend":{"type":"structure","required":["ActualSpend"],"members":{"ActualSpend":{"shape":"S5"},"ForecastedSpend":{"shape":"S5"}}},"BudgetType":{},"LastUpdatedTime":{"type":"timestamp"}}},"S5":{"type":"structure","required":["Amount","Unit"],"members":{"Amount":{},"Unit":{}}},"Sa":{"type":"map","key":{},"value":{"type":"list","member":{}}},"Sc":{"type":"structure","members":{"IncludeTax":{"type":"boolean"},"IncludeSubscription":{"type":"boolean"},"UseBlended":{"type":"boolean"},"IncludeRefund":{"type":"boolean"},"IncludeCredit":{"type":"boolean"},"IncludeUpfront":{"type":"boolean"},"IncludeRecurring":{"type":"boolean"},"IncludeOtherSubscription":{"type":"boolean"},"IncludeSupport":{"type":"boolean"},"IncludeDiscount":{"type":"boolean"},"UseAmortized":{"type":"boolean"}}},"Sf":{"type":"structure","members":{"Start":{"type":"timestamp"},"End":{"type":"timestamp"}}},"Sl":{"type":"structure","required":["NotificationType","ComparisonOperator","Threshold"],"members":{"NotificationType":{},"ComparisonOperator":{},"Threshold":{"type":"double"},"ThresholdType":{},"NotificationState":{}}},"Sr":{"type":"list","member":{"shape":"Ss"}},"Ss":{"type":"structure","required":["SubscriptionType","Address"],"members":{"SubscriptionType":{},"Address":{"type":"string","sensitive":true}}}}}; +const resolveEndpointConfig = (input) => { + const tls = input.tls ?? true; + const { endpoint, useDualstackEndpoint, useFipsEndpoint } = input; + const customEndpointProvider = endpoint != null ? async () => toEndpointV1(await utilMiddleware.normalizeProvider(endpoint)()) : undefined; + const isCustomEndpoint = !!endpoint; + const resolvedConfig = Object.assign(input, { + endpoint: customEndpointProvider, + tls, + isCustomEndpoint, + useDualstackEndpoint: utilMiddleware.normalizeProvider(useDualstackEndpoint ?? false), + useFipsEndpoint: utilMiddleware.normalizeProvider(useFipsEndpoint ?? false), + }); + let configuredEndpointPromise = undefined; + resolvedConfig.serviceConfiguredEndpoint = async () => { + if (input.serviceId && !configuredEndpointPromise) { + configuredEndpointPromise = getEndpointFromConfig.getEndpointFromConfig(input.serviceId); + } + return configuredEndpointPromise; + }; + return resolvedConfig; +}; -/***/ }), +const resolveEndpointRequiredConfig = (input) => { + const { endpoint } = input; + if (endpoint === undefined) { + input.endpoint = async () => { + throw new Error("@smithy/middleware-endpoint: (default endpointRuleSet) endpoint is not set - you must configure an endpoint."); + }; + } + return input; +}; -/***/ 2269: -/***/ (function(module) { +exports.endpointMiddleware = endpointMiddleware; +exports.endpointMiddlewareOptions = endpointMiddlewareOptions; +exports.getEndpointFromInstructions = getEndpointFromInstructions; +exports.getEndpointPlugin = getEndpointPlugin; +exports.resolveEndpointConfig = resolveEndpointConfig; +exports.resolveEndpointRequiredConfig = resolveEndpointRequiredConfig; +exports.resolveParams = resolveParams; +exports.toEndpointV1 = toEndpointV1; -module.exports = {"pagination":{"DescribeDBClusters":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DBClusters"},"DescribeDBEngineVersions":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DBEngineVersions"},"DescribeDBInstances":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DBInstances"},"DescribeDBSubnetGroups":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DBSubnetGroups"},"DescribeEvents":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"Events"},"DescribeOrderableDBInstanceOptions":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"OrderableDBInstanceOptions"},"ListTagsForResource":{"result_key":"TagList"}}}; /***/ }), -/***/ 2271: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['mediastoredata'] = {}; -AWS.MediaStoreData = Service.defineService('mediastoredata', ['2017-09-01']); -Object.defineProperty(apiLoader.services['mediastoredata'], '2017-09-01', { - get: function get() { - var model = __webpack_require__(8825); - model.paginators = __webpack_require__(4483).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.MediaStoreData; +/***/ 9618: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { +"use strict"; -/***/ }), - -/***/ 2304: -/***/ (function(module) { -module.exports = {"metadata":{"apiVersion":"2018-11-14","endpointPrefix":"kafka","signingName":"kafka","serviceFullName":"Managed Streaming for Kafka","serviceAbbreviation":"Kafka","serviceId":"Kafka","protocol":"rest-json","jsonVersion":"1.1","uid":"kafka-2018-11-14","signatureVersion":"v4"},"operations":{"CreateCluster":{"http":{"requestUri":"/v1/clusters","responseCode":200},"input":{"type":"structure","members":{"BrokerNodeGroupInfo":{"shape":"S2","locationName":"brokerNodeGroupInfo"},"ClientAuthentication":{"shape":"Sa","locationName":"clientAuthentication"},"ClusterName":{"locationName":"clusterName"},"ConfigurationInfo":{"shape":"Sd","locationName":"configurationInfo"},"EncryptionInfo":{"shape":"Sf","locationName":"encryptionInfo"},"EnhancedMonitoring":{"locationName":"enhancedMonitoring"},"OpenMonitoring":{"shape":"Sl","locationName":"openMonitoring"},"KafkaVersion":{"locationName":"kafkaVersion"},"LoggingInfo":{"shape":"Sq","locationName":"loggingInfo"},"NumberOfBrokerNodes":{"locationName":"numberOfBrokerNodes","type":"integer"},"Tags":{"shape":"Sw","locationName":"tags"}},"required":["BrokerNodeGroupInfo","KafkaVersion","NumberOfBrokerNodes","ClusterName"]},"output":{"type":"structure","members":{"ClusterArn":{"locationName":"clusterArn"},"ClusterName":{"locationName":"clusterName"},"State":{"locationName":"state"}}}},"CreateConfiguration":{"http":{"requestUri":"/v1/configurations","responseCode":200},"input":{"type":"structure","members":{"Description":{"locationName":"description"},"KafkaVersions":{"shape":"S4","locationName":"kafkaVersions"},"Name":{"locationName":"name"},"ServerProperties":{"locationName":"serverProperties","type":"blob"}},"required":["ServerProperties","Name"]},"output":{"type":"structure","members":{"Arn":{"locationName":"arn"},"CreationTime":{"shape":"S12","locationName":"creationTime"},"LatestRevision":{"shape":"S13","locationName":"latestRevision"},"Name":{"locationName":"name"}}}},"DeleteCluster":{"http":{"method":"DELETE","requestUri":"/v1/clusters/{clusterArn}","responseCode":200},"input":{"type":"structure","members":{"ClusterArn":{"location":"uri","locationName":"clusterArn"},"CurrentVersion":{"location":"querystring","locationName":"currentVersion"}},"required":["ClusterArn"]},"output":{"type":"structure","members":{"ClusterArn":{"locationName":"clusterArn"},"State":{"locationName":"state"}}}},"DescribeCluster":{"http":{"method":"GET","requestUri":"/v1/clusters/{clusterArn}","responseCode":200},"input":{"type":"structure","members":{"ClusterArn":{"location":"uri","locationName":"clusterArn"}},"required":["ClusterArn"]},"output":{"type":"structure","members":{"ClusterInfo":{"shape":"S18","locationName":"clusterInfo"}}}},"DescribeClusterOperation":{"http":{"method":"GET","requestUri":"/v1/operations/{clusterOperationArn}","responseCode":200},"input":{"type":"structure","members":{"ClusterOperationArn":{"location":"uri","locationName":"clusterOperationArn"}},"required":["ClusterOperationArn"]},"output":{"type":"structure","members":{"ClusterOperationInfo":{"shape":"S1i","locationName":"clusterOperationInfo"}}}},"DescribeConfiguration":{"http":{"method":"GET","requestUri":"/v1/configurations/{arn}","responseCode":200},"input":{"type":"structure","members":{"Arn":{"location":"uri","locationName":"arn"}},"required":["Arn"]},"output":{"type":"structure","members":{"Arn":{"locationName":"arn"},"CreationTime":{"shape":"S12","locationName":"creationTime"},"Description":{"locationName":"description"},"KafkaVersions":{"shape":"S4","locationName":"kafkaVersions"},"LatestRevision":{"shape":"S13","locationName":"latestRevision"},"Name":{"locationName":"name"}}}},"DescribeConfigurationRevision":{"http":{"method":"GET","requestUri":"/v1/configurations/{arn}/revisions/{revision}","responseCode":200},"input":{"type":"structure","members":{"Arn":{"location":"uri","locationName":"arn"},"Revision":{"location":"uri","locationName":"revision","type":"long"}},"required":["Revision","Arn"]},"output":{"type":"structure","members":{"Arn":{"locationName":"arn"},"CreationTime":{"shape":"S12","locationName":"creationTime"},"Description":{"locationName":"description"},"Revision":{"locationName":"revision","type":"long"},"ServerProperties":{"locationName":"serverProperties","type":"blob"}}}},"GetBootstrapBrokers":{"http":{"method":"GET","requestUri":"/v1/clusters/{clusterArn}/bootstrap-brokers","responseCode":200},"input":{"type":"structure","members":{"ClusterArn":{"location":"uri","locationName":"clusterArn"}},"required":["ClusterArn"]},"output":{"type":"structure","members":{"BootstrapBrokerString":{"locationName":"bootstrapBrokerString"},"BootstrapBrokerStringTls":{"locationName":"bootstrapBrokerStringTls"}}}},"GetCompatibleKafkaVersions":{"http":{"method":"GET","requestUri":"/v1/compatible-kafka-versions","responseCode":200},"input":{"type":"structure","members":{"ClusterArn":{"location":"querystring","locationName":"clusterArn"}}},"output":{"type":"structure","members":{"CompatibleKafkaVersions":{"locationName":"compatibleKafkaVersions","type":"list","member":{"type":"structure","members":{"SourceVersion":{"locationName":"sourceVersion"},"TargetVersions":{"shape":"S4","locationName":"targetVersions"}}}}}}},"ListClusterOperations":{"http":{"method":"GET","requestUri":"/v1/clusters/{clusterArn}/operations","responseCode":200},"input":{"type":"structure","members":{"ClusterArn":{"location":"uri","locationName":"clusterArn"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}},"required":["ClusterArn"]},"output":{"type":"structure","members":{"ClusterOperationInfoList":{"locationName":"clusterOperationInfoList","type":"list","member":{"shape":"S1i"}},"NextToken":{"locationName":"nextToken"}}}},"ListClusters":{"http":{"method":"GET","requestUri":"/v1/clusters","responseCode":200},"input":{"type":"structure","members":{"ClusterNameFilter":{"location":"querystring","locationName":"clusterNameFilter"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"ClusterInfoList":{"locationName":"clusterInfoList","type":"list","member":{"shape":"S18"}},"NextToken":{"locationName":"nextToken"}}}},"ListConfigurationRevisions":{"http":{"method":"GET","requestUri":"/v1/configurations/{arn}/revisions","responseCode":200},"input":{"type":"structure","members":{"Arn":{"location":"uri","locationName":"arn"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}},"required":["Arn"]},"output":{"type":"structure","members":{"NextToken":{"locationName":"nextToken"},"Revisions":{"locationName":"revisions","type":"list","member":{"shape":"S13"}}}}},"ListConfigurations":{"http":{"method":"GET","requestUri":"/v1/configurations","responseCode":200},"input":{"type":"structure","members":{"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"Configurations":{"locationName":"configurations","type":"list","member":{"type":"structure","members":{"Arn":{"locationName":"arn"},"CreationTime":{"shape":"S12","locationName":"creationTime"},"Description":{"locationName":"description"},"KafkaVersions":{"shape":"S4","locationName":"kafkaVersions"},"LatestRevision":{"shape":"S13","locationName":"latestRevision"},"Name":{"locationName":"name"}},"required":["Description","LatestRevision","CreationTime","KafkaVersions","Arn","Name"]}},"NextToken":{"locationName":"nextToken"}}}},"ListKafkaVersions":{"http":{"method":"GET","requestUri":"/v1/kafka-versions","responseCode":200},"input":{"type":"structure","members":{"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"KafkaVersions":{"locationName":"kafkaVersions","type":"list","member":{"type":"structure","members":{"Version":{"locationName":"version"},"Status":{"locationName":"status"}}}},"NextToken":{"locationName":"nextToken"}}}},"ListNodes":{"http":{"method":"GET","requestUri":"/v1/clusters/{clusterArn}/nodes","responseCode":200},"input":{"type":"structure","members":{"ClusterArn":{"location":"uri","locationName":"clusterArn"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}},"required":["ClusterArn"]},"output":{"type":"structure","members":{"NextToken":{"locationName":"nextToken"},"NodeInfoList":{"locationName":"nodeInfoList","type":"list","member":{"type":"structure","members":{"AddedToClusterTime":{"locationName":"addedToClusterTime"},"BrokerNodeInfo":{"locationName":"brokerNodeInfo","type":"structure","members":{"AttachedENIId":{"locationName":"attachedENIId"},"BrokerId":{"locationName":"brokerId","type":"double"},"ClientSubnet":{"locationName":"clientSubnet"},"ClientVpcIpAddress":{"locationName":"clientVpcIpAddress"},"CurrentBrokerSoftwareInfo":{"shape":"S19","locationName":"currentBrokerSoftwareInfo"},"Endpoints":{"shape":"S4","locationName":"endpoints"}}},"InstanceType":{"locationName":"instanceType"},"NodeARN":{"locationName":"nodeARN"},"NodeType":{"locationName":"nodeType"},"ZookeeperNodeInfo":{"locationName":"zookeeperNodeInfo","type":"structure","members":{"AttachedENIId":{"locationName":"attachedENIId"},"ClientVpcIpAddress":{"locationName":"clientVpcIpAddress"},"Endpoints":{"shape":"S4","locationName":"endpoints"},"ZookeeperId":{"locationName":"zookeeperId","type":"double"},"ZookeeperVersion":{"locationName":"zookeeperVersion"}}}}}}}}},"ListTagsForResource":{"http":{"method":"GET","requestUri":"/v1/tags/{resourceArn}","responseCode":200},"input":{"type":"structure","members":{"ResourceArn":{"location":"uri","locationName":"resourceArn"}},"required":["ResourceArn"]},"output":{"type":"structure","members":{"Tags":{"shape":"Sw","locationName":"tags"}}}},"RebootBroker":{"http":{"method":"PUT","requestUri":"/v1/clusters/{clusterArn}/reboot-broker","responseCode":200},"input":{"type":"structure","members":{"BrokerIds":{"shape":"S4","locationName":"brokerIds"},"ClusterArn":{"location":"uri","locationName":"clusterArn"}},"required":["ClusterArn","BrokerIds"]},"output":{"type":"structure","members":{"ClusterArn":{"locationName":"clusterArn"},"ClusterOperationArn":{"locationName":"clusterOperationArn"}}}},"TagResource":{"http":{"requestUri":"/v1/tags/{resourceArn}","responseCode":204},"input":{"type":"structure","members":{"ResourceArn":{"location":"uri","locationName":"resourceArn"},"Tags":{"shape":"Sw","locationName":"tags"}},"required":["ResourceArn","Tags"]}},"UntagResource":{"http":{"method":"DELETE","requestUri":"/v1/tags/{resourceArn}","responseCode":204},"input":{"type":"structure","members":{"ResourceArn":{"location":"uri","locationName":"resourceArn"},"TagKeys":{"shape":"S4","location":"querystring","locationName":"tagKeys"}},"required":["TagKeys","ResourceArn"]}},"UpdateBrokerCount":{"http":{"method":"PUT","requestUri":"/v1/clusters/{clusterArn}/nodes/count","responseCode":200},"input":{"type":"structure","members":{"ClusterArn":{"location":"uri","locationName":"clusterArn"},"CurrentVersion":{"locationName":"currentVersion"},"TargetNumberOfBrokerNodes":{"locationName":"targetNumberOfBrokerNodes","type":"integer"}},"required":["ClusterArn","CurrentVersion","TargetNumberOfBrokerNodes"]},"output":{"type":"structure","members":{"ClusterArn":{"locationName":"clusterArn"},"ClusterOperationArn":{"locationName":"clusterOperationArn"}}}},"UpdateBrokerStorage":{"http":{"method":"PUT","requestUri":"/v1/clusters/{clusterArn}/nodes/storage","responseCode":200},"input":{"type":"structure","members":{"ClusterArn":{"location":"uri","locationName":"clusterArn"},"CurrentVersion":{"locationName":"currentVersion"},"TargetBrokerEBSVolumeInfo":{"shape":"S1o","locationName":"targetBrokerEBSVolumeInfo"}},"required":["ClusterArn","TargetBrokerEBSVolumeInfo","CurrentVersion"]},"output":{"type":"structure","members":{"ClusterArn":{"locationName":"clusterArn"},"ClusterOperationArn":{"locationName":"clusterOperationArn"}}}},"UpdateClusterConfiguration":{"http":{"method":"PUT","requestUri":"/v1/clusters/{clusterArn}/configuration","responseCode":200},"input":{"type":"structure","members":{"ClusterArn":{"location":"uri","locationName":"clusterArn"},"ConfigurationInfo":{"shape":"Sd","locationName":"configurationInfo"},"CurrentVersion":{"locationName":"currentVersion"}},"required":["ClusterArn","CurrentVersion","ConfigurationInfo"]},"output":{"type":"structure","members":{"ClusterArn":{"locationName":"clusterArn"},"ClusterOperationArn":{"locationName":"clusterOperationArn"}}}},"UpdateClusterKafkaVersion":{"http":{"method":"PUT","requestUri":"/v1/clusters/{clusterArn}/version","responseCode":200},"input":{"type":"structure","members":{"ClusterArn":{"location":"uri","locationName":"clusterArn"},"ConfigurationInfo":{"shape":"Sd","locationName":"configurationInfo"},"CurrentVersion":{"locationName":"currentVersion"},"TargetKafkaVersion":{"locationName":"targetKafkaVersion"}},"required":["ClusterArn","TargetKafkaVersion","CurrentVersion"]},"output":{"type":"structure","members":{"ClusterArn":{"locationName":"clusterArn"},"ClusterOperationArn":{"locationName":"clusterOperationArn"}}}},"UpdateMonitoring":{"http":{"method":"PUT","requestUri":"/v1/clusters/{clusterArn}/monitoring","responseCode":200},"input":{"type":"structure","members":{"ClusterArn":{"location":"uri","locationName":"clusterArn"},"CurrentVersion":{"locationName":"currentVersion"},"EnhancedMonitoring":{"locationName":"enhancedMonitoring"},"OpenMonitoring":{"shape":"Sl","locationName":"openMonitoring"},"LoggingInfo":{"shape":"Sq","locationName":"loggingInfo"}},"required":["ClusterArn","CurrentVersion"]},"output":{"type":"structure","members":{"ClusterArn":{"locationName":"clusterArn"},"ClusterOperationArn":{"locationName":"clusterOperationArn"}}}}},"shapes":{"S2":{"type":"structure","members":{"BrokerAZDistribution":{"locationName":"brokerAZDistribution"},"ClientSubnets":{"shape":"S4","locationName":"clientSubnets"},"InstanceType":{"locationName":"instanceType"},"SecurityGroups":{"shape":"S4","locationName":"securityGroups"},"StorageInfo":{"locationName":"storageInfo","type":"structure","members":{"EbsStorageInfo":{"locationName":"ebsStorageInfo","type":"structure","members":{"VolumeSize":{"locationName":"volumeSize","type":"integer"}}}}}},"required":["ClientSubnets","InstanceType"]},"S4":{"type":"list","member":{}},"Sa":{"type":"structure","members":{"Tls":{"locationName":"tls","type":"structure","members":{"CertificateAuthorityArnList":{"shape":"S4","locationName":"certificateAuthorityArnList"}}}}},"Sd":{"type":"structure","members":{"Arn":{"locationName":"arn"},"Revision":{"locationName":"revision","type":"long"}},"required":["Revision","Arn"]},"Sf":{"type":"structure","members":{"EncryptionAtRest":{"locationName":"encryptionAtRest","type":"structure","members":{"DataVolumeKMSKeyId":{"locationName":"dataVolumeKMSKeyId"}},"required":["DataVolumeKMSKeyId"]},"EncryptionInTransit":{"locationName":"encryptionInTransit","type":"structure","members":{"ClientBroker":{"locationName":"clientBroker"},"InCluster":{"locationName":"inCluster","type":"boolean"}}}}},"Sl":{"type":"structure","members":{"Prometheus":{"locationName":"prometheus","type":"structure","members":{"JmxExporter":{"locationName":"jmxExporter","type":"structure","members":{"EnabledInBroker":{"locationName":"enabledInBroker","type":"boolean"}},"required":["EnabledInBroker"]},"NodeExporter":{"locationName":"nodeExporter","type":"structure","members":{"EnabledInBroker":{"locationName":"enabledInBroker","type":"boolean"}},"required":["EnabledInBroker"]}}}},"required":["Prometheus"]},"Sq":{"type":"structure","members":{"BrokerLogs":{"locationName":"brokerLogs","type":"structure","members":{"CloudWatchLogs":{"locationName":"cloudWatchLogs","type":"structure","members":{"Enabled":{"locationName":"enabled","type":"boolean"},"LogGroup":{"locationName":"logGroup"}},"required":["Enabled"]},"Firehose":{"locationName":"firehose","type":"structure","members":{"DeliveryStream":{"locationName":"deliveryStream"},"Enabled":{"locationName":"enabled","type":"boolean"}},"required":["Enabled"]},"S3":{"locationName":"s3","type":"structure","members":{"Bucket":{"locationName":"bucket"},"Enabled":{"locationName":"enabled","type":"boolean"},"Prefix":{"locationName":"prefix"}},"required":["Enabled"]}}}},"required":["BrokerLogs"]},"Sw":{"type":"map","key":{},"value":{}},"S12":{"type":"timestamp","timestampFormat":"iso8601"},"S13":{"type":"structure","members":{"CreationTime":{"shape":"S12","locationName":"creationTime"},"Description":{"locationName":"description"},"Revision":{"locationName":"revision","type":"long"}},"required":["Revision","CreationTime"]},"S18":{"type":"structure","members":{"ActiveOperationArn":{"locationName":"activeOperationArn"},"BrokerNodeGroupInfo":{"shape":"S2","locationName":"brokerNodeGroupInfo"},"ClientAuthentication":{"shape":"Sa","locationName":"clientAuthentication"},"ClusterArn":{"locationName":"clusterArn"},"ClusterName":{"locationName":"clusterName"},"CreationTime":{"shape":"S12","locationName":"creationTime"},"CurrentBrokerSoftwareInfo":{"shape":"S19","locationName":"currentBrokerSoftwareInfo"},"CurrentVersion":{"locationName":"currentVersion"},"EncryptionInfo":{"shape":"Sf","locationName":"encryptionInfo"},"EnhancedMonitoring":{"locationName":"enhancedMonitoring"},"OpenMonitoring":{"shape":"S1a","locationName":"openMonitoring"},"LoggingInfo":{"shape":"Sq","locationName":"loggingInfo"},"NumberOfBrokerNodes":{"locationName":"numberOfBrokerNodes","type":"integer"},"State":{"locationName":"state"},"StateInfo":{"locationName":"stateInfo","type":"structure","members":{"Code":{"locationName":"code"},"Message":{"locationName":"message"}}},"Tags":{"shape":"Sw","locationName":"tags"},"ZookeeperConnectString":{"locationName":"zookeeperConnectString"}}},"S19":{"type":"structure","members":{"ConfigurationArn":{"locationName":"configurationArn"},"ConfigurationRevision":{"locationName":"configurationRevision","type":"long"},"KafkaVersion":{"locationName":"kafkaVersion"}}},"S1a":{"type":"structure","members":{"Prometheus":{"locationName":"prometheus","type":"structure","members":{"JmxExporter":{"locationName":"jmxExporter","type":"structure","members":{"EnabledInBroker":{"locationName":"enabledInBroker","type":"boolean"}},"required":["EnabledInBroker"]},"NodeExporter":{"locationName":"nodeExporter","type":"structure","members":{"EnabledInBroker":{"locationName":"enabledInBroker","type":"boolean"}},"required":["EnabledInBroker"]}}}},"required":["Prometheus"]},"S1i":{"type":"structure","members":{"ClientRequestId":{"locationName":"clientRequestId"},"ClusterArn":{"locationName":"clusterArn"},"CreationTime":{"shape":"S12","locationName":"creationTime"},"EndTime":{"shape":"S12","locationName":"endTime"},"ErrorInfo":{"locationName":"errorInfo","type":"structure","members":{"ErrorCode":{"locationName":"errorCode"},"ErrorString":{"locationName":"errorString"}}},"OperationArn":{"locationName":"operationArn"},"OperationState":{"locationName":"operationState"},"OperationSteps":{"locationName":"operationSteps","type":"list","member":{"type":"structure","members":{"StepInfo":{"locationName":"stepInfo","type":"structure","members":{"StepStatus":{"locationName":"stepStatus"}}},"StepName":{"locationName":"stepName"}}}},"OperationType":{"locationName":"operationType"},"SourceClusterInfo":{"shape":"S1n","locationName":"sourceClusterInfo"},"TargetClusterInfo":{"shape":"S1n","locationName":"targetClusterInfo"}}},"S1n":{"type":"structure","members":{"BrokerEBSVolumeInfo":{"shape":"S1o","locationName":"brokerEBSVolumeInfo"},"ConfigurationInfo":{"shape":"Sd","locationName":"configurationInfo"},"NumberOfBrokerNodes":{"locationName":"numberOfBrokerNodes","type":"integer"},"EnhancedMonitoring":{"locationName":"enhancedMonitoring"},"OpenMonitoring":{"shape":"S1a","locationName":"openMonitoring"},"KafkaVersion":{"locationName":"kafkaVersion"},"LoggingInfo":{"shape":"Sq","locationName":"loggingInfo"}}},"S1o":{"type":"list","member":{"type":"structure","members":{"KafkaBrokerNodeId":{"locationName":"kafkaBrokerNodeId"},"VolumeSizeGB":{"locationName":"volumeSizeGB","type":"integer"}},"required":["VolumeSizeGB","KafkaBrokerNodeId"]}}}}; +var utilRetry = __nccwpck_require__(5518); +var protocolHttp = __nccwpck_require__(2356); +var serviceErrorClassification = __nccwpck_require__(2058); +var uuid = __nccwpck_require__(266); +var utilMiddleware = __nccwpck_require__(6324); +var smithyClient = __nccwpck_require__(1411); +var isStreamingPayload = __nccwpck_require__(9831); + +const getDefaultRetryQuota = (initialRetryTokens, options) => { + const MAX_CAPACITY = initialRetryTokens; + const noRetryIncrement = utilRetry.NO_RETRY_INCREMENT; + const retryCost = utilRetry.RETRY_COST; + const timeoutRetryCost = utilRetry.TIMEOUT_RETRY_COST; + let availableCapacity = initialRetryTokens; + const getCapacityAmount = (error) => (error.name === "TimeoutError" ? timeoutRetryCost : retryCost); + const hasRetryTokens = (error) => getCapacityAmount(error) <= availableCapacity; + const retrieveRetryTokens = (error) => { + if (!hasRetryTokens(error)) { + throw new Error("No retry token available"); + } + const capacityAmount = getCapacityAmount(error); + availableCapacity -= capacityAmount; + return capacityAmount; + }; + const releaseRetryTokens = (capacityReleaseAmount) => { + availableCapacity += capacityReleaseAmount ?? noRetryIncrement; + availableCapacity = Math.min(availableCapacity, MAX_CAPACITY); + }; + return Object.freeze({ + hasRetryTokens, + retrieveRetryTokens, + releaseRetryTokens, + }); +}; -/***/ }), +const defaultDelayDecider = (delayBase, attempts) => Math.floor(Math.min(utilRetry.MAXIMUM_RETRY_DELAY, Math.random() * 2 ** attempts * delayBase)); -/***/ 2317: -/***/ (function(module, __unusedexports, __webpack_require__) { +const defaultRetryDecider = (error) => { + if (!error) { + return false; + } + return serviceErrorClassification.isRetryableByTrait(error) || serviceErrorClassification.isClockSkewError(error) || serviceErrorClassification.isThrottlingError(error) || serviceErrorClassification.isTransientError(error); +}; -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +const asSdkError = (error) => { + if (error instanceof Error) + return error; + if (error instanceof Object) + return Object.assign(new Error(), error); + if (typeof error === "string") + return new Error(error); + return new Error(`AWS SDK error wrapper for ${error}`); +}; -apiLoader.services['codedeploy'] = {}; -AWS.CodeDeploy = Service.defineService('codedeploy', ['2014-10-06']); -Object.defineProperty(apiLoader.services['codedeploy'], '2014-10-06', { - get: function get() { - var model = __webpack_require__(4721); - model.paginators = __webpack_require__(2971).pagination; - model.waiters = __webpack_require__(1154).waiters; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.CodeDeploy; - - -/***/ }), - -/***/ 2323: -/***/ (function(module) { - -module.exports = {"pagination":{}}; +class StandardRetryStrategy { + maxAttemptsProvider; + retryDecider; + delayDecider; + retryQuota; + mode = utilRetry.RETRY_MODES.STANDARD; + constructor(maxAttemptsProvider, options) { + this.maxAttemptsProvider = maxAttemptsProvider; + this.retryDecider = options?.retryDecider ?? defaultRetryDecider; + this.delayDecider = options?.delayDecider ?? defaultDelayDecider; + this.retryQuota = options?.retryQuota ?? getDefaultRetryQuota(utilRetry.INITIAL_RETRY_TOKENS); + } + shouldRetry(error, attempts, maxAttempts) { + return attempts < maxAttempts && this.retryDecider(error) && this.retryQuota.hasRetryTokens(error); + } + async getMaxAttempts() { + let maxAttempts; + try { + maxAttempts = await this.maxAttemptsProvider(); + } + catch (error) { + maxAttempts = utilRetry.DEFAULT_MAX_ATTEMPTS; + } + return maxAttempts; + } + async retry(next, args, options) { + let retryTokenAmount; + let attempts = 0; + let totalDelay = 0; + const maxAttempts = await this.getMaxAttempts(); + const { request } = args; + if (protocolHttp.HttpRequest.isInstance(request)) { + request.headers[utilRetry.INVOCATION_ID_HEADER] = uuid.v4(); + } + while (true) { + try { + if (protocolHttp.HttpRequest.isInstance(request)) { + request.headers[utilRetry.REQUEST_HEADER] = `attempt=${attempts + 1}; max=${maxAttempts}`; + } + if (options?.beforeRequest) { + await options.beforeRequest(); + } + const { response, output } = await next(args); + if (options?.afterRequest) { + options.afterRequest(response); + } + this.retryQuota.releaseRetryTokens(retryTokenAmount); + output.$metadata.attempts = attempts + 1; + output.$metadata.totalRetryDelay = totalDelay; + return { response, output }; + } + catch (e) { + const err = asSdkError(e); + attempts++; + if (this.shouldRetry(err, attempts, maxAttempts)) { + retryTokenAmount = this.retryQuota.retrieveRetryTokens(err); + const delayFromDecider = this.delayDecider(serviceErrorClassification.isThrottlingError(err) ? utilRetry.THROTTLING_RETRY_DELAY_BASE : utilRetry.DEFAULT_RETRY_DELAY_BASE, attempts); + const delayFromResponse = getDelayFromRetryAfterHeader(err.$response); + const delay = Math.max(delayFromResponse || 0, delayFromDecider); + totalDelay += delay; + await new Promise((resolve) => setTimeout(resolve, delay)); + continue; + } + if (!err.$metadata) { + err.$metadata = {}; + } + err.$metadata.attempts = attempts; + err.$metadata.totalRetryDelay = totalDelay; + throw err; + } + } + } +} +const getDelayFromRetryAfterHeader = (response) => { + if (!protocolHttp.HttpResponse.isInstance(response)) + return; + const retryAfterHeaderName = Object.keys(response.headers).find((key) => key.toLowerCase() === "retry-after"); + if (!retryAfterHeaderName) + return; + const retryAfter = response.headers[retryAfterHeaderName]; + const retryAfterSeconds = Number(retryAfter); + if (!Number.isNaN(retryAfterSeconds)) + return retryAfterSeconds * 1000; + const retryAfterDate = new Date(retryAfter); + return retryAfterDate.getTime() - Date.now(); +}; -/***/ }), +class AdaptiveRetryStrategy extends StandardRetryStrategy { + rateLimiter; + constructor(maxAttemptsProvider, options) { + const { rateLimiter, ...superOptions } = options ?? {}; + super(maxAttemptsProvider, superOptions); + this.rateLimiter = rateLimiter ?? new utilRetry.DefaultRateLimiter(); + this.mode = utilRetry.RETRY_MODES.ADAPTIVE; + } + async retry(next, args) { + return super.retry(next, args, { + beforeRequest: async () => { + return this.rateLimiter.getSendToken(); + }, + afterRequest: (response) => { + this.rateLimiter.updateClientSendingRate(response); + }, + }); + } +} -/***/ 2327: -/***/ (function(module, __unusedexports, __webpack_require__) { +const ENV_MAX_ATTEMPTS = "AWS_MAX_ATTEMPTS"; +const CONFIG_MAX_ATTEMPTS = "max_attempts"; +const NODE_MAX_ATTEMPT_CONFIG_OPTIONS = { + environmentVariableSelector: (env) => { + const value = env[ENV_MAX_ATTEMPTS]; + if (!value) + return undefined; + const maxAttempt = parseInt(value); + if (Number.isNaN(maxAttempt)) { + throw new Error(`Environment variable ${ENV_MAX_ATTEMPTS} mast be a number, got "${value}"`); + } + return maxAttempt; + }, + configFileSelector: (profile) => { + const value = profile[CONFIG_MAX_ATTEMPTS]; + if (!value) + return undefined; + const maxAttempt = parseInt(value); + if (Number.isNaN(maxAttempt)) { + throw new Error(`Shared config file entry ${CONFIG_MAX_ATTEMPTS} mast be a number, got "${value}"`); + } + return maxAttempt; + }, + default: utilRetry.DEFAULT_MAX_ATTEMPTS, +}; +const resolveRetryConfig = (input) => { + const { retryStrategy, retryMode: _retryMode, maxAttempts: _maxAttempts } = input; + const maxAttempts = utilMiddleware.normalizeProvider(_maxAttempts ?? utilRetry.DEFAULT_MAX_ATTEMPTS); + return Object.assign(input, { + maxAttempts, + retryStrategy: async () => { + if (retryStrategy) { + return retryStrategy; + } + const retryMode = await utilMiddleware.normalizeProvider(_retryMode)(); + if (retryMode === utilRetry.RETRY_MODES.ADAPTIVE) { + return new utilRetry.AdaptiveRetryStrategy(maxAttempts); + } + return new utilRetry.StandardRetryStrategy(maxAttempts); + }, + }); +}; +const ENV_RETRY_MODE = "AWS_RETRY_MODE"; +const CONFIG_RETRY_MODE = "retry_mode"; +const NODE_RETRY_MODE_CONFIG_OPTIONS = { + environmentVariableSelector: (env) => env[ENV_RETRY_MODE], + configFileSelector: (profile) => profile[CONFIG_RETRY_MODE], + default: utilRetry.DEFAULT_RETRY_MODE, +}; -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +const omitRetryHeadersMiddleware = () => (next) => async (args) => { + const { request } = args; + if (protocolHttp.HttpRequest.isInstance(request)) { + delete request.headers[utilRetry.INVOCATION_ID_HEADER]; + delete request.headers[utilRetry.REQUEST_HEADER]; + } + return next(args); +}; +const omitRetryHeadersMiddlewareOptions = { + name: "omitRetryHeadersMiddleware", + tags: ["RETRY", "HEADERS", "OMIT_RETRY_HEADERS"], + relation: "before", + toMiddleware: "awsAuthMiddleware", + override: true, +}; +const getOmitRetryHeadersPlugin = (options) => ({ + applyToStack: (clientStack) => { + clientStack.addRelativeTo(omitRetryHeadersMiddleware(), omitRetryHeadersMiddlewareOptions); + }, +}); -apiLoader.services['iotthingsgraph'] = {}; -AWS.IoTThingsGraph = Service.defineService('iotthingsgraph', ['2018-09-06']); -Object.defineProperty(apiLoader.services['iotthingsgraph'], '2018-09-06', { - get: function get() { - var model = __webpack_require__(9187); - model.paginators = __webpack_require__(6433).pagination; - return model; - }, - enumerable: true, - configurable: true +const retryMiddleware = (options) => (next, context) => async (args) => { + let retryStrategy = await options.retryStrategy(); + const maxAttempts = await options.maxAttempts(); + if (isRetryStrategyV2(retryStrategy)) { + retryStrategy = retryStrategy; + let retryToken = await retryStrategy.acquireInitialRetryToken(context["partition_id"]); + let lastError = new Error(); + let attempts = 0; + let totalRetryDelay = 0; + const { request } = args; + const isRequest = protocolHttp.HttpRequest.isInstance(request); + if (isRequest) { + request.headers[utilRetry.INVOCATION_ID_HEADER] = uuid.v4(); + } + while (true) { + try { + if (isRequest) { + request.headers[utilRetry.REQUEST_HEADER] = `attempt=${attempts + 1}; max=${maxAttempts}`; + } + const { response, output } = await next(args); + retryStrategy.recordSuccess(retryToken); + output.$metadata.attempts = attempts + 1; + output.$metadata.totalRetryDelay = totalRetryDelay; + return { response, output }; + } + catch (e) { + const retryErrorInfo = getRetryErrorInfo(e); + lastError = asSdkError(e); + if (isRequest && isStreamingPayload.isStreamingPayload(request)) { + (context.logger instanceof smithyClient.NoOpLogger ? console : context.logger)?.warn("An error was encountered in a non-retryable streaming request."); + throw lastError; + } + try { + retryToken = await retryStrategy.refreshRetryTokenForRetry(retryToken, retryErrorInfo); + } + catch (refreshError) { + if (!lastError.$metadata) { + lastError.$metadata = {}; + } + lastError.$metadata.attempts = attempts + 1; + lastError.$metadata.totalRetryDelay = totalRetryDelay; + throw lastError; + } + attempts = retryToken.getRetryCount(); + const delay = retryToken.getRetryDelay(); + totalRetryDelay += delay; + await new Promise((resolve) => setTimeout(resolve, delay)); + } + } + } + else { + retryStrategy = retryStrategy; + if (retryStrategy?.mode) + context.userAgent = [...(context.userAgent || []), ["cfg/retry-mode", retryStrategy.mode]]; + return retryStrategy.retry(next, args); + } +}; +const isRetryStrategyV2 = (retryStrategy) => typeof retryStrategy.acquireInitialRetryToken !== "undefined" && + typeof retryStrategy.refreshRetryTokenForRetry !== "undefined" && + typeof retryStrategy.recordSuccess !== "undefined"; +const getRetryErrorInfo = (error) => { + const errorInfo = { + error, + errorType: getRetryErrorType(error), + }; + const retryAfterHint = getRetryAfterHint(error.$response); + if (retryAfterHint) { + errorInfo.retryAfterHint = retryAfterHint; + } + return errorInfo; +}; +const getRetryErrorType = (error) => { + if (serviceErrorClassification.isThrottlingError(error)) + return "THROTTLING"; + if (serviceErrorClassification.isTransientError(error)) + return "TRANSIENT"; + if (serviceErrorClassification.isServerError(error)) + return "SERVER_ERROR"; + return "CLIENT_ERROR"; +}; +const retryMiddlewareOptions = { + name: "retryMiddleware", + tags: ["RETRY"], + step: "finalizeRequest", + priority: "high", + override: true, +}; +const getRetryPlugin = (options) => ({ + applyToStack: (clientStack) => { + clientStack.add(retryMiddleware(options), retryMiddlewareOptions); + }, }); +const getRetryAfterHint = (response) => { + if (!protocolHttp.HttpResponse.isInstance(response)) + return; + const retryAfterHeaderName = Object.keys(response.headers).find((key) => key.toLowerCase() === "retry-after"); + if (!retryAfterHeaderName) + return; + const retryAfter = response.headers[retryAfterHeaderName]; + const retryAfterSeconds = Number(retryAfter); + if (!Number.isNaN(retryAfterSeconds)) + return new Date(retryAfterSeconds * 1000); + const retryAfterDate = new Date(retryAfter); + return retryAfterDate; +}; -module.exports = AWS.IoTThingsGraph; +exports.AdaptiveRetryStrategy = AdaptiveRetryStrategy; +exports.CONFIG_MAX_ATTEMPTS = CONFIG_MAX_ATTEMPTS; +exports.CONFIG_RETRY_MODE = CONFIG_RETRY_MODE; +exports.ENV_MAX_ATTEMPTS = ENV_MAX_ATTEMPTS; +exports.ENV_RETRY_MODE = ENV_RETRY_MODE; +exports.NODE_MAX_ATTEMPT_CONFIG_OPTIONS = NODE_MAX_ATTEMPT_CONFIG_OPTIONS; +exports.NODE_RETRY_MODE_CONFIG_OPTIONS = NODE_RETRY_MODE_CONFIG_OPTIONS; +exports.StandardRetryStrategy = StandardRetryStrategy; +exports.defaultDelayDecider = defaultDelayDecider; +exports.defaultRetryDecider = defaultRetryDecider; +exports.getOmitRetryHeadersPlugin = getOmitRetryHeadersPlugin; +exports.getRetryAfterHint = getRetryAfterHint; +exports.getRetryPlugin = getRetryPlugin; +exports.omitRetryHeadersMiddleware = omitRetryHeadersMiddleware; +exports.omitRetryHeadersMiddlewareOptions = omitRetryHeadersMiddlewareOptions; +exports.resolveRetryConfig = resolveRetryConfig; +exports.retryMiddleware = retryMiddleware; +exports.retryMiddlewareOptions = retryMiddlewareOptions; /***/ }), -/***/ 2336: -/***/ (function(module) { - -module.exports = {"version":2,"waiters":{"ResourceRecordSetsChanged":{"delay":30,"maxAttempts":60,"operation":"GetChange","acceptors":[{"matcher":"path","expected":"INSYNC","argument":"ChangeInfo.Status","state":"success"}]}}}; +/***/ 9831: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -/***/ }), +"use strict"; -/***/ 2339: -/***/ (function(module, __unusedexports, __webpack_require__) { +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.isStreamingPayload = void 0; +const stream_1 = __nccwpck_require__(2203); +const isStreamingPayload = (request) => request?.body instanceof stream_1.Readable || + (typeof ReadableStream !== "undefined" && request?.body instanceof ReadableStream); +exports.isStreamingPayload = isStreamingPayload; -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; -apiLoader.services['mediapackagevod'] = {}; -AWS.MediaPackageVod = Service.defineService('mediapackagevod', ['2018-11-07']); -Object.defineProperty(apiLoader.services['mediapackagevod'], '2018-11-07', { - get: function get() { - var model = __webpack_require__(5351); - model.paginators = __webpack_require__(5826).pagination; - return model; - }, - enumerable: true, - configurable: true -}); +/***/ }), -module.exports = AWS.MediaPackageVod; +/***/ 3255: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { +"use strict"; -/***/ }), -/***/ 2382: -/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) { +var protocolHttp = __nccwpck_require__(2356); -var AWS = __webpack_require__(395); +const deserializerMiddleware = (options, deserializer) => (next, context) => async (args) => { + const { response } = await next(args); + try { + const parsed = await deserializer(response, options); + return { + response, + output: parsed, + }; + } + catch (error) { + Object.defineProperty(error, "$response", { + value: response, + enumerable: false, + writable: false, + configurable: false, + }); + if (!("$metadata" in error)) { + const hint = `Deserialization error: to see the raw response, inspect the hidden field {error}.$response on this object.`; + try { + error.message += "\n " + hint; + } + catch (e) { + if (!context.logger || context.logger?.constructor?.name === "NoOpLogger") { + console.warn(hint); + } + else { + context.logger?.warn?.(hint); + } + } + if (typeof error.$responseBodyText !== "undefined") { + if (error.$response) { + error.$response.body = error.$responseBodyText; + } + } + try { + if (protocolHttp.HttpResponse.isInstance(response)) { + const { headers = {} } = response; + const headerEntries = Object.entries(headers); + error.$metadata = { + httpStatusCode: response.statusCode, + requestId: findHeader(/^x-[\w-]+-request-?id$/, headerEntries), + extendedRequestId: findHeader(/^x-[\w-]+-id-2$/, headerEntries), + cfId: findHeader(/^x-[\w-]+-cf-id$/, headerEntries), + }; + } + } + catch (e) { + } + } + throw error; + } +}; +const findHeader = (pattern, headers) => { + return (headers.find(([k]) => { + return k.match(pattern); + }) || [void 0, void 0])[1]; +}; -AWS.util.update(AWS.CognitoIdentity.prototype, { - getOpenIdToken: function getOpenIdToken(params, callback) { - return this.makeUnauthenticatedRequest('getOpenIdToken', params, callback); - }, +const serializerMiddleware = (options, serializer) => (next, context) => async (args) => { + const endpointConfig = options; + const endpoint = context.endpointV2?.url && endpointConfig.urlParser + ? async () => endpointConfig.urlParser(context.endpointV2.url) + : endpointConfig.endpoint; + if (!endpoint) { + throw new Error("No valid endpoint provider available."); + } + const request = await serializer(args.input, { ...options, endpoint }); + return next({ + ...args, + request, + }); +}; - getId: function getId(params, callback) { - return this.makeUnauthenticatedRequest('getId', params, callback); - }, +const deserializerMiddlewareOption = { + name: "deserializerMiddleware", + step: "deserialize", + tags: ["DESERIALIZER"], + override: true, +}; +const serializerMiddlewareOption = { + name: "serializerMiddleware", + step: "serialize", + tags: ["SERIALIZER"], + override: true, +}; +function getSerdePlugin(config, serializer, deserializer) { + return { + applyToStack: (commandStack) => { + commandStack.add(deserializerMiddleware(config, deserializer), deserializerMiddlewareOption); + commandStack.add(serializerMiddleware(config, serializer), serializerMiddlewareOption); + }, + }; +} - getCredentialsForIdentity: function getCredentialsForIdentity(params, callback) { - return this.makeUnauthenticatedRequest('getCredentialsForIdentity', params, callback); - } -}); +exports.deserializerMiddleware = deserializerMiddleware; +exports.deserializerMiddlewareOption = deserializerMiddlewareOption; +exports.getSerdePlugin = getSerdePlugin; +exports.serializerMiddleware = serializerMiddleware; +exports.serializerMiddlewareOption = serializerMiddlewareOption; /***/ }), -/***/ 2386: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['acmpca'] = {}; -AWS.ACMPCA = Service.defineService('acmpca', ['2017-08-22']); -Object.defineProperty(apiLoader.services['acmpca'], '2017-08-22', { - get: function get() { - var model = __webpack_require__(72); - model.paginators = __webpack_require__(1455).pagination; - model.waiters = __webpack_require__(1273).waiters; - return model; - }, - enumerable: true, - configurable: true -}); +/***/ 9208: +/***/ ((__unused_webpack_module, exports) => { -module.exports = AWS.ACMPCA; +"use strict"; -/***/ }), +const getAllAliases = (name, aliases) => { + const _aliases = []; + if (name) { + _aliases.push(name); + } + if (aliases) { + for (const alias of aliases) { + _aliases.push(alias); + } + } + return _aliases; +}; +const getMiddlewareNameWithAliases = (name, aliases) => { + return `${name || "anonymous"}${aliases && aliases.length > 0 ? ` (a.k.a. ${aliases.join(",")})` : ""}`; +}; +const constructStack = () => { + let absoluteEntries = []; + let relativeEntries = []; + let identifyOnResolve = false; + const entriesNameSet = new Set(); + const sort = (entries) => entries.sort((a, b) => stepWeights[b.step] - stepWeights[a.step] || + priorityWeights[b.priority || "normal"] - priorityWeights[a.priority || "normal"]); + const removeByName = (toRemove) => { + let isRemoved = false; + const filterCb = (entry) => { + const aliases = getAllAliases(entry.name, entry.aliases); + if (aliases.includes(toRemove)) { + isRemoved = true; + for (const alias of aliases) { + entriesNameSet.delete(alias); + } + return false; + } + return true; + }; + absoluteEntries = absoluteEntries.filter(filterCb); + relativeEntries = relativeEntries.filter(filterCb); + return isRemoved; + }; + const removeByReference = (toRemove) => { + let isRemoved = false; + const filterCb = (entry) => { + if (entry.middleware === toRemove) { + isRemoved = true; + for (const alias of getAllAliases(entry.name, entry.aliases)) { + entriesNameSet.delete(alias); + } + return false; + } + return true; + }; + absoluteEntries = absoluteEntries.filter(filterCb); + relativeEntries = relativeEntries.filter(filterCb); + return isRemoved; + }; + const cloneTo = (toStack) => { + absoluteEntries.forEach((entry) => { + toStack.add(entry.middleware, { ...entry }); + }); + relativeEntries.forEach((entry) => { + toStack.addRelativeTo(entry.middleware, { ...entry }); + }); + toStack.identifyOnResolve?.(stack.identifyOnResolve()); + return toStack; + }; + const expandRelativeMiddlewareList = (from) => { + const expandedMiddlewareList = []; + from.before.forEach((entry) => { + if (entry.before.length === 0 && entry.after.length === 0) { + expandedMiddlewareList.push(entry); + } + else { + expandedMiddlewareList.push(...expandRelativeMiddlewareList(entry)); + } + }); + expandedMiddlewareList.push(from); + from.after.reverse().forEach((entry) => { + if (entry.before.length === 0 && entry.after.length === 0) { + expandedMiddlewareList.push(entry); + } + else { + expandedMiddlewareList.push(...expandRelativeMiddlewareList(entry)); + } + }); + return expandedMiddlewareList; + }; + const getMiddlewareList = (debug = false) => { + const normalizedAbsoluteEntries = []; + const normalizedRelativeEntries = []; + const normalizedEntriesNameMap = {}; + absoluteEntries.forEach((entry) => { + const normalizedEntry = { + ...entry, + before: [], + after: [], + }; + for (const alias of getAllAliases(normalizedEntry.name, normalizedEntry.aliases)) { + normalizedEntriesNameMap[alias] = normalizedEntry; + } + normalizedAbsoluteEntries.push(normalizedEntry); + }); + relativeEntries.forEach((entry) => { + const normalizedEntry = { + ...entry, + before: [], + after: [], + }; + for (const alias of getAllAliases(normalizedEntry.name, normalizedEntry.aliases)) { + normalizedEntriesNameMap[alias] = normalizedEntry; + } + normalizedRelativeEntries.push(normalizedEntry); + }); + normalizedRelativeEntries.forEach((entry) => { + if (entry.toMiddleware) { + const toMiddleware = normalizedEntriesNameMap[entry.toMiddleware]; + if (toMiddleware === undefined) { + if (debug) { + return; + } + throw new Error(`${entry.toMiddleware} is not found when adding ` + + `${getMiddlewareNameWithAliases(entry.name, entry.aliases)} ` + + `middleware ${entry.relation} ${entry.toMiddleware}`); + } + if (entry.relation === "after") { + toMiddleware.after.push(entry); + } + if (entry.relation === "before") { + toMiddleware.before.push(entry); + } + } + }); + const mainChain = sort(normalizedAbsoluteEntries) + .map(expandRelativeMiddlewareList) + .reduce((wholeList, expandedMiddlewareList) => { + wholeList.push(...expandedMiddlewareList); + return wholeList; + }, []); + return mainChain; + }; + const stack = { + add: (middleware, options = {}) => { + const { name, override, aliases: _aliases } = options; + const entry = { + step: "initialize", + priority: "normal", + middleware, + ...options, + }; + const aliases = getAllAliases(name, _aliases); + if (aliases.length > 0) { + if (aliases.some((alias) => entriesNameSet.has(alias))) { + if (!override) + throw new Error(`Duplicate middleware name '${getMiddlewareNameWithAliases(name, _aliases)}'`); + for (const alias of aliases) { + const toOverrideIndex = absoluteEntries.findIndex((entry) => entry.name === alias || entry.aliases?.some((a) => a === alias)); + if (toOverrideIndex === -1) { + continue; + } + const toOverride = absoluteEntries[toOverrideIndex]; + if (toOverride.step !== entry.step || entry.priority !== toOverride.priority) { + throw new Error(`"${getMiddlewareNameWithAliases(toOverride.name, toOverride.aliases)}" middleware with ` + + `${toOverride.priority} priority in ${toOverride.step} step cannot ` + + `be overridden by "${getMiddlewareNameWithAliases(name, _aliases)}" middleware with ` + + `${entry.priority} priority in ${entry.step} step.`); + } + absoluteEntries.splice(toOverrideIndex, 1); + } + } + for (const alias of aliases) { + entriesNameSet.add(alias); + } + } + absoluteEntries.push(entry); + }, + addRelativeTo: (middleware, options) => { + const { name, override, aliases: _aliases } = options; + const entry = { + middleware, + ...options, + }; + const aliases = getAllAliases(name, _aliases); + if (aliases.length > 0) { + if (aliases.some((alias) => entriesNameSet.has(alias))) { + if (!override) + throw new Error(`Duplicate middleware name '${getMiddlewareNameWithAliases(name, _aliases)}'`); + for (const alias of aliases) { + const toOverrideIndex = relativeEntries.findIndex((entry) => entry.name === alias || entry.aliases?.some((a) => a === alias)); + if (toOverrideIndex === -1) { + continue; + } + const toOverride = relativeEntries[toOverrideIndex]; + if (toOverride.toMiddleware !== entry.toMiddleware || toOverride.relation !== entry.relation) { + throw new Error(`"${getMiddlewareNameWithAliases(toOverride.name, toOverride.aliases)}" middleware ` + + `${toOverride.relation} "${toOverride.toMiddleware}" middleware cannot be overridden ` + + `by "${getMiddlewareNameWithAliases(name, _aliases)}" middleware ${entry.relation} ` + + `"${entry.toMiddleware}" middleware.`); + } + relativeEntries.splice(toOverrideIndex, 1); + } + } + for (const alias of aliases) { + entriesNameSet.add(alias); + } + } + relativeEntries.push(entry); + }, + clone: () => cloneTo(constructStack()), + use: (plugin) => { + plugin.applyToStack(stack); + }, + remove: (toRemove) => { + if (typeof toRemove === "string") + return removeByName(toRemove); + else + return removeByReference(toRemove); + }, + removeByTag: (toRemove) => { + let isRemoved = false; + const filterCb = (entry) => { + const { tags, name, aliases: _aliases } = entry; + if (tags && tags.includes(toRemove)) { + const aliases = getAllAliases(name, _aliases); + for (const alias of aliases) { + entriesNameSet.delete(alias); + } + isRemoved = true; + return false; + } + return true; + }; + absoluteEntries = absoluteEntries.filter(filterCb); + relativeEntries = relativeEntries.filter(filterCb); + return isRemoved; + }, + concat: (from) => { + const cloned = cloneTo(constructStack()); + cloned.use(from); + cloned.identifyOnResolve(identifyOnResolve || cloned.identifyOnResolve() || (from.identifyOnResolve?.() ?? false)); + return cloned; + }, + applyToStack: cloneTo, + identify: () => { + return getMiddlewareList(true).map((mw) => { + const step = mw.step ?? + mw.relation + + " " + + mw.toMiddleware; + return getMiddlewareNameWithAliases(mw.name, mw.aliases) + " - " + step; + }); + }, + identifyOnResolve(toggle) { + if (typeof toggle === "boolean") + identifyOnResolve = toggle; + return identifyOnResolve; + }, + resolve: (handler, context) => { + for (const middleware of getMiddlewareList() + .map((entry) => entry.middleware) + .reverse()) { + handler = middleware(handler, context); + } + if (identifyOnResolve) { + console.log(stack.identify()); + } + return handler; + }, + }; + return stack; +}; +const stepWeights = { + initialize: 5, + serialize: 4, + build: 3, + finalizeRequest: 2, + deserialize: 1, +}; +const priorityWeights = { + high: 3, + normal: 2, + low: 1, +}; -/***/ 2394: -/***/ (function(module) { +exports.constructStack = constructStack; -module.exports = {"version":2,"waiters":{"DistributionDeployed":{"delay":60,"operation":"GetDistribution","maxAttempts":25,"description":"Wait until a distribution is deployed.","acceptors":[{"expected":"Deployed","matcher":"path","state":"success","argument":"Distribution.Status"}]},"InvalidationCompleted":{"delay":20,"operation":"GetInvalidation","maxAttempts":30,"description":"Wait until an invalidation has completed.","acceptors":[{"expected":"Completed","matcher":"path","state":"success","argument":"Invalidation.Status"}]},"StreamingDistributionDeployed":{"delay":60,"operation":"GetStreamingDistribution","maxAttempts":25,"description":"Wait until a streaming distribution is deployed.","acceptors":[{"expected":"Deployed","matcher":"path","state":"success","argument":"StreamingDistribution.Status"}]}}}; /***/ }), -/***/ 2413: -/***/ (function(module) { +/***/ 5704: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -module.exports = require("stream"); +"use strict"; -/***/ }), -/***/ 2421: -/***/ (function(module) { +var propertyProvider = __nccwpck_require__(8857); +var sharedIniFileLoader = __nccwpck_require__(4964); -module.exports = {"pagination":{"ListGatewayRoutes":{"input_token":"nextToken","limit_key":"limit","output_token":"nextToken","result_key":"gatewayRoutes"},"ListMeshes":{"input_token":"nextToken","limit_key":"limit","output_token":"nextToken","result_key":"meshes"},"ListRoutes":{"input_token":"nextToken","limit_key":"limit","output_token":"nextToken","result_key":"routes"},"ListTagsForResource":{"input_token":"nextToken","limit_key":"limit","output_token":"nextToken","result_key":"tags"},"ListVirtualGateways":{"input_token":"nextToken","limit_key":"limit","output_token":"nextToken","result_key":"virtualGateways"},"ListVirtualNodes":{"input_token":"nextToken","limit_key":"limit","output_token":"nextToken","result_key":"virtualNodes"},"ListVirtualRouters":{"input_token":"nextToken","limit_key":"limit","output_token":"nextToken","result_key":"virtualRouters"},"ListVirtualServices":{"input_token":"nextToken","limit_key":"limit","output_token":"nextToken","result_key":"virtualServices"}}}; +function getSelectorName(functionString) { + try { + const constants = new Set(Array.from(functionString.match(/([A-Z_]){3,}/g) ?? [])); + constants.delete("CONFIG"); + constants.delete("CONFIG_PREFIX_SEPARATOR"); + constants.delete("ENV"); + return [...constants].join(", "); + } + catch (e) { + return functionString; + } +} -/***/ }), +const fromEnv = (envVarSelector, options) => async () => { + try { + const config = envVarSelector(process.env, options); + if (config === undefined) { + throw new Error(); + } + return config; + } + catch (e) { + throw new propertyProvider.CredentialsProviderError(e.message || `Not found in ENV: ${getSelectorName(envVarSelector.toString())}`, { logger: options?.logger }); + } +}; -/***/ 2447: -/***/ (function(module, __unusedexports, __webpack_require__) { +const fromSharedConfigFiles = (configSelector, { preferredFile = "config", ...init } = {}) => async () => { + const profile = sharedIniFileLoader.getProfileName(init); + const { configFile, credentialsFile } = await sharedIniFileLoader.loadSharedConfigFiles(init); + const profileFromCredentials = credentialsFile[profile] || {}; + const profileFromConfig = configFile[profile] || {}; + const mergedProfile = preferredFile === "config" + ? { ...profileFromCredentials, ...profileFromConfig } + : { ...profileFromConfig, ...profileFromCredentials }; + try { + const cfgFile = preferredFile === "config" ? configFile : credentialsFile; + const configValue = configSelector(mergedProfile, cfgFile); + if (configValue === undefined) { + throw new Error(); + } + return configValue; + } + catch (e) { + throw new propertyProvider.CredentialsProviderError(e.message || `Not found in config files w/ profile [${profile}]: ${getSelectorName(configSelector.toString())}`, { logger: init.logger }); + } +}; -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +const isFunction = (func) => typeof func === "function"; +const fromStatic = (defaultValue) => isFunction(defaultValue) ? async () => await defaultValue() : propertyProvider.fromStatic(defaultValue); -apiLoader.services['qldbsession'] = {}; -AWS.QLDBSession = Service.defineService('qldbsession', ['2019-07-11']); -Object.defineProperty(apiLoader.services['qldbsession'], '2019-07-11', { - get: function get() { - var model = __webpack_require__(320); - model.paginators = __webpack_require__(8452).pagination; - return model; - }, - enumerable: true, - configurable: true -}); +const loadConfig = ({ environmentVariableSelector, configFileSelector, default: defaultValue }, configuration = {}) => { + const { signingName, logger } = configuration; + const envOptions = { signingName, logger }; + return propertyProvider.memoize(propertyProvider.chain(fromEnv(environmentVariableSelector, envOptions), fromSharedConfigFiles(configFileSelector, configuration), fromStatic(defaultValue))); +}; -module.exports = AWS.QLDBSession; +exports.loadConfig = loadConfig; /***/ }), -/***/ 2449: -/***/ (function(module) { +/***/ 1279: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -module.exports = {"pagination":{}}; +"use strict"; -/***/ }), -/***/ 2450: -/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) { +var protocolHttp = __nccwpck_require__(2356); +var querystringBuilder = __nccwpck_require__(8256); +var http = __nccwpck_require__(8611); +var https = __nccwpck_require__(5692); +var stream = __nccwpck_require__(2203); +var http2 = __nccwpck_require__(5675); -var AWS = __webpack_require__(395); +const NODEJS_TIMEOUT_ERROR_CODES = ["ECONNRESET", "EPIPE", "ETIMEDOUT"]; -AWS.util.update(AWS.RDSDataService.prototype, { - /** - * @return [Boolean] whether the error can be retried - * @api private - */ - retryableError: function retryableError(error) { - if (error.code === 'BadRequestException' && - error.message && - error.message.match(/^Communications link failure/) && - error.statusCode === 400) { - return true; - } else { - var _super = AWS.Service.prototype.retryableError; - return _super.call(this, error); +const getTransformedHeaders = (headers) => { + const transformedHeaders = {}; + for (const name of Object.keys(headers)) { + const headerValues = headers[name]; + transformedHeaders[name] = Array.isArray(headerValues) ? headerValues.join(",") : headerValues; } - } -}); - - -/***/ }), - -/***/ 2453: -/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) { - -var AWS = __webpack_require__(395); -var AcceptorStateMachine = __webpack_require__(3696); -var inherit = AWS.util.inherit; -var domain = AWS.util.domain; -var jmespath = __webpack_require__(2802); + return transformedHeaders; +}; -/** - * @api private - */ -var hardErrorStates = {success: 1, error: 1, complete: 1}; +const timing = { + setTimeout: (cb, ms) => setTimeout(cb, ms), + clearTimeout: (timeoutId) => clearTimeout(timeoutId), +}; -function isTerminalState(machine) { - return Object.prototype.hasOwnProperty.call(hardErrorStates, machine._asm.currentState); -} +const DEFER_EVENT_LISTENER_TIME$2 = 1000; +const setConnectionTimeout = (request, reject, timeoutInMs = 0) => { + if (!timeoutInMs) { + return -1; + } + const registerTimeout = (offset) => { + const timeoutId = timing.setTimeout(() => { + request.destroy(); + reject(Object.assign(new Error(`@smithy/node-http-handler - the request socket did not establish a connection with the server within the configured timeout of ${timeoutInMs} ms.`), { + name: "TimeoutError", + })); + }, timeoutInMs - offset); + const doWithSocket = (socket) => { + if (socket?.connecting) { + socket.on("connect", () => { + timing.clearTimeout(timeoutId); + }); + } + else { + timing.clearTimeout(timeoutId); + } + }; + if (request.socket) { + doWithSocket(request.socket); + } + else { + request.on("socket", doWithSocket); + } + }; + if (timeoutInMs < 2000) { + registerTimeout(0); + return 0; + } + return timing.setTimeout(registerTimeout.bind(null, DEFER_EVENT_LISTENER_TIME$2), DEFER_EVENT_LISTENER_TIME$2); +}; -var fsm = new AcceptorStateMachine(); -fsm.setupStates = function() { - var transition = function(_, done) { - var self = this; - self._haltHandlersOnError = false; +const setRequestTimeout = (req, reject, timeoutInMs = 0, throwOnRequestTimeout, logger) => { + if (timeoutInMs) { + return timing.setTimeout(() => { + let msg = `@smithy/node-http-handler - [${throwOnRequestTimeout ? "ERROR" : "WARN"}] a request has exceeded the configured ${timeoutInMs} ms requestTimeout.`; + if (throwOnRequestTimeout) { + const error = Object.assign(new Error(msg), { + name: "TimeoutError", + code: "ETIMEDOUT", + }); + req.destroy(error); + reject(error); + } + else { + msg += ` Init client requestHandler with throwOnRequestTimeout=true to turn this into an error.`; + logger?.warn?.(msg); + } + }, timeoutInMs); + } + return -1; +}; - self.emit(self._asm.currentState, function(err) { - if (err) { - if (isTerminalState(self)) { - if (domain && self.domain instanceof domain.Domain) { - err.domainEmitter = self; - err.domain = self.domain; - err.domainThrown = false; - self.domain.emit('error', err); - } else { - throw err; - } - } else { - self.response.error = err; - done(err); +const DEFER_EVENT_LISTENER_TIME$1 = 3000; +const setSocketKeepAlive = (request, { keepAlive, keepAliveMsecs }, deferTimeMs = DEFER_EVENT_LISTENER_TIME$1) => { + if (keepAlive !== true) { + return -1; + } + const registerListener = () => { + if (request.socket) { + request.socket.setKeepAlive(keepAlive, keepAliveMsecs || 0); } - } else { - done(self.response.error); - } - }); - - }; - - this.addState('validate', 'build', 'error', transition); - this.addState('build', 'afterBuild', 'restart', transition); - this.addState('afterBuild', 'sign', 'restart', transition); - this.addState('sign', 'send', 'retry', transition); - this.addState('retry', 'afterRetry', 'afterRetry', transition); - this.addState('afterRetry', 'sign', 'error', transition); - this.addState('send', 'validateResponse', 'retry', transition); - this.addState('validateResponse', 'extractData', 'extractError', transition); - this.addState('extractError', 'extractData', 'retry', transition); - this.addState('extractData', 'success', 'retry', transition); - this.addState('restart', 'build', 'error', transition); - this.addState('success', 'complete', 'complete', transition); - this.addState('error', 'complete', 'complete', transition); - this.addState('complete', null, null, transition); -}; -fsm.setupStates(); - -/** - * ## Asynchronous Requests - * - * All requests made through the SDK are asynchronous and use a - * callback interface. Each service method that kicks off a request - * returns an `AWS.Request` object that you can use to register - * callbacks. - * - * For example, the following service method returns the request - * object as "request", which can be used to register callbacks: - * - * ```javascript - * // request is an AWS.Request object - * var request = ec2.describeInstances(); - * - * // register callbacks on request to retrieve response data - * request.on('success', function(response) { - * console.log(response.data); - * }); - * ``` - * - * When a request is ready to be sent, the {send} method should - * be called: - * - * ```javascript - * request.send(); - * ``` - * - * Since registered callbacks may or may not be idempotent, requests should only - * be sent once. To perform the same operation multiple times, you will need to - * create multiple request objects, each with its own registered callbacks. - * - * ## Removing Default Listeners for Events - * - * Request objects are built with default listeners for the various events, - * depending on the service type. In some cases, you may want to remove - * some built-in listeners to customize behaviour. Doing this requires - * access to the built-in listener functions, which are exposed through - * the {AWS.EventListeners.Core} namespace. For instance, you may - * want to customize the HTTP handler used when sending a request. In this - * case, you can remove the built-in listener associated with the 'send' - * event, the {AWS.EventListeners.Core.SEND} listener and add your own. - * - * ## Multiple Callbacks and Chaining - * - * You can register multiple callbacks on any request object. The - * callbacks can be registered for different events, or all for the - * same event. In addition, you can chain callback registration, for - * example: - * - * ```javascript - * request. - * on('success', function(response) { - * console.log("Success!"); - * }). - * on('error', function(error, response) { - * console.log("Error!"); - * }). - * on('complete', function(response) { - * console.log("Always!"); - * }). - * send(); - * ``` - * - * The above example will print either "Success! Always!", or "Error! Always!", - * depending on whether the request succeeded or not. - * - * @!attribute httpRequest - * @readonly - * @!group HTTP Properties - * @return [AWS.HttpRequest] the raw HTTP request object - * containing request headers and body information - * sent by the service. - * - * @!attribute startTime - * @readonly - * @!group Operation Properties - * @return [Date] the time that the request started - * - * @!group Request Building Events - * - * @!event validate(request) - * Triggered when a request is being validated. Listeners - * should throw an error if the request should not be sent. - * @param request [Request] the request object being sent - * @see AWS.EventListeners.Core.VALIDATE_CREDENTIALS - * @see AWS.EventListeners.Core.VALIDATE_REGION - * @example Ensuring that a certain parameter is set before sending a request - * var req = s3.putObject(params); - * req.on('validate', function() { - * if (!req.params.Body.match(/^Hello\s/)) { - * throw new Error('Body must start with "Hello "'); - * } - * }); - * req.send(function(err, data) { ... }); - * - * @!event build(request) - * Triggered when the request payload is being built. Listeners - * should fill the necessary information to send the request - * over HTTP. - * @param (see AWS.Request~validate) - * @example Add a custom HTTP header to a request - * var req = s3.putObject(params); - * req.on('build', function() { - * req.httpRequest.headers['Custom-Header'] = 'value'; - * }); - * req.send(function(err, data) { ... }); - * - * @!event sign(request) - * Triggered when the request is being signed. Listeners should - * add the correct authentication headers and/or adjust the body, - * depending on the authentication mechanism being used. - * @param (see AWS.Request~validate) - * - * @!group Request Sending Events - * - * @!event send(response) - * Triggered when the request is ready to be sent. Listeners - * should call the underlying transport layer to initiate - * the sending of the request. - * @param response [Response] the response object - * @context [Request] the request object that was sent - * @see AWS.EventListeners.Core.SEND - * - * @!event retry(response) - * Triggered when a request failed and might need to be retried or redirected. - * If the response is retryable, the listener should set the - * `response.error.retryable` property to `true`, and optionally set - * `response.error.retryDelay` to the millisecond delay for the next attempt. - * In the case of a redirect, `response.error.redirect` should be set to - * `true` with `retryDelay` set to an optional delay on the next request. - * - * If a listener decides that a request should not be retried, - * it should set both `retryable` and `redirect` to false. - * - * Note that a retryable error will be retried at most - * {AWS.Config.maxRetries} times (based on the service object's config). - * Similarly, a request that is redirected will only redirect at most - * {AWS.Config.maxRedirects} times. - * - * @param (see AWS.Request~send) - * @context (see AWS.Request~send) - * @example Adding a custom retry for a 404 response - * request.on('retry', function(response) { - * // this resource is not yet available, wait 10 seconds to get it again - * if (response.httpResponse.statusCode === 404 && response.error) { - * response.error.retryable = true; // retry this error - * response.error.retryDelay = 10000; // wait 10 seconds - * } - * }); - * - * @!group Data Parsing Events - * - * @!event extractError(response) - * Triggered on all non-2xx requests so that listeners can extract - * error details from the response body. Listeners to this event - * should set the `response.error` property. - * @param (see AWS.Request~send) - * @context (see AWS.Request~send) - * - * @!event extractData(response) - * Triggered in successful requests to allow listeners to - * de-serialize the response body into `response.data`. - * @param (see AWS.Request~send) - * @context (see AWS.Request~send) - * - * @!group Completion Events - * - * @!event success(response) - * Triggered when the request completed successfully. - * `response.data` will contain the response data and - * `response.error` will be null. - * @param (see AWS.Request~send) - * @context (see AWS.Request~send) - * - * @!event error(error, response) - * Triggered when an error occurs at any point during the - * request. `response.error` will contain details about the error - * that occurred. `response.data` will be null. - * @param error [Error] the error object containing details about - * the error that occurred. - * @param (see AWS.Request~send) - * @context (see AWS.Request~send) - * - * @!event complete(response) - * Triggered whenever a request cycle completes. `response.error` - * should be checked, since the request may have failed. - * @param (see AWS.Request~send) - * @context (see AWS.Request~send) - * - * @!group HTTP Events - * - * @!event httpHeaders(statusCode, headers, response, statusMessage) - * Triggered when headers are sent by the remote server - * @param statusCode [Integer] the HTTP response code - * @param headers [map] the response headers - * @param (see AWS.Request~send) - * @param statusMessage [String] A status message corresponding to the HTTP - * response code - * @context (see AWS.Request~send) - * - * @!event httpData(chunk, response) - * Triggered when data is sent by the remote server - * @param chunk [Buffer] the buffer data containing the next data chunk - * from the server - * @param (see AWS.Request~send) - * @context (see AWS.Request~send) - * @see AWS.EventListeners.Core.HTTP_DATA - * - * @!event httpUploadProgress(progress, response) - * Triggered when the HTTP request has uploaded more data - * @param progress [map] An object containing the `loaded` and `total` bytes - * of the request. - * @param (see AWS.Request~send) - * @context (see AWS.Request~send) - * @note This event will not be emitted in Node.js 0.8.x. - * - * @!event httpDownloadProgress(progress, response) - * Triggered when the HTTP request has downloaded more data - * @param progress [map] An object containing the `loaded` and `total` bytes - * of the request. - * @param (see AWS.Request~send) - * @context (see AWS.Request~send) - * @note This event will not be emitted in Node.js 0.8.x. - * - * @!event httpError(error, response) - * Triggered when the HTTP request failed - * @param error [Error] the error object that was thrown - * @param (see AWS.Request~send) - * @context (see AWS.Request~send) - * - * @!event httpDone(response) - * Triggered when the server is finished sending data - * @param (see AWS.Request~send) - * @context (see AWS.Request~send) - * - * @see AWS.Response - */ -AWS.Request = inherit({ - - /** - * Creates a request for an operation on a given service with - * a set of input parameters. - * - * @param service [AWS.Service] the service to perform the operation on - * @param operation [String] the operation to perform on the service - * @param params [Object] parameters to send to the operation. - * See the operation's documentation for the format of the - * parameters. - */ - constructor: function Request(service, operation, params) { - var endpoint = service.endpoint; - var region = service.config.region; - var customUserAgent = service.config.customUserAgent; - - if (service.isGlobalEndpoint) { - if (service.signingRegion) { - region = service.signingRegion; - } else { - region = 'us-east-1'; - } + else { + request.on("socket", (socket) => { + socket.setKeepAlive(keepAlive, keepAliveMsecs || 0); + }); + } + }; + if (deferTimeMs === 0) { + registerListener(); + return 0; } + return timing.setTimeout(registerListener, deferTimeMs); +}; - this.domain = domain && domain.active; - this.service = service; - this.operation = operation; - this.params = params || {}; - this.httpRequest = new AWS.HttpRequest(endpoint, region); - this.httpRequest.appendToUserAgent(customUserAgent); - this.startTime = service.getSkewCorrectedDate(); - - this.response = new AWS.Response(this); - this._asm = new AcceptorStateMachine(fsm.states, 'validate'); - this._haltHandlersOnError = false; - - AWS.SequentialExecutor.call(this); - this.emit = this.emitEvent; - }, - - /** - * @!group Sending a Request - */ - - /** - * @overload send(callback = null) - * Sends the request object. - * - * @callback callback function(err, data) - * If a callback is supplied, it is called when a response is returned - * from the service. - * @context [AWS.Request] the request object being sent. - * @param err [Error] the error object returned from the request. - * Set to `null` if the request is successful. - * @param data [Object] the de-serialized data returned from - * the request. Set to `null` if a request error occurs. - * @example Sending a request with a callback - * request = s3.putObject({Bucket: 'bucket', Key: 'key'}); - * request.send(function(err, data) { console.log(err, data); }); - * @example Sending a request with no callback (using event handlers) - * request = s3.putObject({Bucket: 'bucket', Key: 'key'}); - * request.on('complete', function(response) { ... }); // register a callback - * request.send(); - */ - send: function send(callback) { - if (callback) { - // append to user agent - this.httpRequest.appendToUserAgent('callback'); - this.on('complete', function (resp) { - callback.call(resp, resp.error, resp.data); - }); +const DEFER_EVENT_LISTENER_TIME = 3000; +const setSocketTimeout = (request, reject, timeoutInMs = 0) => { + const registerTimeout = (offset) => { + const timeout = timeoutInMs - offset; + const onTimeout = () => { + request.destroy(); + reject(Object.assign(new Error(`@smithy/node-http-handler - the request socket timed out after ${timeoutInMs} ms of inactivity (configured by client requestHandler).`), { name: "TimeoutError" })); + }; + if (request.socket) { + request.socket.setTimeout(timeout, onTimeout); + request.on("close", () => request.socket?.removeListener("timeout", onTimeout)); + } + else { + request.setTimeout(timeout, onTimeout); + } + }; + if (0 < timeoutInMs && timeoutInMs < 6000) { + registerTimeout(0); + return 0; } - this.runTo(); - - return this.response; - }, - - /** - * @!method promise() - * Sends the request and returns a 'thenable' promise. - * - * Two callbacks can be provided to the `then` method on the returned promise. - * The first callback will be called if the promise is fulfilled, and the second - * callback will be called if the promise is rejected. - * @callback fulfilledCallback function(data) - * Called if the promise is fulfilled. - * @param data [Object] the de-serialized data returned from the request. - * @callback rejectedCallback function(error) - * Called if the promise is rejected. - * @param error [Error] the error object returned from the request. - * @return [Promise] A promise that represents the state of the request. - * @example Sending a request using promises. - * var request = s3.putObject({Bucket: 'bucket', Key: 'key'}); - * var result = request.promise(); - * result.then(function(data) { ... }, function(error) { ... }); - */ - - /** - * @api private - */ - build: function build(callback) { - return this.runTo('send', callback); - }, - - /** - * @api private - */ - runTo: function runTo(state, done) { - this._asm.runTo(state, done, this); - return this; - }, - - /** - * Aborts a request, emitting the error and complete events. - * - * @!macro nobrowser - * @example Aborting a request after sending - * var params = { - * Bucket: 'bucket', Key: 'key', - * Body: Buffer.alloc(1024 * 1024 * 5) // 5MB payload - * }; - * var request = s3.putObject(params); - * request.send(function (err, data) { - * if (err) console.log("Error:", err.code, err.message); - * else console.log(data); - * }); - * - * // abort request in 1 second - * setTimeout(request.abort.bind(request), 1000); - * - * // prints "Error: RequestAbortedError Request aborted by user" - * @return [AWS.Request] the same request object, for chaining. - * @since v1.4.0 - */ - abort: function abort() { - this.removeAllListeners('validateResponse'); - this.removeAllListeners('extractError'); - this.on('validateResponse', function addAbortedError(resp) { - resp.error = AWS.util.error(new Error('Request aborted by user'), { - code: 'RequestAbortedError', retryable: false - }); - }); + return timing.setTimeout(registerTimeout.bind(null, timeoutInMs === 0 ? 0 : DEFER_EVENT_LISTENER_TIME), DEFER_EVENT_LISTENER_TIME); +}; - if (this.httpRequest.stream && !this.httpRequest.stream.didCallback) { // abort HTTP stream - this.httpRequest.stream.abort(); - if (this.httpRequest._abortCallback) { - this.httpRequest._abortCallback(); - } else { - this.removeAllListeners('send'); // haven't sent yet, so let's not - } +const MIN_WAIT_TIME = 6_000; +async function writeRequestBody(httpRequest, request, maxContinueTimeoutMs = MIN_WAIT_TIME, externalAgent = false) { + const headers = request.headers ?? {}; + const expect = headers.Expect || headers.expect; + let timeoutId = -1; + let sendBody = true; + if (!externalAgent && expect === "100-continue") { + sendBody = await Promise.race([ + new Promise((resolve) => { + timeoutId = Number(timing.setTimeout(() => resolve(true), Math.max(MIN_WAIT_TIME, maxContinueTimeoutMs))); + }), + new Promise((resolve) => { + httpRequest.on("continue", () => { + timing.clearTimeout(timeoutId); + resolve(true); + }); + httpRequest.on("response", () => { + timing.clearTimeout(timeoutId); + resolve(false); + }); + httpRequest.on("error", () => { + timing.clearTimeout(timeoutId); + resolve(false); + }); + }), + ]); + } + if (sendBody) { + writeBody(httpRequest, request.body); } - - return this; - }, - - /** - * Iterates over each page of results given a pageable request, calling - * the provided callback with each page of data. After all pages have been - * retrieved, the callback is called with `null` data. - * - * @note This operation can generate multiple requests to a service. - * @example Iterating over multiple pages of objects in an S3 bucket - * var pages = 1; - * s3.listObjects().eachPage(function(err, data) { - * if (err) return; - * console.log("Page", pages++); - * console.log(data); - * }); - * @example Iterating over multiple pages with an asynchronous callback - * s3.listObjects(params).eachPage(function(err, data, done) { - * doSomethingAsyncAndOrExpensive(function() { - * // The next page of results isn't fetched until done is called - * done(); - * }); - * }); - * @callback callback function(err, data, [doneCallback]) - * Called with each page of resulting data from the request. If the - * optional `doneCallback` is provided in the function, it must be called - * when the callback is complete. - * - * @param err [Error] an error object, if an error occurred. - * @param data [Object] a single page of response data. If there is no - * more data, this object will be `null`. - * @param doneCallback [Function] an optional done callback. If this - * argument is defined in the function declaration, it should be called - * when the next page is ready to be retrieved. This is useful for - * controlling serial pagination across asynchronous operations. - * @return [Boolean] if the callback returns `false`, pagination will - * stop. - * - * @see AWS.Request.eachItem - * @see AWS.Response.nextPage - * @since v1.4.0 - */ - eachPage: function eachPage(callback) { - // Make all callbacks async-ish - callback = AWS.util.fn.makeAsync(callback, 3); - - function wrappedCallback(response) { - callback.call(response, response.error, response.data, function (result) { - if (result === false) return; - - if (response.hasNextPage()) { - response.nextPage().on('complete', wrappedCallback).send(); - } else { - callback.call(response, null, null, AWS.util.fn.noop); - } - }); +} +function writeBody(httpRequest, body) { + if (body instanceof stream.Readable) { + body.pipe(httpRequest); + return; } - - this.on('complete', wrappedCallback).send(); - }, - - /** - * Enumerates over individual items of a request, paging the responses if - * necessary. - * - * @api experimental - * @since v1.4.0 - */ - eachItem: function eachItem(callback) { - var self = this; - function wrappedCallback(err, data) { - if (err) return callback(err, null); - if (data === null) return callback(null, null); - - var config = self.service.paginationConfig(self.operation); - var resultKey = config.resultKey; - if (Array.isArray(resultKey)) resultKey = resultKey[0]; - var items = jmespath.search(data, resultKey); - var continueIteration = true; - AWS.util.arrayEach(items, function(item) { - continueIteration = callback(null, item); - if (continueIteration === false) { - return AWS.util.abort; + if (body) { + if (Buffer.isBuffer(body) || typeof body === "string") { + httpRequest.end(body); + return; } - }); - return continueIteration; + const uint8 = body; + if (typeof uint8 === "object" && + uint8.buffer && + typeof uint8.byteOffset === "number" && + typeof uint8.byteLength === "number") { + httpRequest.end(Buffer.from(uint8.buffer, uint8.byteOffset, uint8.byteLength)); + return; + } + httpRequest.end(Buffer.from(body)); + return; } + httpRequest.end(); +} - this.eachPage(wrappedCallback); - }, - - /** - * @return [Boolean] whether the operation can return multiple pages of - * response data. - * @see AWS.Response.eachPage - * @since v1.4.0 - */ - isPageable: function isPageable() { - return this.service.paginationConfig(this.operation) ? true : false; - }, - - /** - * Sends the request and converts the request object into a readable stream - * that can be read from or piped into a writable stream. - * - * @note The data read from a readable stream contains only - * the raw HTTP body contents. - * @example Manually reading from a stream - * request.createReadStream().on('data', function(data) { - * console.log("Got data:", data.toString()); - * }); - * @example Piping a request body into a file - * var out = fs.createWriteStream('/path/to/outfile.jpg'); - * s3.service.getObject(params).createReadStream().pipe(out); - * @return [Stream] the readable stream object that can be piped - * or read from (by registering 'data' event listeners). - * @!macro nobrowser - */ - createReadStream: function createReadStream() { - var streams = AWS.util.stream; - var req = this; - var stream = null; - - if (AWS.HttpClient.streamsApiVersion === 2) { - stream = new streams.PassThrough(); - process.nextTick(function() { req.send(); }); - } else { - stream = new streams.Stream(); - stream.readable = true; - - stream.sent = false; - stream.on('newListener', function(event) { - if (!stream.sent && event === 'data') { - stream.sent = true; - process.nextTick(function() { req.send(); }); +const DEFAULT_REQUEST_TIMEOUT = 0; +class NodeHttpHandler { + config; + configProvider; + socketWarningTimestamp = 0; + externalAgent = false; + metadata = { handlerProtocol: "http/1.1" }; + static create(instanceOrOptions) { + if (typeof instanceOrOptions?.handle === "function") { + return instanceOrOptions; } - }); + return new NodeHttpHandler(instanceOrOptions); } - - this.on('error', function(err) { - stream.emit('error', err); - }); - - this.on('httpHeaders', function streamHeaders(statusCode, headers, resp) { - if (statusCode < 300) { - req.removeListener('httpData', AWS.EventListeners.Core.HTTP_DATA); - req.removeListener('httpError', AWS.EventListeners.Core.HTTP_ERROR); - req.on('httpError', function streamHttpError(error) { - resp.error = error; - resp.error.retryable = false; + static checkSocketUsage(agent, socketWarningTimestamp, logger = console) { + const { sockets, requests, maxSockets } = agent; + if (typeof maxSockets !== "number" || maxSockets === Infinity) { + return socketWarningTimestamp; + } + const interval = 15_000; + if (Date.now() - interval < socketWarningTimestamp) { + return socketWarningTimestamp; + } + if (sockets && requests) { + for (const origin in sockets) { + const socketsInUse = sockets[origin]?.length ?? 0; + const requestsEnqueued = requests[origin]?.length ?? 0; + if (socketsInUse >= maxSockets && requestsEnqueued >= 2 * maxSockets) { + logger?.warn?.(`@smithy/node-http-handler:WARN - socket usage at capacity=${socketsInUse} and ${requestsEnqueued} additional requests are enqueued. +See https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-configuring-maxsockets.html +or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler config.`); + return Date.now(); + } + } + } + return socketWarningTimestamp; + } + constructor(options) { + this.configProvider = new Promise((resolve, reject) => { + if (typeof options === "function") { + options() + .then((_options) => { + resolve(this.resolveDefaultConfig(_options)); + }) + .catch(reject); + } + else { + resolve(this.resolveDefaultConfig(options)); + } }); - - var shouldCheckContentLength = false; - var expectedLen; - if (req.httpRequest.method !== 'HEAD') { - expectedLen = parseInt(headers['content-length'], 10); - } - if (expectedLen !== undefined && !isNaN(expectedLen) && expectedLen >= 0) { - shouldCheckContentLength = true; - var receivedLen = 0; - } - - var checkContentLengthAndEmit = function checkContentLengthAndEmit() { - if (shouldCheckContentLength && receivedLen !== expectedLen) { - stream.emit('error', AWS.util.error( - new Error('Stream content length mismatch. Received ' + - receivedLen + ' of ' + expectedLen + ' bytes.'), - { code: 'StreamContentLengthMismatch' } - )); - } else if (AWS.HttpClient.streamsApiVersion === 2) { - stream.end(); - } else { - stream.emit('end'); - } + } + resolveDefaultConfig(options) { + const { requestTimeout, connectionTimeout, socketTimeout, socketAcquisitionWarningTimeout, httpAgent, httpsAgent, throwOnRequestTimeout, } = options || {}; + const keepAlive = true; + const maxSockets = 50; + return { + connectionTimeout, + requestTimeout, + socketTimeout, + socketAcquisitionWarningTimeout, + throwOnRequestTimeout, + httpAgent: (() => { + if (httpAgent instanceof http.Agent || typeof httpAgent?.destroy === "function") { + this.externalAgent = true; + return httpAgent; + } + return new http.Agent({ keepAlive, maxSockets, ...httpAgent }); + })(), + httpsAgent: (() => { + if (httpsAgent instanceof https.Agent || typeof httpsAgent?.destroy === "function") { + this.externalAgent = true; + return httpsAgent; + } + return new https.Agent({ keepAlive, maxSockets, ...httpsAgent }); + })(), + logger: console, }; - - var httpStream = resp.httpResponse.createUnbufferedStream(); - - if (AWS.HttpClient.streamsApiVersion === 2) { - if (shouldCheckContentLength) { - var lengthAccumulator = new streams.PassThrough(); - lengthAccumulator._write = function(chunk) { - if (chunk && chunk.length) { - receivedLen += chunk.length; - } - return streams.PassThrough.prototype._write.apply(this, arguments); + } + destroy() { + this.config?.httpAgent?.destroy(); + this.config?.httpsAgent?.destroy(); + } + async handle(request, { abortSignal, requestTimeout } = {}) { + if (!this.config) { + this.config = await this.configProvider; + } + return new Promise((_resolve, _reject) => { + const config = this.config; + let writeRequestBodyPromise = undefined; + const timeouts = []; + const resolve = async (arg) => { + await writeRequestBodyPromise; + timeouts.forEach(timing.clearTimeout); + _resolve(arg); }; - - lengthAccumulator.on('end', checkContentLengthAndEmit); - stream.on('error', function(err) { - shouldCheckContentLength = false; - httpStream.unpipe(lengthAccumulator); - lengthAccumulator.emit('end'); - lengthAccumulator.end(); + const reject = async (arg) => { + await writeRequestBodyPromise; + timeouts.forEach(timing.clearTimeout); + _reject(arg); + }; + if (abortSignal?.aborted) { + const abortError = new Error("Request aborted"); + abortError.name = "AbortError"; + reject(abortError); + return; + } + const isSSL = request.protocol === "https:"; + const headers = request.headers ?? {}; + const expectContinue = (headers.Expect ?? headers.expect) === "100-continue"; + let agent = isSSL ? config.httpsAgent : config.httpAgent; + if (expectContinue && !this.externalAgent) { + agent = new (isSSL ? https.Agent : http.Agent)({ + keepAlive: false, + maxSockets: Infinity, + }); + } + timeouts.push(timing.setTimeout(() => { + this.socketWarningTimestamp = NodeHttpHandler.checkSocketUsage(agent, this.socketWarningTimestamp, config.logger); + }, config.socketAcquisitionWarningTimeout ?? (config.requestTimeout ?? 2000) + (config.connectionTimeout ?? 1000))); + const queryString = querystringBuilder.buildQueryString(request.query || {}); + let auth = undefined; + if (request.username != null || request.password != null) { + const username = request.username ?? ""; + const password = request.password ?? ""; + auth = `${username}:${password}`; + } + let path = request.path; + if (queryString) { + path += `?${queryString}`; + } + if (request.fragment) { + path += `#${request.fragment}`; + } + let hostname = request.hostname ?? ""; + if (hostname[0] === "[" && hostname.endsWith("]")) { + hostname = request.hostname.slice(1, -1); + } + else { + hostname = request.hostname; + } + const nodeHttpsOptions = { + headers: request.headers, + host: hostname, + method: request.method, + path, + port: request.port, + agent, + auth, + }; + const requestFunc = isSSL ? https.request : http.request; + const req = requestFunc(nodeHttpsOptions, (res) => { + const httpResponse = new protocolHttp.HttpResponse({ + statusCode: res.statusCode || -1, + reason: res.statusMessage, + headers: getTransformedHeaders(res.headers), + body: res, + }); + resolve({ response: httpResponse }); }); - httpStream.pipe(lengthAccumulator).pipe(stream, { end: false }); - } else { - httpStream.pipe(stream); - } - } else { - - if (shouldCheckContentLength) { - httpStream.on('data', function(arg) { - if (arg && arg.length) { - receivedLen += arg.length; - } + req.on("error", (err) => { + if (NODEJS_TIMEOUT_ERROR_CODES.includes(err.code)) { + reject(Object.assign(err, { name: "TimeoutError" })); + } + else { + reject(err); + } + }); + if (abortSignal) { + const onAbort = () => { + req.destroy(); + const abortError = new Error("Request aborted"); + abortError.name = "AbortError"; + reject(abortError); + }; + if (typeof abortSignal.addEventListener === "function") { + const signal = abortSignal; + signal.addEventListener("abort", onAbort, { once: true }); + req.once("close", () => signal.removeEventListener("abort", onAbort)); + } + else { + abortSignal.onabort = onAbort; + } + } + const effectiveRequestTimeout = requestTimeout ?? config.requestTimeout; + timeouts.push(setConnectionTimeout(req, reject, config.connectionTimeout)); + timeouts.push(setRequestTimeout(req, reject, effectiveRequestTimeout, config.throwOnRequestTimeout, config.logger ?? console)); + timeouts.push(setSocketTimeout(req, reject, config.socketTimeout)); + const httpAgent = nodeHttpsOptions.agent; + if (typeof httpAgent === "object" && "keepAlive" in httpAgent) { + timeouts.push(setSocketKeepAlive(req, { + keepAlive: httpAgent.keepAlive, + keepAliveMsecs: httpAgent.keepAliveMsecs, + })); + } + writeRequestBodyPromise = writeRequestBody(req, request, effectiveRequestTimeout, this.externalAgent).catch((e) => { + timeouts.forEach(timing.clearTimeout); + return _reject(e); }); - } - - httpStream.on('data', function(arg) { - stream.emit('data', arg); - }); - httpStream.on('end', checkContentLengthAndEmit); - } - - httpStream.on('error', function(err) { - shouldCheckContentLength = false; - stream.emit('error', err); }); - } - }); - - return stream; - }, - - /** - * @param [Array,Response] args This should be the response object, - * or an array of args to send to the event. - * @api private - */ - emitEvent: function emit(eventName, args, done) { - if (typeof args === 'function') { done = args; args = null; } - if (!done) done = function() { }; - if (!args) args = this.eventParameters(eventName, this.response); - - var origEmit = AWS.SequentialExecutor.prototype.emit; - origEmit.call(this, eventName, args, function (err) { - if (err) this.response.error = err; - done.call(this, err); - }); - }, - - /** - * @api private - */ - eventParameters: function eventParameters(eventName) { - switch (eventName) { - case 'restart': - case 'validate': - case 'sign': - case 'build': - case 'afterValidate': - case 'afterBuild': - return [this]; - case 'error': - return [this.response.error, this.response]; - default: - return [this.response]; } - }, - - /** - * @api private - */ - presign: function presign(expires, callback) { - if (!callback && typeof expires === 'function') { - callback = expires; - expires = null; + updateHttpClientConfig(key, value) { + this.config = undefined; + this.configProvider = this.configProvider.then((config) => { + return { + ...config, + [key]: value, + }; + }); } - return new AWS.Signers.Presign().sign(this.toGet(), expires, callback); - }, - - /** - * @api private - */ - isPresigned: function isPresigned() { - return Object.prototype.hasOwnProperty.call(this.httpRequest.headers, 'presigned-expires'); - }, - - /** - * @api private - */ - toUnauthenticated: function toUnauthenticated() { - this._unAuthenticated = true; - this.removeListener('validate', AWS.EventListeners.Core.VALIDATE_CREDENTIALS); - this.removeListener('sign', AWS.EventListeners.Core.SIGN); - return this; - }, - - /** - * @api private - */ - toGet: function toGet() { - if (this.service.api.protocol === 'query' || - this.service.api.protocol === 'ec2') { - this.removeListener('build', this.buildAsGet); - this.addListener('build', this.buildAsGet); + httpHandlerConfigs() { + return this.config ?? {}; } - return this; - }, - - /** - * @api private - */ - buildAsGet: function buildAsGet(request) { - request.httpRequest.method = 'GET'; - request.httpRequest.path = request.service.endpoint.path + - '?' + request.httpRequest.body; - request.httpRequest.body = ''; - - // don't need these headers on a GET request - delete request.httpRequest.headers['Content-Length']; - delete request.httpRequest.headers['Content-Type']; - }, - - /** - * @api private - */ - haltHandlersOnError: function haltHandlersOnError() { - this._haltHandlersOnError = true; - } -}); +} -/** - * @api private - */ -AWS.Request.addPromisesToClass = function addPromisesToClass(PromiseDependency) { - this.prototype.promise = function promise() { - var self = this; - // append to user agent - this.httpRequest.appendToUserAgent('promise'); - return new PromiseDependency(function(resolve, reject) { - self.on('complete', function(resp) { - if (resp.error) { - reject(resp.error); - } else { - // define $response property so that it is not enumberable - // this prevents circular reference errors when stringifying the JSON object - resolve(Object.defineProperty( - resp.data || {}, - '$response', - {value: resp} - )); +class NodeHttp2ConnectionPool { + sessions = []; + constructor(sessions) { + this.sessions = sessions ?? []; + } + poll() { + if (this.sessions.length > 0) { + return this.sessions.shift(); } - }); - self.runTo(); - }); - }; -}; + } + offerLast(session) { + this.sessions.push(session); + } + contains(session) { + return this.sessions.includes(session); + } + remove(session) { + this.sessions = this.sessions.filter((s) => s !== session); + } + [Symbol.iterator]() { + return this.sessions[Symbol.iterator](); + } + destroy(connection) { + for (const session of this.sessions) { + if (session === connection) { + if (!session.destroyed) { + session.destroy(); + } + } + } + } +} -/** - * @api private - */ -AWS.Request.deletePromisesFromClass = function deletePromisesFromClass() { - delete this.prototype.promise; -}; +class NodeHttp2ConnectionManager { + constructor(config) { + this.config = config; + if (this.config.maxConcurrency && this.config.maxConcurrency <= 0) { + throw new RangeError("maxConcurrency must be greater than zero."); + } + } + config; + sessionCache = new Map(); + lease(requestContext, connectionConfiguration) { + const url = this.getUrlString(requestContext); + const existingPool = this.sessionCache.get(url); + if (existingPool) { + const existingSession = existingPool.poll(); + if (existingSession && !this.config.disableConcurrency) { + return existingSession; + } + } + const session = http2.connect(url); + if (this.config.maxConcurrency) { + session.settings({ maxConcurrentStreams: this.config.maxConcurrency }, (err) => { + if (err) { + throw new Error("Fail to set maxConcurrentStreams to " + + this.config.maxConcurrency + + "when creating new session for " + + requestContext.destination.toString()); + } + }); + } + session.unref(); + const destroySessionCb = () => { + session.destroy(); + this.deleteSession(url, session); + }; + session.on("goaway", destroySessionCb); + session.on("error", destroySessionCb); + session.on("frameError", destroySessionCb); + session.on("close", () => this.deleteSession(url, session)); + if (connectionConfiguration.requestTimeout) { + session.setTimeout(connectionConfiguration.requestTimeout, destroySessionCb); + } + const connectionPool = this.sessionCache.get(url) || new NodeHttp2ConnectionPool(); + connectionPool.offerLast(session); + this.sessionCache.set(url, connectionPool); + return session; + } + deleteSession(authority, session) { + const existingConnectionPool = this.sessionCache.get(authority); + if (!existingConnectionPool) { + return; + } + if (!existingConnectionPool.contains(session)) { + return; + } + existingConnectionPool.remove(session); + this.sessionCache.set(authority, existingConnectionPool); + } + release(requestContext, session) { + const cacheKey = this.getUrlString(requestContext); + this.sessionCache.get(cacheKey)?.offerLast(session); + } + destroy() { + for (const [key, connectionPool] of this.sessionCache) { + for (const session of connectionPool) { + if (!session.destroyed) { + session.destroy(); + } + connectionPool.remove(session); + } + this.sessionCache.delete(key); + } + } + setMaxConcurrentStreams(maxConcurrentStreams) { + if (maxConcurrentStreams && maxConcurrentStreams <= 0) { + throw new RangeError("maxConcurrentStreams must be greater than zero."); + } + this.config.maxConcurrency = maxConcurrentStreams; + } + setDisableConcurrentStreams(disableConcurrentStreams) { + this.config.disableConcurrency = disableConcurrentStreams; + } + getUrlString(request) { + return request.destination.toString(); + } +} + +class NodeHttp2Handler { + config; + configProvider; + metadata = { handlerProtocol: "h2" }; + connectionManager = new NodeHttp2ConnectionManager({}); + static create(instanceOrOptions) { + if (typeof instanceOrOptions?.handle === "function") { + return instanceOrOptions; + } + return new NodeHttp2Handler(instanceOrOptions); + } + constructor(options) { + this.configProvider = new Promise((resolve, reject) => { + if (typeof options === "function") { + options() + .then((opts) => { + resolve(opts || {}); + }) + .catch(reject); + } + else { + resolve(options || {}); + } + }); + } + destroy() { + this.connectionManager.destroy(); + } + async handle(request, { abortSignal, requestTimeout } = {}) { + if (!this.config) { + this.config = await this.configProvider; + this.connectionManager.setDisableConcurrentStreams(this.config.disableConcurrentStreams || false); + if (this.config.maxConcurrentStreams) { + this.connectionManager.setMaxConcurrentStreams(this.config.maxConcurrentStreams); + } + } + const { requestTimeout: configRequestTimeout, disableConcurrentStreams } = this.config; + const effectiveRequestTimeout = requestTimeout ?? configRequestTimeout; + return new Promise((_resolve, _reject) => { + let fulfilled = false; + let writeRequestBodyPromise = undefined; + const resolve = async (arg) => { + await writeRequestBodyPromise; + _resolve(arg); + }; + const reject = async (arg) => { + await writeRequestBodyPromise; + _reject(arg); + }; + if (abortSignal?.aborted) { + fulfilled = true; + const abortError = new Error("Request aborted"); + abortError.name = "AbortError"; + reject(abortError); + return; + } + const { hostname, method, port, protocol, query } = request; + let auth = ""; + if (request.username != null || request.password != null) { + const username = request.username ?? ""; + const password = request.password ?? ""; + auth = `${username}:${password}@`; + } + const authority = `${protocol}//${auth}${hostname}${port ? `:${port}` : ""}`; + const requestContext = { destination: new URL(authority) }; + const session = this.connectionManager.lease(requestContext, { + requestTimeout: this.config?.sessionTimeout, + disableConcurrentStreams: disableConcurrentStreams || false, + }); + const rejectWithDestroy = (err) => { + if (disableConcurrentStreams) { + this.destroySession(session); + } + fulfilled = true; + reject(err); + }; + const queryString = querystringBuilder.buildQueryString(query || {}); + let path = request.path; + if (queryString) { + path += `?${queryString}`; + } + if (request.fragment) { + path += `#${request.fragment}`; + } + const req = session.request({ + ...request.headers, + [http2.constants.HTTP2_HEADER_PATH]: path, + [http2.constants.HTTP2_HEADER_METHOD]: method, + }); + session.ref(); + req.on("response", (headers) => { + const httpResponse = new protocolHttp.HttpResponse({ + statusCode: headers[":status"] || -1, + headers: getTransformedHeaders(headers), + body: req, + }); + fulfilled = true; + resolve({ response: httpResponse }); + if (disableConcurrentStreams) { + session.close(); + this.connectionManager.deleteSession(authority, session); + } + }); + if (effectiveRequestTimeout) { + req.setTimeout(effectiveRequestTimeout, () => { + req.close(); + const timeoutError = new Error(`Stream timed out because of no activity for ${effectiveRequestTimeout} ms`); + timeoutError.name = "TimeoutError"; + rejectWithDestroy(timeoutError); + }); + } + if (abortSignal) { + const onAbort = () => { + req.close(); + const abortError = new Error("Request aborted"); + abortError.name = "AbortError"; + rejectWithDestroy(abortError); + }; + if (typeof abortSignal.addEventListener === "function") { + const signal = abortSignal; + signal.addEventListener("abort", onAbort, { once: true }); + req.once("close", () => signal.removeEventListener("abort", onAbort)); + } + else { + abortSignal.onabort = onAbort; + } + } + req.on("frameError", (type, code, id) => { + rejectWithDestroy(new Error(`Frame type id ${type} in stream id ${id} has failed with code ${code}.`)); + }); + req.on("error", rejectWithDestroy); + req.on("aborted", () => { + rejectWithDestroy(new Error(`HTTP/2 stream is abnormally aborted in mid-communication with result code ${req.rstCode}.`)); + }); + req.on("close", () => { + session.unref(); + if (disableConcurrentStreams) { + session.destroy(); + } + if (!fulfilled) { + rejectWithDestroy(new Error("Unexpected error: http2 request did not get a response")); + } + }); + writeRequestBodyPromise = writeRequestBody(req, request, effectiveRequestTimeout); + }); + } + updateHttpClientConfig(key, value) { + this.config = undefined; + this.configProvider = this.configProvider.then((config) => { + return { + ...config, + [key]: value, + }; + }); + } + httpHandlerConfigs() { + return this.config ?? {}; + } + destroySession(session) { + if (!session.destroyed) { + session.destroy(); + } + } +} + +class Collector extends stream.Writable { + bufferedBytes = []; + _write(chunk, encoding, callback) { + this.bufferedBytes.push(chunk); + callback(); + } +} -AWS.util.addPromises(AWS.Request); +const streamCollector = (stream) => { + if (isReadableStreamInstance(stream)) { + return collectReadableStream(stream); + } + return new Promise((resolve, reject) => { + const collector = new Collector(); + stream.pipe(collector); + stream.on("error", (err) => { + collector.end(); + reject(err); + }); + collector.on("error", reject); + collector.on("finish", function () { + const bytes = new Uint8Array(Buffer.concat(this.bufferedBytes)); + resolve(bytes); + }); + }); +}; +const isReadableStreamInstance = (stream) => typeof ReadableStream === "function" && stream instanceof ReadableStream; +async function collectReadableStream(stream) { + const chunks = []; + const reader = stream.getReader(); + let isDone = false; + let length = 0; + while (!isDone) { + const { done, value } = await reader.read(); + if (value) { + chunks.push(value); + length += value.length; + } + isDone = done; + } + const collected = new Uint8Array(length); + let offset = 0; + for (const chunk of chunks) { + collected.set(chunk, offset); + offset += chunk.length; + } + return collected; +} -AWS.util.mixin(AWS.Request, AWS.SequentialExecutor); +exports.DEFAULT_REQUEST_TIMEOUT = DEFAULT_REQUEST_TIMEOUT; +exports.NodeHttp2Handler = NodeHttp2Handler; +exports.NodeHttpHandler = NodeHttpHandler; +exports.streamCollector = streamCollector; /***/ }), -/***/ 2457: -/***/ (function(module, __unusedexports, __webpack_require__) { +/***/ 8857: +/***/ ((__unused_webpack_module, exports) => { "use strict"; -/*eslint-disable max-len,no-use-before-define*/ +class ProviderError extends Error { + name = "ProviderError"; + tryNextLink; + constructor(message, options = true) { + let logger; + let tryNextLink = true; + if (typeof options === "boolean") { + logger = undefined; + tryNextLink = options; + } + else if (options != null && typeof options === "object") { + logger = options.logger; + tryNextLink = options.tryNextLink ?? true; + } + super(message); + this.tryNextLink = tryNextLink; + Object.setPrototypeOf(this, ProviderError.prototype); + logger?.debug?.(`@smithy/property-provider ${tryNextLink ? "->" : "(!)"} ${message}`); + } + static from(error, options = true) { + return Object.assign(new this(error.message, options), error); + } +} -var common = __webpack_require__(2740); -var YAMLException = __webpack_require__(556); -var Mark = __webpack_require__(93); -var DEFAULT_SAFE_SCHEMA = __webpack_require__(6830); -var DEFAULT_FULL_SCHEMA = __webpack_require__(5910); +class CredentialsProviderError extends ProviderError { + name = "CredentialsProviderError"; + constructor(message, options = true) { + super(message, options); + Object.setPrototypeOf(this, CredentialsProviderError.prototype); + } +} +class TokenProviderError extends ProviderError { + name = "TokenProviderError"; + constructor(message, options = true) { + super(message, options); + Object.setPrototypeOf(this, TokenProviderError.prototype); + } +} -var _hasOwnProperty = Object.prototype.hasOwnProperty; +const chain = (...providers) => async () => { + if (providers.length === 0) { + throw new ProviderError("No providers in chain"); + } + let lastProviderError; + for (const provider of providers) { + try { + const credentials = await provider(); + return credentials; + } + catch (err) { + lastProviderError = err; + if (err?.tryNextLink) { + continue; + } + throw err; + } + } + throw lastProviderError; +}; +const fromStatic = (staticValue) => () => Promise.resolve(staticValue); -var CONTEXT_FLOW_IN = 1; -var CONTEXT_FLOW_OUT = 2; -var CONTEXT_BLOCK_IN = 3; -var CONTEXT_BLOCK_OUT = 4; +const memoize = (provider, isExpired, requiresRefresh) => { + let resolved; + let pending; + let hasResult; + let isConstant = false; + const coalesceProvider = async () => { + if (!pending) { + pending = provider(); + } + try { + resolved = await pending; + hasResult = true; + isConstant = false; + } + finally { + pending = undefined; + } + return resolved; + }; + if (isExpired === undefined) { + return async (options) => { + if (!hasResult || options?.forceRefresh) { + resolved = await coalesceProvider(); + } + return resolved; + }; + } + return async (options) => { + if (!hasResult || options?.forceRefresh) { + resolved = await coalesceProvider(); + } + if (isConstant) { + return resolved; + } + if (requiresRefresh && !requiresRefresh(resolved)) { + isConstant = true; + return resolved; + } + if (isExpired(resolved)) { + await coalesceProvider(); + return resolved; + } + return resolved; + }; +}; +exports.CredentialsProviderError = CredentialsProviderError; +exports.ProviderError = ProviderError; +exports.TokenProviderError = TokenProviderError; +exports.chain = chain; +exports.fromStatic = fromStatic; +exports.memoize = memoize; -var CHOMPING_CLIP = 1; -var CHOMPING_STRIP = 2; -var CHOMPING_KEEP = 3; +/***/ }), -var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/; -var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/; -var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/; -var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i; -var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i; +/***/ 2356: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { +"use strict"; -function _class(obj) { return Object.prototype.toString.call(obj); } -function is_EOL(c) { - return (c === 0x0A/* LF */) || (c === 0x0D/* CR */); +var types = __nccwpck_require__(690); + +const getHttpHandlerExtensionConfiguration = (runtimeConfig) => { + return { + setHttpHandler(handler) { + runtimeConfig.httpHandler = handler; + }, + httpHandler() { + return runtimeConfig.httpHandler; + }, + updateHttpClientConfig(key, value) { + runtimeConfig.httpHandler?.updateHttpClientConfig(key, value); + }, + httpHandlerConfigs() { + return runtimeConfig.httpHandler.httpHandlerConfigs(); + }, + }; +}; +const resolveHttpHandlerRuntimeConfig = (httpHandlerExtensionConfiguration) => { + return { + httpHandler: httpHandlerExtensionConfiguration.httpHandler(), + }; +}; + +class Field { + name; + kind; + values; + constructor({ name, kind = types.FieldPosition.HEADER, values = [] }) { + this.name = name; + this.kind = kind; + this.values = values; + } + add(value) { + this.values.push(value); + } + set(values) { + this.values = values; + } + remove(value) { + this.values = this.values.filter((v) => v !== value); + } + toString() { + return this.values.map((v) => (v.includes(",") || v.includes(" ") ? `"${v}"` : v)).join(", "); + } + get() { + return this.values; + } } -function is_WHITE_SPACE(c) { - return (c === 0x09/* Tab */) || (c === 0x20/* Space */); +class Fields { + entries = {}; + encoding; + constructor({ fields = [], encoding = "utf-8" }) { + fields.forEach(this.setField.bind(this)); + this.encoding = encoding; + } + setField(field) { + this.entries[field.name.toLowerCase()] = field; + } + getField(name) { + return this.entries[name.toLowerCase()]; + } + removeField(name) { + delete this.entries[name.toLowerCase()]; + } + getByType(kind) { + return Object.values(this.entries).filter((field) => field.kind === kind); + } } -function is_WS_OR_EOL(c) { - return (c === 0x09/* Tab */) || - (c === 0x20/* Space */) || - (c === 0x0A/* LF */) || - (c === 0x0D/* CR */); +class HttpRequest { + method; + protocol; + hostname; + port; + path; + query; + headers; + username; + password; + fragment; + body; + constructor(options) { + this.method = options.method || "GET"; + this.hostname = options.hostname || "localhost"; + this.port = options.port; + this.query = options.query || {}; + this.headers = options.headers || {}; + this.body = options.body; + this.protocol = options.protocol + ? options.protocol.slice(-1) !== ":" + ? `${options.protocol}:` + : options.protocol + : "https:"; + this.path = options.path ? (options.path.charAt(0) !== "/" ? `/${options.path}` : options.path) : "/"; + this.username = options.username; + this.password = options.password; + this.fragment = options.fragment; + } + static clone(request) { + const cloned = new HttpRequest({ + ...request, + headers: { ...request.headers }, + }); + if (cloned.query) { + cloned.query = cloneQuery(cloned.query); + } + return cloned; + } + static isInstance(request) { + if (!request) { + return false; + } + const req = request; + return ("method" in req && + "protocol" in req && + "hostname" in req && + "path" in req && + typeof req["query"] === "object" && + typeof req["headers"] === "object"); + } + clone() { + return HttpRequest.clone(this); + } +} +function cloneQuery(query) { + return Object.keys(query).reduce((carry, paramName) => { + const param = query[paramName]; + return { + ...carry, + [paramName]: Array.isArray(param) ? [...param] : param, + }; + }, {}); } -function is_FLOW_INDICATOR(c) { - return c === 0x2C/* , */ || - c === 0x5B/* [ */ || - c === 0x5D/* ] */ || - c === 0x7B/* { */ || - c === 0x7D/* } */; +class HttpResponse { + statusCode; + reason; + headers; + body; + constructor(options) { + this.statusCode = options.statusCode; + this.reason = options.reason; + this.headers = options.headers || {}; + this.body = options.body; + } + static isInstance(response) { + if (!response) + return false; + const resp = response; + return typeof resp.statusCode === "number" && typeof resp.headers === "object"; + } } -function fromHexCode(c) { - var lc; +function isValidHostname(hostname) { + const hostPattern = /^[a-z0-9][a-z0-9\.\-]*[a-z0-9]$/; + return hostPattern.test(hostname); +} - if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) { - return c - 0x30; - } +exports.Field = Field; +exports.Fields = Fields; +exports.HttpRequest = HttpRequest; +exports.HttpResponse = HttpResponse; +exports.getHttpHandlerExtensionConfiguration = getHttpHandlerExtensionConfiguration; +exports.isValidHostname = isValidHostname; +exports.resolveHttpHandlerRuntimeConfig = resolveHttpHandlerRuntimeConfig; - /*eslint-disable no-bitwise*/ - lc = c | 0x20; - if ((0x61/* a */ <= lc) && (lc <= 0x66/* f */)) { - return lc - 0x61 + 10; - } +/***/ }), - return -1; -} +/***/ 8256: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -function escapedHexLen(c) { - if (c === 0x78/* x */) { return 2; } - if (c === 0x75/* u */) { return 4; } - if (c === 0x55/* U */) { return 8; } - return 0; -} +"use strict"; -function fromDecimalCode(c) { - if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) { - return c - 0x30; - } - return -1; -} +var utilUriEscape = __nccwpck_require__(146); -function simpleEscapeSequence(c) { - /* eslint-disable indent */ - return (c === 0x30/* 0 */) ? '\x00' : - (c === 0x61/* a */) ? '\x07' : - (c === 0x62/* b */) ? '\x08' : - (c === 0x74/* t */) ? '\x09' : - (c === 0x09/* Tab */) ? '\x09' : - (c === 0x6E/* n */) ? '\x0A' : - (c === 0x76/* v */) ? '\x0B' : - (c === 0x66/* f */) ? '\x0C' : - (c === 0x72/* r */) ? '\x0D' : - (c === 0x65/* e */) ? '\x1B' : - (c === 0x20/* Space */) ? ' ' : - (c === 0x22/* " */) ? '\x22' : - (c === 0x2F/* / */) ? '/' : - (c === 0x5C/* \ */) ? '\x5C' : - (c === 0x4E/* N */) ? '\x85' : - (c === 0x5F/* _ */) ? '\xA0' : - (c === 0x4C/* L */) ? '\u2028' : - (c === 0x50/* P */) ? '\u2029' : ''; +function buildQueryString(query) { + const parts = []; + for (let key of Object.keys(query).sort()) { + const value = query[key]; + key = utilUriEscape.escapeUri(key); + if (Array.isArray(value)) { + for (let i = 0, iLen = value.length; i < iLen; i++) { + parts.push(`${key}=${utilUriEscape.escapeUri(value[i])}`); + } + } + else { + let qsEntry = key; + if (value || typeof value === "string") { + qsEntry += `=${utilUriEscape.escapeUri(value)}`; + } + parts.push(qsEntry); + } + } + return parts.join("&"); } -function charFromCodepoint(c) { - if (c <= 0xFFFF) { - return String.fromCharCode(c); - } - // Encode UTF-16 surrogate pair - // https://en.wikipedia.org/wiki/UTF-16#Code_points_U.2B010000_to_U.2B10FFFF - return String.fromCharCode( - ((c - 0x010000) >> 10) + 0xD800, - ((c - 0x010000) & 0x03FF) + 0xDC00 - ); -} +exports.buildQueryString = buildQueryString; -var simpleEscapeCheck = new Array(256); // integer, for fast access -var simpleEscapeMap = new Array(256); -for (var i = 0; i < 256; i++) { - simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0; - simpleEscapeMap[i] = simpleEscapeSequence(i); -} +/***/ }), -function State(input, options) { - this.input = input; - - this.filename = options['filename'] || null; - this.schema = options['schema'] || DEFAULT_FULL_SCHEMA; - this.onWarning = options['onWarning'] || null; - this.legacy = options['legacy'] || false; - this.json = options['json'] || false; - this.listener = options['listener'] || null; - - this.implicitTypes = this.schema.compiledImplicit; - this.typeMap = this.schema.compiledTypeMap; - - this.length = input.length; - this.position = 0; - this.line = 0; - this.lineStart = 0; - this.lineIndent = 0; - - this.documents = []; - - /* - this.version; - this.checkLineBreaks; - this.tagMap; - this.anchorMap; - this.tag; - this.anchor; - this.kind; - this.result;*/ +/***/ 8822: +/***/ ((__unused_webpack_module, exports) => { -} +"use strict"; -function generateError(state, message) { - return new YAMLException( - message, - new Mark(state.filename, state.input, state.position, state.line, (state.position - state.lineStart))); +function parseQueryString(querystring) { + const query = {}; + querystring = querystring.replace(/^\?/, ""); + if (querystring) { + for (const pair of querystring.split("&")) { + let [key, value = null] = pair.split("="); + key = decodeURIComponent(key); + if (value) { + value = decodeURIComponent(value); + } + if (!(key in query)) { + query[key] = value; + } + else if (Array.isArray(query[key])) { + query[key].push(value); + } + else { + query[key] = [query[key], value]; + } + } + } + return query; } -function throwError(state, message) { - throw generateError(state, message); -} +exports.parseQueryString = parseQueryString; -function throwWarning(state, message) { - if (state.onWarning) { - state.onWarning.call(null, generateError(state, message)); - } -} +/***/ }), -var directiveHandlers = { +/***/ 2058: +/***/ ((__unused_webpack_module, exports) => { - YAML: function handleYamlDirective(state, name, args) { +"use strict"; - var match, major, minor; - if (state.version !== null) { - throwError(state, 'duplication of %YAML directive'); +const CLOCK_SKEW_ERROR_CODES = [ + "AuthFailure", + "InvalidSignatureException", + "RequestExpired", + "RequestInTheFuture", + "RequestTimeTooSkewed", + "SignatureDoesNotMatch", +]; +const THROTTLING_ERROR_CODES = [ + "BandwidthLimitExceeded", + "EC2ThrottledException", + "LimitExceededException", + "PriorRequestNotComplete", + "ProvisionedThroughputExceededException", + "RequestLimitExceeded", + "RequestThrottled", + "RequestThrottledException", + "SlowDown", + "ThrottledException", + "Throttling", + "ThrottlingException", + "TooManyRequestsException", + "TransactionInProgressException", +]; +const TRANSIENT_ERROR_CODES = ["TimeoutError", "RequestTimeout", "RequestTimeoutException"]; +const TRANSIENT_ERROR_STATUS_CODES = [500, 502, 503, 504]; +const NODEJS_TIMEOUT_ERROR_CODES = ["ECONNRESET", "ECONNREFUSED", "EPIPE", "ETIMEDOUT"]; +const NODEJS_NETWORK_ERROR_CODES = ["EHOSTUNREACH", "ENETUNREACH", "ENOTFOUND"]; + +const isRetryableByTrait = (error) => error?.$retryable !== undefined; +const isClockSkewError = (error) => CLOCK_SKEW_ERROR_CODES.includes(error.name); +const isClockSkewCorrectedError = (error) => error.$metadata?.clockSkewCorrected; +const isBrowserNetworkError = (error) => { + const errorMessages = new Set([ + "Failed to fetch", + "NetworkError when attempting to fetch resource", + "The Internet connection appears to be offline", + "Load failed", + "Network request failed", + ]); + const isValid = error && error instanceof TypeError; + if (!isValid) { + return false; } - - if (args.length !== 1) { - throwError(state, 'YAML directive accepts exactly one argument'); + return errorMessages.has(error.message); +}; +const isThrottlingError = (error) => error.$metadata?.httpStatusCode === 429 || + THROTTLING_ERROR_CODES.includes(error.name) || + error.$retryable?.throttling == true; +const isTransientError = (error, depth = 0) => isRetryableByTrait(error) || + isClockSkewCorrectedError(error) || + TRANSIENT_ERROR_CODES.includes(error.name) || + NODEJS_TIMEOUT_ERROR_CODES.includes(error?.code || "") || + NODEJS_NETWORK_ERROR_CODES.includes(error?.code || "") || + TRANSIENT_ERROR_STATUS_CODES.includes(error.$metadata?.httpStatusCode || 0) || + isBrowserNetworkError(error) || + (error.cause !== undefined && depth <= 10 && isTransientError(error.cause, depth + 1)); +const isServerError = (error) => { + if (error.$metadata?.httpStatusCode !== undefined) { + const statusCode = error.$metadata.httpStatusCode; + if (500 <= statusCode && statusCode <= 599 && !isTransientError(error)) { + return true; + } + return false; } + return false; +}; - match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]); +exports.isBrowserNetworkError = isBrowserNetworkError; +exports.isClockSkewCorrectedError = isClockSkewCorrectedError; +exports.isClockSkewError = isClockSkewError; +exports.isRetryableByTrait = isRetryableByTrait; +exports.isServerError = isServerError; +exports.isThrottlingError = isThrottlingError; +exports.isTransientError = isTransientError; - if (match === null) { - throwError(state, 'ill-formed argument of the YAML directive'); - } - major = parseInt(match[1], 10); - minor = parseInt(match[2], 10); +/***/ }), - if (major !== 1) { - throwError(state, 'unacceptable YAML version of the document'); - } +/***/ 4172: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - state.version = args[0]; - state.checkLineBreaks = (minor < 2); +"use strict"; - if (minor !== 1 && minor !== 2) { - throwWarning(state, 'unsupported YAML version of the document'); +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getHomeDir = void 0; +const os_1 = __nccwpck_require__(857); +const path_1 = __nccwpck_require__(6928); +const homeDirCache = {}; +const getHomeDirCacheKey = () => { + if (process && process.geteuid) { + return `${process.geteuid()}`; } - }, + return "DEFAULT"; +}; +const getHomeDir = () => { + const { HOME, USERPROFILE, HOMEPATH, HOMEDRIVE = `C:${path_1.sep}` } = process.env; + if (HOME) + return HOME; + if (USERPROFILE) + return USERPROFILE; + if (HOMEPATH) + return `${HOMEDRIVE}${HOMEPATH}`; + const homeDirCacheKey = getHomeDirCacheKey(); + if (!homeDirCache[homeDirCacheKey]) + homeDirCache[homeDirCacheKey] = (0, os_1.homedir)(); + return homeDirCache[homeDirCacheKey]; +}; +exports.getHomeDir = getHomeDir; - TAG: function handleTagDirective(state, name, args) { - var handle, prefix; +/***/ }), - if (args.length !== 2) { - throwError(state, 'TAG directive accepts exactly two arguments'); - } +/***/ 269: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - handle = args[0]; - prefix = args[1]; +"use strict"; - if (!PATTERN_TAG_HANDLE.test(handle)) { - throwError(state, 'ill-formed tag handle (first argument) of the TAG directive'); - } +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getSSOTokenFilepath = void 0; +const crypto_1 = __nccwpck_require__(6982); +const path_1 = __nccwpck_require__(6928); +const getHomeDir_1 = __nccwpck_require__(4172); +const getSSOTokenFilepath = (id) => { + const hasher = (0, crypto_1.createHash)("sha1"); + const cacheName = hasher.update(id).digest("hex"); + return (0, path_1.join)((0, getHomeDir_1.getHomeDir)(), ".aws", "sso", "cache", `${cacheName}.json`); +}; +exports.getSSOTokenFilepath = getSSOTokenFilepath; - if (_hasOwnProperty.call(state.tagMap, handle)) { - throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle'); - } - if (!PATTERN_TAG_URI.test(prefix)) { - throwError(state, 'ill-formed tag prefix (second argument) of the TAG directive'); - } +/***/ }), - state.tagMap[handle] = prefix; - } +/***/ 1326: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getSSOTokenFromFile = exports.tokenIntercept = void 0; +const promises_1 = __nccwpck_require__(1943); +const getSSOTokenFilepath_1 = __nccwpck_require__(269); +exports.tokenIntercept = {}; +const getSSOTokenFromFile = async (id) => { + if (exports.tokenIntercept[id]) { + return exports.tokenIntercept[id]; + } + const ssoTokenFilepath = (0, getSSOTokenFilepath_1.getSSOTokenFilepath)(id); + const ssoTokenText = await (0, promises_1.readFile)(ssoTokenFilepath, "utf8"); + return JSON.parse(ssoTokenText); }; +exports.getSSOTokenFromFile = getSSOTokenFromFile; -function captureSegment(state, start, end, checkJson) { - var _position, _length, _character, _result; +/***/ }), - if (start < end) { - _result = state.input.slice(start, end); +/***/ 4964: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - if (checkJson) { - for (_position = 0, _length = _result.length; _position < _length; _position += 1) { - _character = _result.charCodeAt(_position); - if (!(_character === 0x09 || - (0x20 <= _character && _character <= 0x10FFFF))) { - throwError(state, 'expected valid JSON character'); - } - } - } else if (PATTERN_NON_PRINTABLE.test(_result)) { - throwError(state, 'the stream contains non-printable characters'); - } +"use strict"; - state.result += _result; - } -} -function mergeMappings(state, destination, source, overridableKeys) { - var sourceKeys, key, index, quantity; +var getHomeDir = __nccwpck_require__(4172); +var getSSOTokenFilepath = __nccwpck_require__(269); +var getSSOTokenFromFile = __nccwpck_require__(1326); +var path = __nccwpck_require__(6928); +var types = __nccwpck_require__(690); +var readFile = __nccwpck_require__(6684); - if (!common.isObject(source)) { - throwError(state, 'cannot merge mappings; the provided source object is unacceptable'); - } +const ENV_PROFILE = "AWS_PROFILE"; +const DEFAULT_PROFILE = "default"; +const getProfileName = (init) => init.profile || process.env[ENV_PROFILE] || DEFAULT_PROFILE; - sourceKeys = Object.keys(source); +const CONFIG_PREFIX_SEPARATOR = "."; - for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) { - key = sourceKeys[index]; +const getConfigData = (data) => Object.entries(data) + .filter(([key]) => { + const indexOfSeparator = key.indexOf(CONFIG_PREFIX_SEPARATOR); + if (indexOfSeparator === -1) { + return false; + } + return Object.values(types.IniSectionType).includes(key.substring(0, indexOfSeparator)); +}) + .reduce((acc, [key, value]) => { + const indexOfSeparator = key.indexOf(CONFIG_PREFIX_SEPARATOR); + const updatedKey = key.substring(0, indexOfSeparator) === types.IniSectionType.PROFILE ? key.substring(indexOfSeparator + 1) : key; + acc[updatedKey] = value; + return acc; +}, { + ...(data.default && { default: data.default }), +}); - if (!_hasOwnProperty.call(destination, key)) { - destination[key] = source[key]; - overridableKeys[key] = true; +const ENV_CONFIG_PATH = "AWS_CONFIG_FILE"; +const getConfigFilepath = () => process.env[ENV_CONFIG_PATH] || path.join(getHomeDir.getHomeDir(), ".aws", "config"); + +const ENV_CREDENTIALS_PATH = "AWS_SHARED_CREDENTIALS_FILE"; +const getCredentialsFilepath = () => process.env[ENV_CREDENTIALS_PATH] || path.join(getHomeDir.getHomeDir(), ".aws", "credentials"); + +const prefixKeyRegex = /^([\w-]+)\s(["'])?([\w-@\+\.%:/]+)\2$/; +const profileNameBlockList = ["__proto__", "profile __proto__"]; +const parseIni = (iniData) => { + const map = {}; + let currentSection; + let currentSubSection; + for (const iniLine of iniData.split(/\r?\n/)) { + const trimmedLine = iniLine.split(/(^|\s)[;#]/)[0].trim(); + const isSection = trimmedLine[0] === "[" && trimmedLine[trimmedLine.length - 1] === "]"; + if (isSection) { + currentSection = undefined; + currentSubSection = undefined; + const sectionName = trimmedLine.substring(1, trimmedLine.length - 1); + const matches = prefixKeyRegex.exec(sectionName); + if (matches) { + const [, prefix, , name] = matches; + if (Object.values(types.IniSectionType).includes(prefix)) { + currentSection = [prefix, name].join(CONFIG_PREFIX_SEPARATOR); + } + } + else { + currentSection = sectionName; + } + if (profileNameBlockList.includes(sectionName)) { + throw new Error(`Found invalid profile name "${sectionName}"`); + } + } + else if (currentSection) { + const indexOfEqualsSign = trimmedLine.indexOf("="); + if (![0, -1].includes(indexOfEqualsSign)) { + const [name, value] = [ + trimmedLine.substring(0, indexOfEqualsSign).trim(), + trimmedLine.substring(indexOfEqualsSign + 1).trim(), + ]; + if (value === "") { + currentSubSection = name; + } + else { + if (currentSubSection && iniLine.trimStart() === iniLine) { + currentSubSection = undefined; + } + map[currentSection] = map[currentSection] || {}; + const key = currentSubSection ? [currentSubSection, name].join(CONFIG_PREFIX_SEPARATOR) : name; + map[currentSection][key] = value; + } + } + } } - } -} + return map; +}; -function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startPos) { - var index, quantity; +const swallowError$1 = () => ({}); +const loadSharedConfigFiles = async (init = {}) => { + const { filepath = getCredentialsFilepath(), configFilepath = getConfigFilepath() } = init; + const homeDir = getHomeDir.getHomeDir(); + const relativeHomeDirPrefix = "~/"; + let resolvedFilepath = filepath; + if (filepath.startsWith(relativeHomeDirPrefix)) { + resolvedFilepath = path.join(homeDir, filepath.slice(2)); + } + let resolvedConfigFilepath = configFilepath; + if (configFilepath.startsWith(relativeHomeDirPrefix)) { + resolvedConfigFilepath = path.join(homeDir, configFilepath.slice(2)); + } + const parsedFiles = await Promise.all([ + readFile.readFile(resolvedConfigFilepath, { + ignoreCache: init.ignoreCache, + }) + .then(parseIni) + .then(getConfigData) + .catch(swallowError$1), + readFile.readFile(resolvedFilepath, { + ignoreCache: init.ignoreCache, + }) + .then(parseIni) + .catch(swallowError$1), + ]); + return { + configFile: parsedFiles[0], + credentialsFile: parsedFiles[1], + }; +}; - // The output is a plain object here, so keys can only be strings. - // We need to convert keyNode to a string, but doing so can hang the process - // (deeply nested arrays that explode exponentially using aliases). - if (Array.isArray(keyNode)) { - keyNode = Array.prototype.slice.call(keyNode); +const getSsoSessionData = (data) => Object.entries(data) + .filter(([key]) => key.startsWith(types.IniSectionType.SSO_SESSION + CONFIG_PREFIX_SEPARATOR)) + .reduce((acc, [key, value]) => ({ ...acc, [key.substring(key.indexOf(CONFIG_PREFIX_SEPARATOR) + 1)]: value }), {}); + +const swallowError = () => ({}); +const loadSsoSessionData = async (init = {}) => readFile.readFile(init.configFilepath ?? getConfigFilepath()) + .then(parseIni) + .then(getSsoSessionData) + .catch(swallowError); + +const mergeConfigFiles = (...files) => { + const merged = {}; + for (const file of files) { + for (const [key, values] of Object.entries(file)) { + if (merged[key] !== undefined) { + Object.assign(merged[key], values); + } + else { + merged[key] = values; + } + } + } + return merged; +}; - for (index = 0, quantity = keyNode.length; index < quantity; index += 1) { - if (Array.isArray(keyNode[index])) { - throwError(state, 'nested arrays are not supported inside keys'); - } +const parseKnownFiles = async (init) => { + const parsedFiles = await loadSharedConfigFiles(init); + return mergeConfigFiles(parsedFiles.configFile, parsedFiles.credentialsFile); +}; - if (typeof keyNode === 'object' && _class(keyNode[index]) === '[object Object]') { - keyNode[index] = '[object Object]'; - } - } - } +const externalDataInterceptor = { + getFileRecord() { + return readFile.fileIntercept; + }, + interceptFile(path, contents) { + readFile.fileIntercept[path] = Promise.resolve(contents); + }, + getTokenRecord() { + return getSSOTokenFromFile.tokenIntercept; + }, + interceptToken(id, contents) { + getSSOTokenFromFile.tokenIntercept[id] = contents; + }, +}; - // Avoid code execution in load() via toString property - // (still use its own toString for arrays, timestamps, - // and whatever user schema extensions happen to have @@toStringTag) - if (typeof keyNode === 'object' && _class(keyNode) === '[object Object]') { - keyNode = '[object Object]'; - } +Object.defineProperty(exports, "getSSOTokenFromFile", ({ + enumerable: true, + get: function () { return getSSOTokenFromFile.getSSOTokenFromFile; } +})); +Object.defineProperty(exports, "readFile", ({ + enumerable: true, + get: function () { return readFile.readFile; } +})); +exports.CONFIG_PREFIX_SEPARATOR = CONFIG_PREFIX_SEPARATOR; +exports.DEFAULT_PROFILE = DEFAULT_PROFILE; +exports.ENV_PROFILE = ENV_PROFILE; +exports.externalDataInterceptor = externalDataInterceptor; +exports.getProfileName = getProfileName; +exports.loadSharedConfigFiles = loadSharedConfigFiles; +exports.loadSsoSessionData = loadSsoSessionData; +exports.parseKnownFiles = parseKnownFiles; +Object.keys(getHomeDir).forEach(function (k) { + if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, { + enumerable: true, + get: function () { return getHomeDir[k]; } + }); +}); +Object.keys(getSSOTokenFilepath).forEach(function (k) { + if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, { + enumerable: true, + get: function () { return getSSOTokenFilepath[k]; } + }); +}); - keyNode = String(keyNode); +/***/ }), - if (_result === null) { - _result = {}; - } +/***/ 6684: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - if (keyTag === 'tag:yaml.org,2002:merge') { - if (Array.isArray(valueNode)) { - for (index = 0, quantity = valueNode.length; index < quantity; index += 1) { - mergeMappings(state, _result, valueNode[index], overridableKeys); - } - } else { - mergeMappings(state, _result, valueNode, overridableKeys); +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.readFile = exports.fileIntercept = exports.filePromises = void 0; +const promises_1 = __nccwpck_require__(1455); +exports.filePromises = {}; +exports.fileIntercept = {}; +const readFile = (path, options) => { + if (exports.fileIntercept[path] !== undefined) { + return exports.fileIntercept[path]; } - } else { - if (!state.json && - !_hasOwnProperty.call(overridableKeys, keyNode) && - _hasOwnProperty.call(_result, keyNode)) { - state.line = startLine || state.line; - state.position = startPos || state.position; - throwError(state, 'duplicated mapping key'); + if (!exports.filePromises[path] || options?.ignoreCache) { + exports.filePromises[path] = (0, promises_1.readFile)(path, "utf8"); } - _result[keyNode] = valueNode; - delete overridableKeys[keyNode]; - } + return exports.filePromises[path]; +}; +exports.readFile = readFile; - return _result; -} -function readLineBreak(state) { - var ch; +/***/ }), - ch = state.input.charCodeAt(state.position); +/***/ 5118: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - if (ch === 0x0A/* LF */) { - state.position++; - } else if (ch === 0x0D/* CR */) { - state.position++; - if (state.input.charCodeAt(state.position) === 0x0A/* LF */) { - state.position++; - } - } else { - throwError(state, 'a line break is expected'); - } +"use strict"; - state.line += 1; - state.lineStart = state.position; -} -function skipSeparationSpace(state, allowComments, checkIndent) { - var lineBreaks = 0, - ch = state.input.charCodeAt(state.position); +var utilHexEncoding = __nccwpck_require__(6435); +var utilUtf8 = __nccwpck_require__(1577); +var isArrayBuffer = __nccwpck_require__(6130); +var protocolHttp = __nccwpck_require__(2356); +var utilMiddleware = __nccwpck_require__(6324); +var utilUriEscape = __nccwpck_require__(146); + +const ALGORITHM_QUERY_PARAM = "X-Amz-Algorithm"; +const CREDENTIAL_QUERY_PARAM = "X-Amz-Credential"; +const AMZ_DATE_QUERY_PARAM = "X-Amz-Date"; +const SIGNED_HEADERS_QUERY_PARAM = "X-Amz-SignedHeaders"; +const EXPIRES_QUERY_PARAM = "X-Amz-Expires"; +const SIGNATURE_QUERY_PARAM = "X-Amz-Signature"; +const TOKEN_QUERY_PARAM = "X-Amz-Security-Token"; +const REGION_SET_PARAM = "X-Amz-Region-Set"; +const AUTH_HEADER = "authorization"; +const AMZ_DATE_HEADER = AMZ_DATE_QUERY_PARAM.toLowerCase(); +const DATE_HEADER = "date"; +const GENERATED_HEADERS = [AUTH_HEADER, AMZ_DATE_HEADER, DATE_HEADER]; +const SIGNATURE_HEADER = SIGNATURE_QUERY_PARAM.toLowerCase(); +const SHA256_HEADER = "x-amz-content-sha256"; +const TOKEN_HEADER = TOKEN_QUERY_PARAM.toLowerCase(); +const HOST_HEADER = "host"; +const ALWAYS_UNSIGNABLE_HEADERS = { + authorization: true, + "cache-control": true, + connection: true, + expect: true, + from: true, + "keep-alive": true, + "max-forwards": true, + pragma: true, + referer: true, + te: true, + trailer: true, + "transfer-encoding": true, + upgrade: true, + "user-agent": true, + "x-amzn-trace-id": true, +}; +const PROXY_HEADER_PATTERN = /^proxy-/; +const SEC_HEADER_PATTERN = /^sec-/; +const UNSIGNABLE_PATTERNS = [/^proxy-/i, /^sec-/i]; +const ALGORITHM_IDENTIFIER = "AWS4-HMAC-SHA256"; +const ALGORITHM_IDENTIFIER_V4A = "AWS4-ECDSA-P256-SHA256"; +const EVENT_ALGORITHM_IDENTIFIER = "AWS4-HMAC-SHA256-PAYLOAD"; +const UNSIGNED_PAYLOAD = "UNSIGNED-PAYLOAD"; +const MAX_CACHE_SIZE = 50; +const KEY_TYPE_IDENTIFIER = "aws4_request"; +const MAX_PRESIGNED_TTL = 60 * 60 * 24 * 7; + +const signingKeyCache = {}; +const cacheQueue = []; +const createScope = (shortDate, region, service) => `${shortDate}/${region}/${service}/${KEY_TYPE_IDENTIFIER}`; +const getSigningKey = async (sha256Constructor, credentials, shortDate, region, service) => { + const credsHash = await hmac(sha256Constructor, credentials.secretAccessKey, credentials.accessKeyId); + const cacheKey = `${shortDate}:${region}:${service}:${utilHexEncoding.toHex(credsHash)}:${credentials.sessionToken}`; + if (cacheKey in signingKeyCache) { + return signingKeyCache[cacheKey]; + } + cacheQueue.push(cacheKey); + while (cacheQueue.length > MAX_CACHE_SIZE) { + delete signingKeyCache[cacheQueue.shift()]; + } + let key = `AWS4${credentials.secretAccessKey}`; + for (const signable of [shortDate, region, service, KEY_TYPE_IDENTIFIER]) { + key = await hmac(sha256Constructor, key, signable); + } + return (signingKeyCache[cacheKey] = key); +}; +const clearCredentialCache = () => { + cacheQueue.length = 0; + Object.keys(signingKeyCache).forEach((cacheKey) => { + delete signingKeyCache[cacheKey]; + }); +}; +const hmac = (ctor, secret, data) => { + const hash = new ctor(secret); + hash.update(utilUtf8.toUint8Array(data)); + return hash.digest(); +}; - while (ch !== 0) { - while (is_WHITE_SPACE(ch)) { - ch = state.input.charCodeAt(++state.position); +const getCanonicalHeaders = ({ headers }, unsignableHeaders, signableHeaders) => { + const canonical = {}; + for (const headerName of Object.keys(headers).sort()) { + if (headers[headerName] == undefined) { + continue; + } + const canonicalHeaderName = headerName.toLowerCase(); + if (canonicalHeaderName in ALWAYS_UNSIGNABLE_HEADERS || + unsignableHeaders?.has(canonicalHeaderName) || + PROXY_HEADER_PATTERN.test(canonicalHeaderName) || + SEC_HEADER_PATTERN.test(canonicalHeaderName)) { + if (!signableHeaders || (signableHeaders && !signableHeaders.has(canonicalHeaderName))) { + continue; + } + } + canonical[canonicalHeaderName] = headers[headerName].trim().replace(/\s+/g, " "); } + return canonical; +}; - if (allowComments && ch === 0x23/* # */) { - do { - ch = state.input.charCodeAt(++state.position); - } while (ch !== 0x0A/* LF */ && ch !== 0x0D/* CR */ && ch !== 0); +const getPayloadHash = async ({ headers, body }, hashConstructor) => { + for (const headerName of Object.keys(headers)) { + if (headerName.toLowerCase() === SHA256_HEADER) { + return headers[headerName]; + } } - - if (is_EOL(ch)) { - readLineBreak(state); - - ch = state.input.charCodeAt(state.position); - lineBreaks++; - state.lineIndent = 0; - - while (ch === 0x20/* Space */) { - state.lineIndent++; - ch = state.input.charCodeAt(++state.position); - } - } else { - break; + if (body == undefined) { + return "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"; } - } - - if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) { - throwWarning(state, 'deficient indentation'); - } + else if (typeof body === "string" || ArrayBuffer.isView(body) || isArrayBuffer.isArrayBuffer(body)) { + const hashCtor = new hashConstructor(); + hashCtor.update(utilUtf8.toUint8Array(body)); + return utilHexEncoding.toHex(await hashCtor.digest()); + } + return UNSIGNED_PAYLOAD; +}; - return lineBreaks; +class HeaderFormatter { + format(headers) { + const chunks = []; + for (const headerName of Object.keys(headers)) { + const bytes = utilUtf8.fromUtf8(headerName); + chunks.push(Uint8Array.from([bytes.byteLength]), bytes, this.formatHeaderValue(headers[headerName])); + } + const out = new Uint8Array(chunks.reduce((carry, bytes) => carry + bytes.byteLength, 0)); + let position = 0; + for (const chunk of chunks) { + out.set(chunk, position); + position += chunk.byteLength; + } + return out; + } + formatHeaderValue(header) { + switch (header.type) { + case "boolean": + return Uint8Array.from([header.value ? 0 : 1]); + case "byte": + return Uint8Array.from([2, header.value]); + case "short": + const shortView = new DataView(new ArrayBuffer(3)); + shortView.setUint8(0, 3); + shortView.setInt16(1, header.value, false); + return new Uint8Array(shortView.buffer); + case "integer": + const intView = new DataView(new ArrayBuffer(5)); + intView.setUint8(0, 4); + intView.setInt32(1, header.value, false); + return new Uint8Array(intView.buffer); + case "long": + const longBytes = new Uint8Array(9); + longBytes[0] = 5; + longBytes.set(header.value.bytes, 1); + return longBytes; + case "binary": + const binView = new DataView(new ArrayBuffer(3 + header.value.byteLength)); + binView.setUint8(0, 6); + binView.setUint16(1, header.value.byteLength, false); + const binBytes = new Uint8Array(binView.buffer); + binBytes.set(header.value, 3); + return binBytes; + case "string": + const utf8Bytes = utilUtf8.fromUtf8(header.value); + const strView = new DataView(new ArrayBuffer(3 + utf8Bytes.byteLength)); + strView.setUint8(0, 7); + strView.setUint16(1, utf8Bytes.byteLength, false); + const strBytes = new Uint8Array(strView.buffer); + strBytes.set(utf8Bytes, 3); + return strBytes; + case "timestamp": + const tsBytes = new Uint8Array(9); + tsBytes[0] = 8; + tsBytes.set(Int64.fromNumber(header.value.valueOf()).bytes, 1); + return tsBytes; + case "uuid": + if (!UUID_PATTERN.test(header.value)) { + throw new Error(`Invalid UUID received: ${header.value}`); + } + const uuidBytes = new Uint8Array(17); + uuidBytes[0] = 9; + uuidBytes.set(utilHexEncoding.fromHex(header.value.replace(/\-/g, "")), 1); + return uuidBytes; + } + } } - -function testDocumentSeparator(state) { - var _position = state.position, - ch; - - ch = state.input.charCodeAt(_position); - - // Condition state.position === state.lineStart is tested - // in parent on each call, for efficiency. No needs to test here again. - if ((ch === 0x2D/* - */ || ch === 0x2E/* . */) && - ch === state.input.charCodeAt(_position + 1) && - ch === state.input.charCodeAt(_position + 2)) { - - _position += 3; - - ch = state.input.charCodeAt(_position); - - if (ch === 0 || is_WS_OR_EOL(ch)) { - return true; +const UUID_PATTERN = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/; +class Int64 { + bytes; + constructor(bytes) { + this.bytes = bytes; + if (bytes.byteLength !== 8) { + throw new Error("Int64 buffers must be exactly 8 bytes"); + } + } + static fromNumber(number) { + if (number > 9_223_372_036_854_775_807 || number < -9223372036854776e3) { + throw new Error(`${number} is too large (or, if negative, too small) to represent as an Int64`); + } + const bytes = new Uint8Array(8); + for (let i = 7, remaining = Math.abs(Math.round(number)); i > -1 && remaining > 0; i--, remaining /= 256) { + bytes[i] = remaining; + } + if (number < 0) { + negate(bytes); + } + return new Int64(bytes); + } + valueOf() { + const bytes = this.bytes.slice(0); + const negative = bytes[0] & 0b10000000; + if (negative) { + negate(bytes); + } + return parseInt(utilHexEncoding.toHex(bytes), 16) * (negative ? -1 : 1); + } + toString() { + return String(this.valueOf()); } - } - - return false; } - -function writeFoldedLines(state, count) { - if (count === 1) { - state.result += ' '; - } else if (count > 1) { - state.result += common.repeat('\n', count - 1); - } +function negate(bytes) { + for (let i = 0; i < 8; i++) { + bytes[i] ^= 0xff; + } + for (let i = 7; i > -1; i--) { + bytes[i]++; + if (bytes[i] !== 0) + break; + } } +const hasHeader = (soughtHeader, headers) => { + soughtHeader = soughtHeader.toLowerCase(); + for (const headerName of Object.keys(headers)) { + if (soughtHeader === headerName.toLowerCase()) { + return true; + } + } + return false; +}; -function readPlainScalar(state, nodeIndent, withinFlowCollection) { - var preceding, - following, - captureStart, - captureEnd, - hasPendingContent, - _line, - _lineStart, - _lineIndent, - _kind = state.kind, - _result = state.result, - ch; +const moveHeadersToQuery = (request, options = {}) => { + const { headers, query = {} } = protocolHttp.HttpRequest.clone(request); + for (const name of Object.keys(headers)) { + const lname = name.toLowerCase(); + if ((lname.slice(0, 6) === "x-amz-" && !options.unhoistableHeaders?.has(lname)) || + options.hoistableHeaders?.has(lname)) { + query[name] = headers[name]; + delete headers[name]; + } + } + return { + ...request, + headers, + query, + }; +}; - ch = state.input.charCodeAt(state.position); +const prepareRequest = (request) => { + request = protocolHttp.HttpRequest.clone(request); + for (const headerName of Object.keys(request.headers)) { + if (GENERATED_HEADERS.indexOf(headerName.toLowerCase()) > -1) { + delete request.headers[headerName]; + } + } + return request; +}; - if (is_WS_OR_EOL(ch) || - is_FLOW_INDICATOR(ch) || - ch === 0x23/* # */ || - ch === 0x26/* & */ || - ch === 0x2A/* * */ || - ch === 0x21/* ! */ || - ch === 0x7C/* | */ || - ch === 0x3E/* > */ || - ch === 0x27/* ' */ || - ch === 0x22/* " */ || - ch === 0x25/* % */ || - ch === 0x40/* @ */ || - ch === 0x60/* ` */) { - return false; - } +const getCanonicalQuery = ({ query = {} }) => { + const keys = []; + const serialized = {}; + for (const key of Object.keys(query)) { + if (key.toLowerCase() === SIGNATURE_HEADER) { + continue; + } + const encodedKey = utilUriEscape.escapeUri(key); + keys.push(encodedKey); + const value = query[key]; + if (typeof value === "string") { + serialized[encodedKey] = `${encodedKey}=${utilUriEscape.escapeUri(value)}`; + } + else if (Array.isArray(value)) { + serialized[encodedKey] = value + .slice(0) + .reduce((encoded, value) => encoded.concat([`${encodedKey}=${utilUriEscape.escapeUri(value)}`]), []) + .sort() + .join("&"); + } + } + return keys + .sort() + .map((key) => serialized[key]) + .filter((serialized) => serialized) + .join("&"); +}; - if (ch === 0x3F/* ? */ || ch === 0x2D/* - */) { - following = state.input.charCodeAt(state.position + 1); +const iso8601 = (time) => toDate(time) + .toISOString() + .replace(/\.\d{3}Z$/, "Z"); +const toDate = (time) => { + if (typeof time === "number") { + return new Date(time * 1000); + } + if (typeof time === "string") { + if (Number(time)) { + return new Date(Number(time) * 1000); + } + return new Date(time); + } + return time; +}; - if (is_WS_OR_EOL(following) || - withinFlowCollection && is_FLOW_INDICATOR(following)) { - return false; +class SignatureV4Base { + service; + regionProvider; + credentialProvider; + sha256; + uriEscapePath; + applyChecksum; + constructor({ applyChecksum, credentials, region, service, sha256, uriEscapePath = true, }) { + this.service = service; + this.sha256 = sha256; + this.uriEscapePath = uriEscapePath; + this.applyChecksum = typeof applyChecksum === "boolean" ? applyChecksum : true; + this.regionProvider = utilMiddleware.normalizeProvider(region); + this.credentialProvider = utilMiddleware.normalizeProvider(credentials); + } + createCanonicalRequest(request, canonicalHeaders, payloadHash) { + const sortedHeaders = Object.keys(canonicalHeaders).sort(); + return `${request.method} +${this.getCanonicalPath(request)} +${getCanonicalQuery(request)} +${sortedHeaders.map((name) => `${name}:${canonicalHeaders[name]}`).join("\n")} + +${sortedHeaders.join(";")} +${payloadHash}`; + } + async createStringToSign(longDate, credentialScope, canonicalRequest, algorithmIdentifier) { + const hash = new this.sha256(); + hash.update(utilUtf8.toUint8Array(canonicalRequest)); + const hashedRequest = await hash.digest(); + return `${algorithmIdentifier} +${longDate} +${credentialScope} +${utilHexEncoding.toHex(hashedRequest)}`; + } + getCanonicalPath({ path }) { + if (this.uriEscapePath) { + const normalizedPathSegments = []; + for (const pathSegment of path.split("/")) { + if (pathSegment?.length === 0) + continue; + if (pathSegment === ".") + continue; + if (pathSegment === "..") { + normalizedPathSegments.pop(); + } + else { + normalizedPathSegments.push(pathSegment); + } + } + const normalizedPath = `${path?.startsWith("/") ? "/" : ""}${normalizedPathSegments.join("/")}${normalizedPathSegments.length > 0 && path?.endsWith("/") ? "/" : ""}`; + const doubleEncoded = utilUriEscape.escapeUri(normalizedPath); + return doubleEncoded.replace(/%2F/g, "/"); + } + return path; } - } + validateResolvedCredentials(credentials) { + if (typeof credentials !== "object" || + typeof credentials.accessKeyId !== "string" || + typeof credentials.secretAccessKey !== "string") { + throw new Error("Resolved credential object is not valid"); + } + } + formatDate(now) { + const longDate = iso8601(now).replace(/[\-:]/g, ""); + return { + longDate, + shortDate: longDate.slice(0, 8), + }; + } + getCanonicalHeaderList(headers) { + return Object.keys(headers).sort().join(";"); + } +} - state.kind = 'scalar'; - state.result = ''; - captureStart = captureEnd = state.position; - hasPendingContent = false; +class SignatureV4 extends SignatureV4Base { + headerFormatter = new HeaderFormatter(); + constructor({ applyChecksum, credentials, region, service, sha256, uriEscapePath = true, }) { + super({ + applyChecksum, + credentials, + region, + service, + sha256, + uriEscapePath, + }); + } + async presign(originalRequest, options = {}) { + const { signingDate = new Date(), expiresIn = 3600, unsignableHeaders, unhoistableHeaders, signableHeaders, hoistableHeaders, signingRegion, signingService, } = options; + const credentials = await this.credentialProvider(); + this.validateResolvedCredentials(credentials); + const region = signingRegion ?? (await this.regionProvider()); + const { longDate, shortDate } = this.formatDate(signingDate); + if (expiresIn > MAX_PRESIGNED_TTL) { + return Promise.reject("Signature version 4 presigned URLs" + " must have an expiration date less than one week in" + " the future"); + } + const scope = createScope(shortDate, region, signingService ?? this.service); + const request = moveHeadersToQuery(prepareRequest(originalRequest), { unhoistableHeaders, hoistableHeaders }); + if (credentials.sessionToken) { + request.query[TOKEN_QUERY_PARAM] = credentials.sessionToken; + } + request.query[ALGORITHM_QUERY_PARAM] = ALGORITHM_IDENTIFIER; + request.query[CREDENTIAL_QUERY_PARAM] = `${credentials.accessKeyId}/${scope}`; + request.query[AMZ_DATE_QUERY_PARAM] = longDate; + request.query[EXPIRES_QUERY_PARAM] = expiresIn.toString(10); + const canonicalHeaders = getCanonicalHeaders(request, unsignableHeaders, signableHeaders); + request.query[SIGNED_HEADERS_QUERY_PARAM] = this.getCanonicalHeaderList(canonicalHeaders); + request.query[SIGNATURE_QUERY_PARAM] = await this.getSignature(longDate, scope, this.getSigningKey(credentials, region, shortDate, signingService), this.createCanonicalRequest(request, canonicalHeaders, await getPayloadHash(originalRequest, this.sha256))); + return request; + } + async sign(toSign, options) { + if (typeof toSign === "string") { + return this.signString(toSign, options); + } + else if (toSign.headers && toSign.payload) { + return this.signEvent(toSign, options); + } + else if (toSign.message) { + return this.signMessage(toSign, options); + } + else { + return this.signRequest(toSign, options); + } + } + async signEvent({ headers, payload }, { signingDate = new Date(), priorSignature, signingRegion, signingService }) { + const region = signingRegion ?? (await this.regionProvider()); + const { shortDate, longDate } = this.formatDate(signingDate); + const scope = createScope(shortDate, region, signingService ?? this.service); + const hashedPayload = await getPayloadHash({ headers: {}, body: payload }, this.sha256); + const hash = new this.sha256(); + hash.update(headers); + const hashedHeaders = utilHexEncoding.toHex(await hash.digest()); + const stringToSign = [ + EVENT_ALGORITHM_IDENTIFIER, + longDate, + scope, + priorSignature, + hashedHeaders, + hashedPayload, + ].join("\n"); + return this.signString(stringToSign, { signingDate, signingRegion: region, signingService }); + } + async signMessage(signableMessage, { signingDate = new Date(), signingRegion, signingService }) { + const promise = this.signEvent({ + headers: this.headerFormatter.format(signableMessage.message.headers), + payload: signableMessage.message.body, + }, { + signingDate, + signingRegion, + signingService, + priorSignature: signableMessage.priorSignature, + }); + return promise.then((signature) => { + return { message: signableMessage.message, signature }; + }); + } + async signString(stringToSign, { signingDate = new Date(), signingRegion, signingService } = {}) { + const credentials = await this.credentialProvider(); + this.validateResolvedCredentials(credentials); + const region = signingRegion ?? (await this.regionProvider()); + const { shortDate } = this.formatDate(signingDate); + const hash = new this.sha256(await this.getSigningKey(credentials, region, shortDate, signingService)); + hash.update(utilUtf8.toUint8Array(stringToSign)); + return utilHexEncoding.toHex(await hash.digest()); + } + async signRequest(requestToSign, { signingDate = new Date(), signableHeaders, unsignableHeaders, signingRegion, signingService, } = {}) { + const credentials = await this.credentialProvider(); + this.validateResolvedCredentials(credentials); + const region = signingRegion ?? (await this.regionProvider()); + const request = prepareRequest(requestToSign); + const { longDate, shortDate } = this.formatDate(signingDate); + const scope = createScope(shortDate, region, signingService ?? this.service); + request.headers[AMZ_DATE_HEADER] = longDate; + if (credentials.sessionToken) { + request.headers[TOKEN_HEADER] = credentials.sessionToken; + } + const payloadHash = await getPayloadHash(request, this.sha256); + if (!hasHeader(SHA256_HEADER, request.headers) && this.applyChecksum) { + request.headers[SHA256_HEADER] = payloadHash; + } + const canonicalHeaders = getCanonicalHeaders(request, unsignableHeaders, signableHeaders); + const signature = await this.getSignature(longDate, scope, this.getSigningKey(credentials, region, shortDate, signingService), this.createCanonicalRequest(request, canonicalHeaders, payloadHash)); + request.headers[AUTH_HEADER] = + `${ALGORITHM_IDENTIFIER} ` + + `Credential=${credentials.accessKeyId}/${scope}, ` + + `SignedHeaders=${this.getCanonicalHeaderList(canonicalHeaders)}, ` + + `Signature=${signature}`; + return request; + } + async getSignature(longDate, credentialScope, keyPromise, canonicalRequest) { + const stringToSign = await this.createStringToSign(longDate, credentialScope, canonicalRequest, ALGORITHM_IDENTIFIER); + const hash = new this.sha256(await keyPromise); + hash.update(utilUtf8.toUint8Array(stringToSign)); + return utilHexEncoding.toHex(await hash.digest()); + } + getSigningKey(credentials, region, shortDate, service) { + return getSigningKey(this.sha256, credentials, shortDate, region, service || this.service); + } +} - while (ch !== 0) { - if (ch === 0x3A/* : */) { - following = state.input.charCodeAt(state.position + 1); +const signatureV4aContainer = { + SignatureV4a: null, +}; - if (is_WS_OR_EOL(following) || - withinFlowCollection && is_FLOW_INDICATOR(following)) { - break; - } +exports.ALGORITHM_IDENTIFIER = ALGORITHM_IDENTIFIER; +exports.ALGORITHM_IDENTIFIER_V4A = ALGORITHM_IDENTIFIER_V4A; +exports.ALGORITHM_QUERY_PARAM = ALGORITHM_QUERY_PARAM; +exports.ALWAYS_UNSIGNABLE_HEADERS = ALWAYS_UNSIGNABLE_HEADERS; +exports.AMZ_DATE_HEADER = AMZ_DATE_HEADER; +exports.AMZ_DATE_QUERY_PARAM = AMZ_DATE_QUERY_PARAM; +exports.AUTH_HEADER = AUTH_HEADER; +exports.CREDENTIAL_QUERY_PARAM = CREDENTIAL_QUERY_PARAM; +exports.DATE_HEADER = DATE_HEADER; +exports.EVENT_ALGORITHM_IDENTIFIER = EVENT_ALGORITHM_IDENTIFIER; +exports.EXPIRES_QUERY_PARAM = EXPIRES_QUERY_PARAM; +exports.GENERATED_HEADERS = GENERATED_HEADERS; +exports.HOST_HEADER = HOST_HEADER; +exports.KEY_TYPE_IDENTIFIER = KEY_TYPE_IDENTIFIER; +exports.MAX_CACHE_SIZE = MAX_CACHE_SIZE; +exports.MAX_PRESIGNED_TTL = MAX_PRESIGNED_TTL; +exports.PROXY_HEADER_PATTERN = PROXY_HEADER_PATTERN; +exports.REGION_SET_PARAM = REGION_SET_PARAM; +exports.SEC_HEADER_PATTERN = SEC_HEADER_PATTERN; +exports.SHA256_HEADER = SHA256_HEADER; +exports.SIGNATURE_HEADER = SIGNATURE_HEADER; +exports.SIGNATURE_QUERY_PARAM = SIGNATURE_QUERY_PARAM; +exports.SIGNED_HEADERS_QUERY_PARAM = SIGNED_HEADERS_QUERY_PARAM; +exports.SignatureV4 = SignatureV4; +exports.SignatureV4Base = SignatureV4Base; +exports.TOKEN_HEADER = TOKEN_HEADER; +exports.TOKEN_QUERY_PARAM = TOKEN_QUERY_PARAM; +exports.UNSIGNABLE_PATTERNS = UNSIGNABLE_PATTERNS; +exports.UNSIGNED_PAYLOAD = UNSIGNED_PAYLOAD; +exports.clearCredentialCache = clearCredentialCache; +exports.createScope = createScope; +exports.getCanonicalHeaders = getCanonicalHeaders; +exports.getCanonicalQuery = getCanonicalQuery; +exports.getPayloadHash = getPayloadHash; +exports.getSigningKey = getSigningKey; +exports.hasHeader = hasHeader; +exports.moveHeadersToQuery = moveHeadersToQuery; +exports.prepareRequest = prepareRequest; +exports.signatureV4aContainer = signatureV4aContainer; - } else if (ch === 0x23/* # */) { - preceding = state.input.charCodeAt(state.position - 1); - if (is_WS_OR_EOL(preceding)) { - break; - } +/***/ }), - } else if ((state.position === state.lineStart && testDocumentSeparator(state)) || - withinFlowCollection && is_FLOW_INDICATOR(ch)) { - break; +/***/ 1411: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - } else if (is_EOL(ch)) { - _line = state.line; - _lineStart = state.lineStart; - _lineIndent = state.lineIndent; - skipSeparationSpace(state, false, -1); +"use strict"; - if (state.lineIndent >= nodeIndent) { - hasPendingContent = true; - ch = state.input.charCodeAt(state.position); - continue; - } else { - state.position = captureEnd; - state.line = _line; - state.lineStart = _lineStart; - state.lineIndent = _lineIndent; - break; - } + +var middlewareStack = __nccwpck_require__(9208); +var protocols = __nccwpck_require__(3422); +var types = __nccwpck_require__(690); +var schema = __nccwpck_require__(6890); +var serde = __nccwpck_require__(2430); + +class Client { + config; + middlewareStack = middlewareStack.constructStack(); + initConfig; + handlers; + constructor(config) { + this.config = config; + const { protocol, protocolSettings } = config; + if (protocolSettings) { + if (typeof protocol === "function") { + config.protocol = new protocol(protocolSettings); + } + } + } + send(command, optionsOrCb, cb) { + const options = typeof optionsOrCb !== "function" ? optionsOrCb : undefined; + const callback = typeof optionsOrCb === "function" ? optionsOrCb : cb; + const useHandlerCache = options === undefined && this.config.cacheMiddleware === true; + let handler; + if (useHandlerCache) { + if (!this.handlers) { + this.handlers = new WeakMap(); + } + const handlers = this.handlers; + if (handlers.has(command.constructor)) { + handler = handlers.get(command.constructor); + } + else { + handler = command.resolveMiddleware(this.middlewareStack, this.config, options); + handlers.set(command.constructor, handler); + } + } + else { + delete this.handlers; + handler = command.resolveMiddleware(this.middlewareStack, this.config, options); + } + if (callback) { + handler(command) + .then((result) => callback(null, result.output), (err) => callback(err)) + .catch(() => { }); + } + else { + return handler(command).then((result) => result.output); + } + } + destroy() { + this.config?.requestHandler?.destroy?.(); + delete this.handlers; } +} - if (hasPendingContent) { - captureSegment(state, captureStart, captureEnd, false); - writeFoldedLines(state, state.line - _line); - captureStart = captureEnd = state.position; - hasPendingContent = false; +const SENSITIVE_STRING$1 = "***SensitiveInformation***"; +function schemaLogFilter(schema$1, data) { + if (data == null) { + return data; + } + const ns = schema.NormalizedSchema.of(schema$1); + if (ns.getMergedTraits().sensitive) { + return SENSITIVE_STRING$1; + } + if (ns.isListSchema()) { + const isSensitive = !!ns.getValueSchema().getMergedTraits().sensitive; + if (isSensitive) { + return SENSITIVE_STRING$1; + } + } + else if (ns.isMapSchema()) { + const isSensitive = !!ns.getKeySchema().getMergedTraits().sensitive || !!ns.getValueSchema().getMergedTraits().sensitive; + if (isSensitive) { + return SENSITIVE_STRING$1; + } + } + else if (ns.isStructSchema() && typeof data === "object") { + const object = data; + const newObject = {}; + for (const [member, memberNs] of ns.structIterator()) { + if (object[member] != null) { + newObject[member] = schemaLogFilter(memberNs, object[member]); + } + } + return newObject; } + return data; +} - if (!is_WHITE_SPACE(ch)) { - captureEnd = state.position + 1; +class Command { + middlewareStack = middlewareStack.constructStack(); + schema; + static classBuilder() { + return new ClassBuilder(); + } + resolveMiddlewareWithContext(clientStack, configuration, options, { middlewareFn, clientName, commandName, inputFilterSensitiveLog, outputFilterSensitiveLog, smithyContext, additionalContext, CommandCtor, }) { + for (const mw of middlewareFn.bind(this)(CommandCtor, clientStack, configuration, options)) { + this.middlewareStack.use(mw); + } + const stack = clientStack.concat(this.middlewareStack); + const { logger } = configuration; + const handlerExecutionContext = { + logger, + clientName, + commandName, + inputFilterSensitiveLog, + outputFilterSensitiveLog, + [types.SMITHY_CONTEXT_KEY]: { + commandInstance: this, + ...smithyContext, + }, + ...additionalContext, + }; + const { requestHandler } = configuration; + return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); + } +} +class ClassBuilder { + _init = () => { }; + _ep = {}; + _middlewareFn = () => []; + _commandName = ""; + _clientName = ""; + _additionalContext = {}; + _smithyContext = {}; + _inputFilterSensitiveLog = undefined; + _outputFilterSensitiveLog = undefined; + _serializer = null; + _deserializer = null; + _operationSchema; + init(cb) { + this._init = cb; + } + ep(endpointParameterInstructions) { + this._ep = endpointParameterInstructions; + return this; + } + m(middlewareSupplier) { + this._middlewareFn = middlewareSupplier; + return this; + } + s(service, operation, smithyContext = {}) { + this._smithyContext = { + service, + operation, + ...smithyContext, + }; + return this; + } + c(additionalContext = {}) { + this._additionalContext = additionalContext; + return this; + } + n(clientName, commandName) { + this._clientName = clientName; + this._commandName = commandName; + return this; + } + f(inputFilter = (_) => _, outputFilter = (_) => _) { + this._inputFilterSensitiveLog = inputFilter; + this._outputFilterSensitiveLog = outputFilter; + return this; + } + ser(serializer) { + this._serializer = serializer; + return this; + } + de(deserializer) { + this._deserializer = deserializer; + return this; + } + sc(operation) { + this._operationSchema = operation; + this._smithyContext.operationSchema = operation; + return this; + } + build() { + const closure = this; + let CommandRef; + return (CommandRef = class extends Command { + input; + static getEndpointParameterInstructions() { + return closure._ep; + } + constructor(...[input]) { + super(); + this.input = input ?? {}; + closure._init(this); + this.schema = closure._operationSchema; + } + resolveMiddleware(stack, configuration, options) { + const op = closure._operationSchema; + const input = op?.[4] ?? op?.input; + const output = op?.[5] ?? op?.output; + return this.resolveMiddlewareWithContext(stack, configuration, options, { + CommandCtor: CommandRef, + middlewareFn: closure._middlewareFn, + clientName: closure._clientName, + commandName: closure._commandName, + inputFilterSensitiveLog: closure._inputFilterSensitiveLog ?? (op ? schemaLogFilter.bind(null, input) : (_) => _), + outputFilterSensitiveLog: closure._outputFilterSensitiveLog ?? (op ? schemaLogFilter.bind(null, output) : (_) => _), + smithyContext: closure._smithyContext, + additionalContext: closure._additionalContext, + }); + } + serialize = closure._serializer; + deserialize = closure._deserializer; + }); } +} - ch = state.input.charCodeAt(++state.position); - } +const SENSITIVE_STRING = "***SensitiveInformation***"; - captureSegment(state, captureStart, captureEnd, false); - - if (state.result) { - return true; - } +const createAggregatedClient = (commands, Client, options) => { + for (const [command, CommandCtor] of Object.entries(commands)) { + const methodImpl = async function (args, optionsOrCb, cb) { + const command = new CommandCtor(args); + if (typeof optionsOrCb === "function") { + this.send(command, optionsOrCb); + } + else if (typeof cb === "function") { + if (typeof optionsOrCb !== "object") + throw new Error(`Expected http options but got ${typeof optionsOrCb}`); + this.send(command, optionsOrCb || {}, cb); + } + else { + return this.send(command, optionsOrCb); + } + }; + const methodName = (command[0].toLowerCase() + command.slice(1)).replace(/Command$/, ""); + Client.prototype[methodName] = methodImpl; + } + const { paginators = {}, waiters = {} } = options ?? {}; + for (const [paginatorName, paginatorFn] of Object.entries(paginators)) { + if (Client.prototype[paginatorName] === void 0) { + Client.prototype[paginatorName] = function (commandInput = {}, paginationConfiguration, ...rest) { + return paginatorFn({ + ...paginationConfiguration, + client: this, + }, commandInput, ...rest); + }; + } + } + for (const [waiterName, waiterFn] of Object.entries(waiters)) { + if (Client.prototype[waiterName] === void 0) { + Client.prototype[waiterName] = async function (commandInput = {}, waiterConfiguration, ...rest) { + let config = waiterConfiguration; + if (typeof waiterConfiguration === "number") { + config = { + maxWaitTime: waiterConfiguration, + }; + } + return waiterFn({ + ...config, + client: this, + }, commandInput, ...rest); + }; + } + } +}; - state.kind = _kind; - state.result = _result; - return false; +class ServiceException extends Error { + $fault; + $response; + $retryable; + $metadata; + constructor(options) { + super(options.message); + Object.setPrototypeOf(this, Object.getPrototypeOf(this).constructor.prototype); + this.name = options.name; + this.$fault = options.$fault; + this.$metadata = options.$metadata; + } + static isInstance(value) { + if (!value) + return false; + const candidate = value; + return (ServiceException.prototype.isPrototypeOf(candidate) || + (Boolean(candidate.$fault) && + Boolean(candidate.$metadata) && + (candidate.$fault === "client" || candidate.$fault === "server"))); + } + static [Symbol.hasInstance](instance) { + if (!instance) + return false; + const candidate = instance; + if (this === ServiceException) { + return ServiceException.isInstance(instance); + } + if (ServiceException.isInstance(instance)) { + if (candidate.name && this.name) { + return this.prototype.isPrototypeOf(instance) || candidate.name === this.name; + } + return this.prototype.isPrototypeOf(instance); + } + return false; + } } +const decorateServiceException = (exception, additions = {}) => { + Object.entries(additions) + .filter(([, v]) => v !== undefined) + .forEach(([k, v]) => { + if (exception[k] == undefined || exception[k] === "") { + exception[k] = v; + } + }); + const message = exception.message || exception.Message || "UnknownError"; + exception.message = message; + delete exception.Message; + return exception; +}; -function readSingleQuotedScalar(state, nodeIndent) { - var ch, - captureStart, captureEnd; - - ch = state.input.charCodeAt(state.position); +const throwDefaultError = ({ output, parsedBody, exceptionCtor, errorCode }) => { + const $metadata = deserializeMetadata(output); + const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined; + const response = new exceptionCtor({ + name: parsedBody?.code || parsedBody?.Code || errorCode || statusCode || "UnknownError", + $fault: "client", + $metadata, + }); + throw decorateServiceException(response, parsedBody); +}; +const withBaseException = (ExceptionCtor) => { + return ({ output, parsedBody, errorCode }) => { + throwDefaultError({ output, parsedBody, exceptionCtor: ExceptionCtor, errorCode }); + }; +}; +const deserializeMetadata = (output) => ({ + httpStatusCode: output.statusCode, + requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"], + extendedRequestId: output.headers["x-amz-id-2"], + cfId: output.headers["x-amz-cf-id"], +}); - if (ch !== 0x27/* ' */) { - return false; - } +const loadConfigsForDefaultMode = (mode) => { + switch (mode) { + case "standard": + return { + retryMode: "standard", + connectionTimeout: 3100, + }; + case "in-region": + return { + retryMode: "standard", + connectionTimeout: 1100, + }; + case "cross-region": + return { + retryMode: "standard", + connectionTimeout: 3100, + }; + case "mobile": + return { + retryMode: "standard", + connectionTimeout: 30000, + }; + default: + return {}; + } +}; - state.kind = 'scalar'; - state.result = ''; - state.position++; - captureStart = captureEnd = state.position; +let warningEmitted = false; +const emitWarningIfUnsupportedVersion = (version) => { + if (version && !warningEmitted && parseInt(version.substring(1, version.indexOf("."))) < 16) { + warningEmitted = true; + } +}; - while ((ch = state.input.charCodeAt(state.position)) !== 0) { - if (ch === 0x27/* ' */) { - captureSegment(state, captureStart, state.position, true); - ch = state.input.charCodeAt(++state.position); +const getChecksumConfiguration = (runtimeConfig) => { + const checksumAlgorithms = []; + for (const id in types.AlgorithmId) { + const algorithmId = types.AlgorithmId[id]; + if (runtimeConfig[algorithmId] === undefined) { + continue; + } + checksumAlgorithms.push({ + algorithmId: () => algorithmId, + checksumConstructor: () => runtimeConfig[algorithmId], + }); + } + return { + addChecksumAlgorithm(algo) { + checksumAlgorithms.push(algo); + }, + checksumAlgorithms() { + return checksumAlgorithms; + }, + }; +}; +const resolveChecksumRuntimeConfig = (clientConfig) => { + const runtimeConfig = {}; + clientConfig.checksumAlgorithms().forEach((checksumAlgorithm) => { + runtimeConfig[checksumAlgorithm.algorithmId()] = checksumAlgorithm.checksumConstructor(); + }); + return runtimeConfig; +}; - if (ch === 0x27/* ' */) { - captureStart = state.position; - state.position++; - captureEnd = state.position; - } else { - return true; - } +const getRetryConfiguration = (runtimeConfig) => { + return { + setRetryStrategy(retryStrategy) { + runtimeConfig.retryStrategy = retryStrategy; + }, + retryStrategy() { + return runtimeConfig.retryStrategy; + }, + }; +}; +const resolveRetryRuntimeConfig = (retryStrategyConfiguration) => { + const runtimeConfig = {}; + runtimeConfig.retryStrategy = retryStrategyConfiguration.retryStrategy(); + return runtimeConfig; +}; - } else if (is_EOL(ch)) { - captureSegment(state, captureStart, captureEnd, true); - writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent)); - captureStart = captureEnd = state.position; +const getDefaultExtensionConfiguration = (runtimeConfig) => { + return Object.assign(getChecksumConfiguration(runtimeConfig), getRetryConfiguration(runtimeConfig)); +}; +const getDefaultClientConfiguration = getDefaultExtensionConfiguration; +const resolveDefaultRuntimeConfig = (config) => { + return Object.assign(resolveChecksumRuntimeConfig(config), resolveRetryRuntimeConfig(config)); +}; - } else if (state.position === state.lineStart && testDocumentSeparator(state)) { - throwError(state, 'unexpected end of the document within a single quoted scalar'); +const getArrayIfSingleItem = (mayBeArray) => Array.isArray(mayBeArray) ? mayBeArray : [mayBeArray]; - } else { - state.position++; - captureEnd = state.position; +const getValueFromTextNode = (obj) => { + const textNodeName = "#text"; + for (const key in obj) { + if (obj.hasOwnProperty(key) && obj[key][textNodeName] !== undefined) { + obj[key] = obj[key][textNodeName]; + } + else if (typeof obj[key] === "object" && obj[key] !== null) { + obj[key] = getValueFromTextNode(obj[key]); + } } - } + return obj; +}; - throwError(state, 'unexpected end of the stream within a single quoted scalar'); +const isSerializableHeaderValue = (value) => { + return value != null; +}; + +class NoOpLogger { + trace() { } + debug() { } + info() { } + warn() { } + error() { } } -function readDoubleQuotedScalar(state, nodeIndent) { - var captureStart, - captureEnd, - hexLength, - hexResult, - tmp, - ch; +function map(arg0, arg1, arg2) { + let target; + let filter; + let instructions; + if (typeof arg1 === "undefined" && typeof arg2 === "undefined") { + target = {}; + instructions = arg0; + } + else { + target = arg0; + if (typeof arg1 === "function") { + filter = arg1; + instructions = arg2; + return mapWithFilter(target, filter, instructions); + } + else { + instructions = arg1; + } + } + for (const key of Object.keys(instructions)) { + if (!Array.isArray(instructions[key])) { + target[key] = instructions[key]; + continue; + } + applyInstruction(target, null, instructions, key); + } + return target; +} +const convertMap = (target) => { + const output = {}; + for (const [k, v] of Object.entries(target || {})) { + output[k] = [, v]; + } + return output; +}; +const take = (source, instructions) => { + const out = {}; + for (const key in instructions) { + applyInstruction(out, source, instructions, key); + } + return out; +}; +const mapWithFilter = (target, filter, instructions) => { + return map(target, Object.entries(instructions).reduce((_instructions, [key, value]) => { + if (Array.isArray(value)) { + _instructions[key] = value; + } + else { + if (typeof value === "function") { + _instructions[key] = [filter, value()]; + } + else { + _instructions[key] = [filter, value]; + } + } + return _instructions; + }, {})); +}; +const applyInstruction = (target, source, instructions, targetKey) => { + if (source !== null) { + let instruction = instructions[targetKey]; + if (typeof instruction === "function") { + instruction = [, instruction]; + } + const [filter = nonNullish, valueFn = pass, sourceKey = targetKey] = instruction; + if ((typeof filter === "function" && filter(source[sourceKey])) || (typeof filter !== "function" && !!filter)) { + target[targetKey] = valueFn(source[sourceKey]); + } + return; + } + let [filter, value] = instructions[targetKey]; + if (typeof value === "function") { + let _value; + const defaultFilterPassed = filter === undefined && (_value = value()) != null; + const customFilterPassed = (typeof filter === "function" && !!filter(void 0)) || (typeof filter !== "function" && !!filter); + if (defaultFilterPassed) { + target[targetKey] = _value; + } + else if (customFilterPassed) { + target[targetKey] = value(); + } + } + else { + const defaultFilterPassed = filter === undefined && value != null; + const customFilterPassed = (typeof filter === "function" && !!filter(value)) || (typeof filter !== "function" && !!filter); + if (defaultFilterPassed || customFilterPassed) { + target[targetKey] = value; + } + } +}; +const nonNullish = (_) => _ != null; +const pass = (_) => _; + +const serializeFloat = (value) => { + if (value !== value) { + return "NaN"; + } + switch (value) { + case Infinity: + return "Infinity"; + case -Infinity: + return "-Infinity"; + default: + return value; + } +}; +const serializeDateTime = (date) => date.toISOString().replace(".000Z", "Z"); - ch = state.input.charCodeAt(state.position); +const _json = (obj) => { + if (obj == null) { + return {}; + } + if (Array.isArray(obj)) { + return obj.filter((_) => _ != null).map(_json); + } + if (typeof obj === "object") { + const target = {}; + for (const key of Object.keys(obj)) { + if (obj[key] == null) { + continue; + } + target[key] = _json(obj[key]); + } + return target; + } + return obj; +}; - if (ch !== 0x22/* " */) { - return false; - } +Object.defineProperty(exports, "collectBody", ({ + enumerable: true, + get: function () { return protocols.collectBody; } +})); +Object.defineProperty(exports, "extendedEncodeURIComponent", ({ + enumerable: true, + get: function () { return protocols.extendedEncodeURIComponent; } +})); +Object.defineProperty(exports, "resolvedPath", ({ + enumerable: true, + get: function () { return protocols.resolvedPath; } +})); +exports.Client = Client; +exports.Command = Command; +exports.NoOpLogger = NoOpLogger; +exports.SENSITIVE_STRING = SENSITIVE_STRING; +exports.ServiceException = ServiceException; +exports._json = _json; +exports.convertMap = convertMap; +exports.createAggregatedClient = createAggregatedClient; +exports.decorateServiceException = decorateServiceException; +exports.emitWarningIfUnsupportedVersion = emitWarningIfUnsupportedVersion; +exports.getArrayIfSingleItem = getArrayIfSingleItem; +exports.getDefaultClientConfiguration = getDefaultClientConfiguration; +exports.getDefaultExtensionConfiguration = getDefaultExtensionConfiguration; +exports.getValueFromTextNode = getValueFromTextNode; +exports.isSerializableHeaderValue = isSerializableHeaderValue; +exports.loadConfigsForDefaultMode = loadConfigsForDefaultMode; +exports.map = map; +exports.resolveDefaultRuntimeConfig = resolveDefaultRuntimeConfig; +exports.serializeDateTime = serializeDateTime; +exports.serializeFloat = serializeFloat; +exports.take = take; +exports.throwDefaultError = throwDefaultError; +exports.withBaseException = withBaseException; +Object.keys(serde).forEach(function (k) { + if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, { + enumerable: true, + get: function () { return serde[k]; } + }); +}); - state.kind = 'scalar'; - state.result = ''; - state.position++; - captureStart = captureEnd = state.position; - while ((ch = state.input.charCodeAt(state.position)) !== 0) { - if (ch === 0x22/* " */) { - captureSegment(state, captureStart, state.position, true); - state.position++; - return true; +/***/ }), - } else if (ch === 0x5C/* \ */) { - captureSegment(state, captureStart, state.position, true); - ch = state.input.charCodeAt(++state.position); +/***/ 690: +/***/ ((__unused_webpack_module, exports) => { - if (is_EOL(ch)) { - skipSeparationSpace(state, false, nodeIndent); +"use strict"; - // TODO: rework to inline fn with no type cast? - } else if (ch < 256 && simpleEscapeCheck[ch]) { - state.result += simpleEscapeMap[ch]; - state.position++; - } else if ((tmp = escapedHexLen(ch)) > 0) { - hexLength = tmp; - hexResult = 0; +exports.HttpAuthLocation = void 0; +(function (HttpAuthLocation) { + HttpAuthLocation["HEADER"] = "header"; + HttpAuthLocation["QUERY"] = "query"; +})(exports.HttpAuthLocation || (exports.HttpAuthLocation = {})); + +exports.HttpApiKeyAuthLocation = void 0; +(function (HttpApiKeyAuthLocation) { + HttpApiKeyAuthLocation["HEADER"] = "header"; + HttpApiKeyAuthLocation["QUERY"] = "query"; +})(exports.HttpApiKeyAuthLocation || (exports.HttpApiKeyAuthLocation = {})); + +exports.EndpointURLScheme = void 0; +(function (EndpointURLScheme) { + EndpointURLScheme["HTTP"] = "http"; + EndpointURLScheme["HTTPS"] = "https"; +})(exports.EndpointURLScheme || (exports.EndpointURLScheme = {})); + +exports.AlgorithmId = void 0; +(function (AlgorithmId) { + AlgorithmId["MD5"] = "md5"; + AlgorithmId["CRC32"] = "crc32"; + AlgorithmId["CRC32C"] = "crc32c"; + AlgorithmId["SHA1"] = "sha1"; + AlgorithmId["SHA256"] = "sha256"; +})(exports.AlgorithmId || (exports.AlgorithmId = {})); +const getChecksumConfiguration = (runtimeConfig) => { + const checksumAlgorithms = []; + if (runtimeConfig.sha256 !== undefined) { + checksumAlgorithms.push({ + algorithmId: () => exports.AlgorithmId.SHA256, + checksumConstructor: () => runtimeConfig.sha256, + }); + } + if (runtimeConfig.md5 != undefined) { + checksumAlgorithms.push({ + algorithmId: () => exports.AlgorithmId.MD5, + checksumConstructor: () => runtimeConfig.md5, + }); + } + return { + addChecksumAlgorithm(algo) { + checksumAlgorithms.push(algo); + }, + checksumAlgorithms() { + return checksumAlgorithms; + }, + }; +}; +const resolveChecksumRuntimeConfig = (clientConfig) => { + const runtimeConfig = {}; + clientConfig.checksumAlgorithms().forEach((checksumAlgorithm) => { + runtimeConfig[checksumAlgorithm.algorithmId()] = checksumAlgorithm.checksumConstructor(); + }); + return runtimeConfig; +}; - for (; hexLength > 0; hexLength--) { - ch = state.input.charCodeAt(++state.position); +const getDefaultClientConfiguration = (runtimeConfig) => { + return getChecksumConfiguration(runtimeConfig); +}; +const resolveDefaultRuntimeConfig = (config) => { + return resolveChecksumRuntimeConfig(config); +}; - if ((tmp = fromHexCode(ch)) >= 0) { - hexResult = (hexResult << 4) + tmp; +exports.FieldPosition = void 0; +(function (FieldPosition) { + FieldPosition[FieldPosition["HEADER"] = 0] = "HEADER"; + FieldPosition[FieldPosition["TRAILER"] = 1] = "TRAILER"; +})(exports.FieldPosition || (exports.FieldPosition = {})); - } else { - throwError(state, 'expected hexadecimal character'); - } - } +const SMITHY_CONTEXT_KEY = "__smithy_context"; - state.result += charFromCodepoint(hexResult); +exports.IniSectionType = void 0; +(function (IniSectionType) { + IniSectionType["PROFILE"] = "profile"; + IniSectionType["SSO_SESSION"] = "sso-session"; + IniSectionType["SERVICES"] = "services"; +})(exports.IniSectionType || (exports.IniSectionType = {})); - state.position++; +exports.RequestHandlerProtocol = void 0; +(function (RequestHandlerProtocol) { + RequestHandlerProtocol["HTTP_0_9"] = "http/0.9"; + RequestHandlerProtocol["HTTP_1_0"] = "http/1.0"; + RequestHandlerProtocol["TDS_8_0"] = "tds/8.0"; +})(exports.RequestHandlerProtocol || (exports.RequestHandlerProtocol = {})); - } else { - throwError(state, 'unknown escape sequence'); - } +exports.SMITHY_CONTEXT_KEY = SMITHY_CONTEXT_KEY; +exports.getDefaultClientConfiguration = getDefaultClientConfiguration; +exports.resolveDefaultRuntimeConfig = resolveDefaultRuntimeConfig; - captureStart = captureEnd = state.position; - } else if (is_EOL(ch)) { - captureSegment(state, captureStart, captureEnd, true); - writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent)); - captureStart = captureEnd = state.position; +/***/ }), - } else if (state.position === state.lineStart && testDocumentSeparator(state)) { - throwError(state, 'unexpected end of the document within a double quoted scalar'); +/***/ 4494: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - } else { - state.position++; - captureEnd = state.position; +"use strict"; + + +var querystringParser = __nccwpck_require__(8822); + +const parseUrl = (url) => { + if (typeof url === "string") { + return parseUrl(new URL(url)); } - } + const { hostname, pathname, port, protocol, search } = url; + let query; + if (search) { + query = querystringParser.parseQueryString(search); + } + return { + hostname, + port: port ? parseInt(port) : undefined, + protocol, + path: pathname, + query, + }; +}; - throwError(state, 'unexpected end of the stream within a double quoted scalar'); -} +exports.parseUrl = parseUrl; -function readFlowCollection(state, nodeIndent) { - var readNext = true, - _line, - _tag = state.tag, - _result, - _anchor = state.anchor, - following, - terminator, - isPair, - isExplicitPair, - isMapping, - overridableKeys = {}, - keyNode, - keyTag, - valueNode, - ch; - ch = state.input.charCodeAt(state.position); +/***/ }), - if (ch === 0x5B/* [ */) { - terminator = 0x5D;/* ] */ - isMapping = false; - _result = []; - } else if (ch === 0x7B/* { */) { - terminator = 0x7D;/* } */ - isMapping = true; - _result = {}; - } else { - return false; - } +/***/ 2674: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - if (state.anchor !== null) { - state.anchorMap[state.anchor] = _result; - } +"use strict"; - ch = state.input.charCodeAt(++state.position); +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.fromBase64 = void 0; +const util_buffer_from_1 = __nccwpck_require__(4151); +const BASE64_REGEX = /^[A-Za-z0-9+/]*={0,2}$/; +const fromBase64 = (input) => { + if ((input.length * 3) % 4 !== 0) { + throw new TypeError(`Incorrect padding on base64 string.`); + } + if (!BASE64_REGEX.exec(input)) { + throw new TypeError(`Invalid base64 string.`); + } + const buffer = (0, util_buffer_from_1.fromString)(input, "base64"); + return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength); +}; +exports.fromBase64 = fromBase64; - while (ch !== 0) { - skipSeparationSpace(state, true, nodeIndent); - ch = state.input.charCodeAt(state.position); +/***/ }), - if (ch === terminator) { - state.position++; - state.tag = _tag; - state.anchor = _anchor; - state.kind = isMapping ? 'mapping' : 'sequence'; - state.result = _result; - return true; - } else if (!readNext) { - throwError(state, 'missed comma between flow collection entries'); - } +/***/ 8385: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - keyTag = keyNode = valueNode = null; - isPair = isExplicitPair = false; +"use strict"; - if (ch === 0x3F/* ? */) { - following = state.input.charCodeAt(state.position + 1); - if (is_WS_OR_EOL(following)) { - isPair = isExplicitPair = true; - state.position++; - skipSeparationSpace(state, true, nodeIndent); - } - } +var fromBase64 = __nccwpck_require__(2674); +var toBase64 = __nccwpck_require__(4871); - _line = state.line; - composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true); - keyTag = state.tag; - keyNode = state.result; - skipSeparationSpace(state, true, nodeIndent); - ch = state.input.charCodeAt(state.position); - if ((isExplicitPair || state.line === _line) && ch === 0x3A/* : */) { - isPair = true; - ch = state.input.charCodeAt(++state.position); - skipSeparationSpace(state, true, nodeIndent); - composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true); - valueNode = state.result; - } +Object.keys(fromBase64).forEach(function (k) { + if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, { + enumerable: true, + get: function () { return fromBase64[k]; } + }); +}); +Object.keys(toBase64).forEach(function (k) { + if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, { + enumerable: true, + get: function () { return toBase64[k]; } + }); +}); - if (isMapping) { - storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode); - } else if (isPair) { - _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode)); - } else { - _result.push(keyNode); - } - skipSeparationSpace(state, true, nodeIndent); +/***/ }), - ch = state.input.charCodeAt(state.position); +/***/ 4871: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - if (ch === 0x2C/* , */) { - readNext = true; - ch = state.input.charCodeAt(++state.position); - } else { - readNext = false; +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.toBase64 = void 0; +const util_buffer_from_1 = __nccwpck_require__(4151); +const util_utf8_1 = __nccwpck_require__(1577); +const toBase64 = (_input) => { + let input; + if (typeof _input === "string") { + input = (0, util_utf8_1.fromUtf8)(_input); } - } + else { + input = _input; + } + if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") { + throw new Error("@smithy/util-base64: toBase64 encoder function only accepts string | Uint8Array."); + } + return (0, util_buffer_from_1.fromArrayBuffer)(input.buffer, input.byteOffset, input.byteLength).toString("base64"); +}; +exports.toBase64 = toBase64; - throwError(state, 'unexpected end of the stream within a flow collection'); -} -function readBlockScalar(state, nodeIndent) { - var captureStart, - folding, - chomping = CHOMPING_CLIP, - didReadContent = false, - detectedIndent = false, - textIndent = nodeIndent, - emptyLines = 0, - atMoreIndented = false, - tmp, - ch; +/***/ }), - ch = state.input.charCodeAt(state.position); +/***/ 2098: +/***/ ((__unused_webpack_module, exports) => { - if (ch === 0x7C/* | */) { - folding = false; - } else if (ch === 0x3E/* > */) { - folding = true; - } else { - return false; - } +"use strict"; - state.kind = 'scalar'; - state.result = ''; - while (ch !== 0) { - ch = state.input.charCodeAt(++state.position); +const TEXT_ENCODER = typeof TextEncoder == "function" ? new TextEncoder() : null; +const calculateBodyLength = (body) => { + if (typeof body === "string") { + if (TEXT_ENCODER) { + return TEXT_ENCODER.encode(body).byteLength; + } + let len = body.length; + for (let i = len - 1; i >= 0; i--) { + const code = body.charCodeAt(i); + if (code > 0x7f && code <= 0x7ff) + len++; + else if (code > 0x7ff && code <= 0xffff) + len += 2; + if (code >= 0xdc00 && code <= 0xdfff) + i--; + } + return len; + } + else if (typeof body.byteLength === "number") { + return body.byteLength; + } + else if (typeof body.size === "number") { + return body.size; + } + throw new Error(`Body Length computation failed for ${body}`); +}; - if (ch === 0x2B/* + */ || ch === 0x2D/* - */) { - if (CHOMPING_CLIP === chomping) { - chomping = (ch === 0x2B/* + */) ? CHOMPING_KEEP : CHOMPING_STRIP; - } else { - throwError(state, 'repeat of a chomping mode identifier'); - } +exports.calculateBodyLength = calculateBodyLength; - } else if ((tmp = fromDecimalCode(ch)) >= 0) { - if (tmp === 0) { - throwError(state, 'bad explicit indentation width of a block scalar; it cannot be less than one'); - } else if (!detectedIndent) { - textIndent = nodeIndent + tmp - 1; - detectedIndent = true; - } else { - throwError(state, 'repeat of an indentation width identifier'); - } - } else { - break; - } - } +/***/ }), - if (is_WHITE_SPACE(ch)) { - do { ch = state.input.charCodeAt(++state.position); } - while (is_WHITE_SPACE(ch)); +/***/ 3638: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - if (ch === 0x23/* # */) { - do { ch = state.input.charCodeAt(++state.position); } - while (!is_EOL(ch) && (ch !== 0)); - } - } +"use strict"; - while (ch !== 0) { - readLineBreak(state); - state.lineIndent = 0; - ch = state.input.charCodeAt(state.position); +var node_fs = __nccwpck_require__(3024); - while ((!detectedIndent || state.lineIndent < textIndent) && - (ch === 0x20/* Space */)) { - state.lineIndent++; - ch = state.input.charCodeAt(++state.position); +const calculateBodyLength = (body) => { + if (!body) { + return 0; } - - if (!detectedIndent && state.lineIndent > textIndent) { - textIndent = state.lineIndent; + if (typeof body === "string") { + return Buffer.byteLength(body); } - - if (is_EOL(ch)) { - emptyLines++; - continue; + else if (typeof body.byteLength === "number") { + return body.byteLength; } - - // End of the scalar. - if (state.lineIndent < textIndent) { - - // Perform the chomping. - if (chomping === CHOMPING_KEEP) { - state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines); - } else if (chomping === CHOMPING_CLIP) { - if (didReadContent) { // i.e. only if the scalar is not empty. - state.result += '\n'; + else if (typeof body.size === "number") { + return body.size; + } + else if (typeof body.start === "number" && typeof body.end === "number") { + return body.end + 1 - body.start; + } + else if (body instanceof node_fs.ReadStream) { + if (body.path != null) { + return node_fs.lstatSync(body.path).size; + } + else if (typeof body.fd === "number") { + return node_fs.fstatSync(body.fd).size; } - } - - // Break this `while` cycle and go to the funciton's epilogue. - break; } + throw new Error(`Body Length computation failed for ${body}`); +}; - // Folded style: use fancy rules to handle line breaks. - if (folding) { +exports.calculateBodyLength = calculateBodyLength; - // Lines starting with white space characters (more-indented lines) are not folded. - if (is_WHITE_SPACE(ch)) { - atMoreIndented = true; - // except for the first content line (cf. Example 8.1) - state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines); - // End of more-indented block. - } else if (atMoreIndented) { - atMoreIndented = false; - state.result += common.repeat('\n', emptyLines + 1); +/***/ }), - // Just one line break - perceive as the same line. - } else if (emptyLines === 0) { - if (didReadContent) { // i.e. only if we have already read some scalar content. - state.result += ' '; - } +/***/ 4151: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - // Several line breaks - perceive as different lines. - } else { - state.result += common.repeat('\n', emptyLines); - } +"use strict"; - // Literal style: just add exact number of line breaks between content lines. - } else { - // Keep all line breaks except the header line break. - state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines); - } - didReadContent = true; - detectedIndent = true; - emptyLines = 0; - captureStart = state.position; +var isArrayBuffer = __nccwpck_require__(6130); +var buffer = __nccwpck_require__(181); - while (!is_EOL(ch) && (ch !== 0)) { - ch = state.input.charCodeAt(++state.position); +const fromArrayBuffer = (input, offset = 0, length = input.byteLength - offset) => { + if (!isArrayBuffer.isArrayBuffer(input)) { + throw new TypeError(`The "input" argument must be ArrayBuffer. Received type ${typeof input} (${input})`); + } + return buffer.Buffer.from(input, offset, length); +}; +const fromString = (input, encoding) => { + if (typeof input !== "string") { + throw new TypeError(`The "input" argument must be of type string. Received type ${typeof input} (${input})`); } + return encoding ? buffer.Buffer.from(input, encoding) : buffer.Buffer.from(input); +}; - captureSegment(state, captureStart, state.position, false); - } +exports.fromArrayBuffer = fromArrayBuffer; +exports.fromString = fromString; - return true; -} -function readBlockSequence(state, nodeIndent) { - var _line, - _tag = state.tag, - _anchor = state.anchor, - _result = [], - following, - detected = false, - ch; +/***/ }), - if (state.anchor !== null) { - state.anchorMap[state.anchor] = _result; - } +/***/ 6716: +/***/ ((__unused_webpack_module, exports) => { - ch = state.input.charCodeAt(state.position); +"use strict"; - while (ch !== 0) { - if (ch !== 0x2D/* - */) { - break; +const booleanSelector = (obj, key, type) => { + if (!(key in obj)) + return undefined; + if (obj[key] === "true") + return true; + if (obj[key] === "false") + return false; + throw new Error(`Cannot load ${type} "${key}". Expected "true" or "false", got ${obj[key]}.`); +}; + +const numberSelector = (obj, key, type) => { + if (!(key in obj)) + return undefined; + const numberValue = parseInt(obj[key], 10); + if (Number.isNaN(numberValue)) { + throw new TypeError(`Cannot load ${type} '${key}'. Expected number, got '${obj[key]}'.`); } + return numberValue; +}; - following = state.input.charCodeAt(state.position + 1); +exports.SelectorType = void 0; +(function (SelectorType) { + SelectorType["ENV"] = "env"; + SelectorType["CONFIG"] = "shared config entry"; +})(exports.SelectorType || (exports.SelectorType = {})); - if (!is_WS_OR_EOL(following)) { - break; - } +exports.booleanSelector = booleanSelector; +exports.numberSelector = numberSelector; - detected = true; - state.position++; - if (skipSeparationSpace(state, true, -1)) { - if (state.lineIndent <= nodeIndent) { - _result.push(null); - ch = state.input.charCodeAt(state.position); - continue; - } - } +/***/ }), - _line = state.line; - composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true); - _result.push(state.result); - skipSeparationSpace(state, true, -1); +/***/ 5435: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - ch = state.input.charCodeAt(state.position); +"use strict"; - if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) { - throwError(state, 'bad indentation of a sequence entry'); - } else if (state.lineIndent < nodeIndent) { - break; - } - } - if (detected) { - state.tag = _tag; - state.anchor = _anchor; - state.kind = 'sequence'; - state.result = _result; - return true; - } - return false; -} +var configResolver = __nccwpck_require__(9316); +var nodeConfigProvider = __nccwpck_require__(5704); +var propertyProvider = __nccwpck_require__(8857); -function readBlockMapping(state, nodeIndent, flowIndent) { - var following, - allowCompact, - _line, - _pos, - _tag = state.tag, - _anchor = state.anchor, - _result = {}, - overridableKeys = {}, - keyTag = null, - keyNode = null, - valueNode = null, - atExplicitKey = false, - detected = false, - ch; +const AWS_EXECUTION_ENV = "AWS_EXECUTION_ENV"; +const AWS_REGION_ENV = "AWS_REGION"; +const AWS_DEFAULT_REGION_ENV = "AWS_DEFAULT_REGION"; +const ENV_IMDS_DISABLED = "AWS_EC2_METADATA_DISABLED"; +const DEFAULTS_MODE_OPTIONS = ["in-region", "cross-region", "mobile", "standard", "legacy"]; +const IMDS_REGION_PATH = "/latest/meta-data/placement/region"; - if (state.anchor !== null) { - state.anchorMap[state.anchor] = _result; - } +const AWS_DEFAULTS_MODE_ENV = "AWS_DEFAULTS_MODE"; +const AWS_DEFAULTS_MODE_CONFIG = "defaults_mode"; +const NODE_DEFAULTS_MODE_CONFIG_OPTIONS = { + environmentVariableSelector: (env) => { + return env[AWS_DEFAULTS_MODE_ENV]; + }, + configFileSelector: (profile) => { + return profile[AWS_DEFAULTS_MODE_CONFIG]; + }, + default: "legacy", +}; - ch = state.input.charCodeAt(state.position); +const resolveDefaultsModeConfig = ({ region = nodeConfigProvider.loadConfig(configResolver.NODE_REGION_CONFIG_OPTIONS), defaultsMode = nodeConfigProvider.loadConfig(NODE_DEFAULTS_MODE_CONFIG_OPTIONS), } = {}) => propertyProvider.memoize(async () => { + const mode = typeof defaultsMode === "function" ? await defaultsMode() : defaultsMode; + switch (mode?.toLowerCase()) { + case "auto": + return resolveNodeDefaultsModeAuto(region); + case "in-region": + case "cross-region": + case "mobile": + case "standard": + case "legacy": + return Promise.resolve(mode?.toLocaleLowerCase()); + case undefined: + return Promise.resolve("legacy"); + default: + throw new Error(`Invalid parameter for "defaultsMode", expect ${DEFAULTS_MODE_OPTIONS.join(", ")}, got ${mode}`); + } +}); +const resolveNodeDefaultsModeAuto = async (clientRegion) => { + if (clientRegion) { + const resolvedRegion = typeof clientRegion === "function" ? await clientRegion() : clientRegion; + const inferredRegion = await inferPhysicalRegion(); + if (!inferredRegion) { + return "standard"; + } + if (resolvedRegion === inferredRegion) { + return "in-region"; + } + else { + return "cross-region"; + } + } + return "standard"; +}; +const inferPhysicalRegion = async () => { + if (process.env[AWS_EXECUTION_ENV] && (process.env[AWS_REGION_ENV] || process.env[AWS_DEFAULT_REGION_ENV])) { + return process.env[AWS_REGION_ENV] ?? process.env[AWS_DEFAULT_REGION_ENV]; + } + if (!process.env[ENV_IMDS_DISABLED]) { + try { + const { getInstanceMetadataEndpoint, httpRequest } = await __nccwpck_require__.e(/* import() */ 566).then(__nccwpck_require__.t.bind(__nccwpck_require__, 566, 19)); + const endpoint = await getInstanceMetadataEndpoint(); + return (await httpRequest({ ...endpoint, path: IMDS_REGION_PATH })).toString(); + } + catch (e) { + } + } +}; - while (ch !== 0) { - following = state.input.charCodeAt(state.position + 1); - _line = state.line; // Save the current line. - _pos = state.position; +exports.resolveDefaultsModeConfig = resolveDefaultsModeConfig; - // - // Explicit notation case. There are two separate blocks: - // first for the key (denoted by "?") and second for the value (denoted by ":") - // - if ((ch === 0x3F/* ? */ || ch === 0x3A/* : */) && is_WS_OR_EOL(following)) { - if (ch === 0x3F/* ? */) { - if (atExplicitKey) { - storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null); - keyTag = keyNode = valueNode = null; - } +/***/ }), - detected = true; - atExplicitKey = true; - allowCompact = true; +/***/ 9674: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - } else if (atExplicitKey) { - // i.e. 0x3A/* : */ === character after the explicit key. - atExplicitKey = false; - allowCompact = true; +"use strict"; - } else { - throwError(state, 'incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line'); - } - state.position += 1; - ch = following; +var types = __nccwpck_require__(690); - // - // Implicit notation case. Flow-style node as the key first, then ":", and the value. - // - } else if (composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) { +class EndpointCache { + capacity; + data = new Map(); + parameters = []; + constructor({ size, params }) { + this.capacity = size ?? 50; + if (params) { + this.parameters = params; + } + } + get(endpointParams, resolver) { + const key = this.hash(endpointParams); + if (key === false) { + return resolver(); + } + if (!this.data.has(key)) { + if (this.data.size > this.capacity + 10) { + const keys = this.data.keys(); + let i = 0; + while (true) { + const { value, done } = keys.next(); + this.data.delete(value); + if (done || ++i > 10) { + break; + } + } + } + this.data.set(key, resolver()); + } + return this.data.get(key); + } + size() { + return this.data.size; + } + hash(endpointParams) { + let buffer = ""; + const { parameters } = this; + if (parameters.length === 0) { + return false; + } + for (const param of parameters) { + const val = String(endpointParams[param] ?? ""); + if (val.includes("|;")) { + return false; + } + buffer += val + "|;"; + } + return buffer; + } +} - if (state.line === _line) { - ch = state.input.charCodeAt(state.position); +const IP_V4_REGEX = new RegExp(`^(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}$`); +const isIpAddress = (value) => IP_V4_REGEX.test(value) || (value.startsWith("[") && value.endsWith("]")); - while (is_WHITE_SPACE(ch)) { - ch = state.input.charCodeAt(++state.position); +const VALID_HOST_LABEL_REGEX = new RegExp(`^(?!.*-$)(?!-)[a-zA-Z0-9-]{1,63}$`); +const isValidHostLabel = (value, allowSubDomains = false) => { + if (!allowSubDomains) { + return VALID_HOST_LABEL_REGEX.test(value); + } + const labels = value.split("."); + for (const label of labels) { + if (!isValidHostLabel(label)) { + return false; } + } + return true; +}; - if (ch === 0x3A/* : */) { - ch = state.input.charCodeAt(++state.position); +const customEndpointFunctions = {}; - if (!is_WS_OR_EOL(ch)) { - throwError(state, 'a whitespace character is expected after the key-value separator within a block mapping'); - } +const debugId = "endpoints"; - if (atExplicitKey) { - storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null); - keyTag = keyNode = valueNode = null; - } +function toDebugString(input) { + if (typeof input !== "object" || input == null) { + return input; + } + if ("ref" in input) { + return `$${toDebugString(input.ref)}`; + } + if ("fn" in input) { + return `${input.fn}(${(input.argv || []).map(toDebugString).join(", ")})`; + } + return JSON.stringify(input, null, 2); +} - detected = true; - atExplicitKey = false; - allowCompact = false; - keyTag = state.tag; - keyNode = state.result; +class EndpointError extends Error { + constructor(message) { + super(message); + this.name = "EndpointError"; + } +} - } else if (detected) { - throwError(state, 'can not read an implicit mapping pair; a colon is missed'); +const booleanEquals = (value1, value2) => value1 === value2; - } else { - state.tag = _tag; - state.anchor = _anchor; - return true; // Keep the result of `composeNode`. +const getAttrPathList = (path) => { + const parts = path.split("."); + const pathList = []; + for (const part of parts) { + const squareBracketIndex = part.indexOf("["); + if (squareBracketIndex !== -1) { + if (part.indexOf("]") !== part.length - 1) { + throw new EndpointError(`Path: '${path}' does not end with ']'`); + } + const arrayIndex = part.slice(squareBracketIndex + 1, -1); + if (Number.isNaN(parseInt(arrayIndex))) { + throw new EndpointError(`Invalid array index: '${arrayIndex}' in path: '${path}'`); + } + if (squareBracketIndex !== 0) { + pathList.push(part.slice(0, squareBracketIndex)); + } + pathList.push(arrayIndex); + } + else { + pathList.push(part); } + } + return pathList; +}; - } else if (detected) { - throwError(state, 'can not read a block mapping entry; a multiline key may not be an implicit key'); +const getAttr = (value, path) => getAttrPathList(path).reduce((acc, index) => { + if (typeof acc !== "object") { + throw new EndpointError(`Index '${index}' in '${path}' not found in '${JSON.stringify(value)}'`); + } + else if (Array.isArray(acc)) { + return acc[parseInt(index)]; + } + return acc[index]; +}, value); - } else { - state.tag = _tag; - state.anchor = _anchor; - return true; // Keep the result of `composeNode`. - } +const isSet = (value) => value != null; - } else { - break; // Reading is done. Go to the epilogue. - } +const not = (value) => !value; - // - // Common reading code for both explicit and implicit notations. - // - if (state.line === _line || state.lineIndent > nodeIndent) { - if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) { - if (atExplicitKey) { - keyNode = state.result; - } else { - valueNode = state.result; +const DEFAULT_PORTS = { + [types.EndpointURLScheme.HTTP]: 80, + [types.EndpointURLScheme.HTTPS]: 443, +}; +const parseURL = (value) => { + const whatwgURL = (() => { + try { + if (value instanceof URL) { + return value; + } + if (typeof value === "object" && "hostname" in value) { + const { hostname, port, protocol = "", path = "", query = {} } = value; + const url = new URL(`${protocol}//${hostname}${port ? `:${port}` : ""}${path}`); + url.search = Object.entries(query) + .map(([k, v]) => `${k}=${v}`) + .join("&"); + return url; + } + return new URL(value); } - } + catch (error) { + return null; + } + })(); + if (!whatwgURL) { + console.error(`Unable to parse ${JSON.stringify(value)} as a whatwg URL.`); + return null; + } + const urlString = whatwgURL.href; + const { host, hostname, pathname, protocol, search } = whatwgURL; + if (search) { + return null; + } + const scheme = protocol.slice(0, -1); + if (!Object.values(types.EndpointURLScheme).includes(scheme)) { + return null; + } + const isIp = isIpAddress(hostname); + const inputContainsDefaultPort = urlString.includes(`${host}:${DEFAULT_PORTS[scheme]}`) || + (typeof value === "string" && value.includes(`${host}:${DEFAULT_PORTS[scheme]}`)); + const authority = `${host}${inputContainsDefaultPort ? `:${DEFAULT_PORTS[scheme]}` : ``}`; + return { + scheme, + authority, + path: pathname, + normalizedPath: pathname.endsWith("/") ? pathname : `${pathname}/`, + isIp, + }; +}; - if (!atExplicitKey) { - storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _pos); - keyTag = keyNode = valueNode = null; - } +const stringEquals = (value1, value2) => value1 === value2; - skipSeparationSpace(state, true, -1); - ch = state.input.charCodeAt(state.position); +const substring = (input, start, stop, reverse) => { + if (start >= stop || input.length < stop) { + return null; } - - if (state.lineIndent > nodeIndent && (ch !== 0)) { - throwError(state, 'bad indentation of a mapping entry'); - } else if (state.lineIndent < nodeIndent) { - break; + if (!reverse) { + return input.substring(start, stop); } - } + return input.substring(input.length - stop, input.length - start); +}; - // - // Epilogue. - // +const uriEncode = (value) => encodeURIComponent(value).replace(/[!*'()]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`); + +const endpointFunctions = { + booleanEquals, + getAttr, + isSet, + isValidHostLabel, + not, + parseURL, + stringEquals, + substring, + uriEncode, +}; - // Special case: last mapping's node contains only the key in explicit notation. - if (atExplicitKey) { - storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null); - } +const evaluateTemplate = (template, options) => { + const evaluatedTemplateArr = []; + const templateContext = { + ...options.endpointParams, + ...options.referenceRecord, + }; + let currentIndex = 0; + while (currentIndex < template.length) { + const openingBraceIndex = template.indexOf("{", currentIndex); + if (openingBraceIndex === -1) { + evaluatedTemplateArr.push(template.slice(currentIndex)); + break; + } + evaluatedTemplateArr.push(template.slice(currentIndex, openingBraceIndex)); + const closingBraceIndex = template.indexOf("}", openingBraceIndex); + if (closingBraceIndex === -1) { + evaluatedTemplateArr.push(template.slice(openingBraceIndex)); + break; + } + if (template[openingBraceIndex + 1] === "{" && template[closingBraceIndex + 1] === "}") { + evaluatedTemplateArr.push(template.slice(openingBraceIndex + 1, closingBraceIndex)); + currentIndex = closingBraceIndex + 2; + } + const parameterName = template.substring(openingBraceIndex + 1, closingBraceIndex); + if (parameterName.includes("#")) { + const [refName, attrName] = parameterName.split("#"); + evaluatedTemplateArr.push(getAttr(templateContext[refName], attrName)); + } + else { + evaluatedTemplateArr.push(templateContext[parameterName]); + } + currentIndex = closingBraceIndex + 1; + } + return evaluatedTemplateArr.join(""); +}; - // Expose the resulting mapping. - if (detected) { - state.tag = _tag; - state.anchor = _anchor; - state.kind = 'mapping'; - state.result = _result; - } +const getReferenceValue = ({ ref }, options) => { + const referenceRecord = { + ...options.endpointParams, + ...options.referenceRecord, + }; + return referenceRecord[ref]; +}; - return detected; -} +const evaluateExpression = (obj, keyName, options) => { + if (typeof obj === "string") { + return evaluateTemplate(obj, options); + } + else if (obj["fn"]) { + return group$2.callFunction(obj, options); + } + else if (obj["ref"]) { + return getReferenceValue(obj, options); + } + throw new EndpointError(`'${keyName}': ${String(obj)} is not a string, function or reference.`); +}; +const callFunction = ({ fn, argv }, options) => { + const evaluatedArgs = argv.map((arg) => ["boolean", "number"].includes(typeof arg) ? arg : group$2.evaluateExpression(arg, "arg", options)); + const fnSegments = fn.split("."); + if (fnSegments[0] in customEndpointFunctions && fnSegments[1] != null) { + return customEndpointFunctions[fnSegments[0]][fnSegments[1]](...evaluatedArgs); + } + return endpointFunctions[fn](...evaluatedArgs); +}; +const group$2 = { + evaluateExpression, + callFunction, +}; -function readTagProperty(state) { - var _position, - isVerbatim = false, - isNamed = false, - tagHandle, - tagName, - ch; +const evaluateCondition = ({ assign, ...fnArgs }, options) => { + if (assign && assign in options.referenceRecord) { + throw new EndpointError(`'${assign}' is already defined in Reference Record.`); + } + const value = callFunction(fnArgs, options); + options.logger?.debug?.(`${debugId} evaluateCondition: ${toDebugString(fnArgs)} = ${toDebugString(value)}`); + return { + result: value === "" ? true : !!value, + ...(assign != null && { toAssign: { name: assign, value } }), + }; +}; - ch = state.input.charCodeAt(state.position); +const evaluateConditions = (conditions = [], options) => { + const conditionsReferenceRecord = {}; + for (const condition of conditions) { + const { result, toAssign } = evaluateCondition(condition, { + ...options, + referenceRecord: { + ...options.referenceRecord, + ...conditionsReferenceRecord, + }, + }); + if (!result) { + return { result }; + } + if (toAssign) { + conditionsReferenceRecord[toAssign.name] = toAssign.value; + options.logger?.debug?.(`${debugId} assign: ${toAssign.name} := ${toDebugString(toAssign.value)}`); + } + } + return { result: true, referenceRecord: conditionsReferenceRecord }; +}; - if (ch !== 0x21/* ! */) return false; +const getEndpointHeaders = (headers, options) => Object.entries(headers).reduce((acc, [headerKey, headerVal]) => ({ + ...acc, + [headerKey]: headerVal.map((headerValEntry) => { + const processedExpr = evaluateExpression(headerValEntry, "Header value entry", options); + if (typeof processedExpr !== "string") { + throw new EndpointError(`Header '${headerKey}' value '${processedExpr}' is not a string`); + } + return processedExpr; + }), +}), {}); + +const getEndpointProperties = (properties, options) => Object.entries(properties).reduce((acc, [propertyKey, propertyVal]) => ({ + ...acc, + [propertyKey]: group$1.getEndpointProperty(propertyVal, options), +}), {}); +const getEndpointProperty = (property, options) => { + if (Array.isArray(property)) { + return property.map((propertyEntry) => getEndpointProperty(propertyEntry, options)); + } + switch (typeof property) { + case "string": + return evaluateTemplate(property, options); + case "object": + if (property === null) { + throw new EndpointError(`Unexpected endpoint property: ${property}`); + } + return group$1.getEndpointProperties(property, options); + case "boolean": + return property; + default: + throw new EndpointError(`Unexpected endpoint property type: ${typeof property}`); + } +}; +const group$1 = { + getEndpointProperty, + getEndpointProperties, +}; - if (state.tag !== null) { - throwError(state, 'duplication of a tag property'); - } +const getEndpointUrl = (endpointUrl, options) => { + const expression = evaluateExpression(endpointUrl, "Endpoint URL", options); + if (typeof expression === "string") { + try { + return new URL(expression); + } + catch (error) { + console.error(`Failed to construct URL with ${expression}`, error); + throw error; + } + } + throw new EndpointError(`Endpoint URL must be a string, got ${typeof expression}`); +}; - ch = state.input.charCodeAt(++state.position); +const evaluateEndpointRule = (endpointRule, options) => { + const { conditions, endpoint } = endpointRule; + const { result, referenceRecord } = evaluateConditions(conditions, options); + if (!result) { + return; + } + const endpointRuleOptions = { + ...options, + referenceRecord: { ...options.referenceRecord, ...referenceRecord }, + }; + const { url, properties, headers } = endpoint; + options.logger?.debug?.(`${debugId} Resolving endpoint from template: ${toDebugString(endpoint)}`); + return { + ...(headers != undefined && { + headers: getEndpointHeaders(headers, endpointRuleOptions), + }), + ...(properties != undefined && { + properties: getEndpointProperties(properties, endpointRuleOptions), + }), + url: getEndpointUrl(url, endpointRuleOptions), + }; +}; - if (ch === 0x3C/* < */) { - isVerbatim = true; - ch = state.input.charCodeAt(++state.position); +const evaluateErrorRule = (errorRule, options) => { + const { conditions, error } = errorRule; + const { result, referenceRecord } = evaluateConditions(conditions, options); + if (!result) { + return; + } + throw new EndpointError(evaluateExpression(error, "Error", { + ...options, + referenceRecord: { ...options.referenceRecord, ...referenceRecord }, + })); +}; - } else if (ch === 0x21/* ! */) { - isNamed = true; - tagHandle = '!!'; - ch = state.input.charCodeAt(++state.position); +const evaluateRules = (rules, options) => { + for (const rule of rules) { + if (rule.type === "endpoint") { + const endpointOrUndefined = evaluateEndpointRule(rule, options); + if (endpointOrUndefined) { + return endpointOrUndefined; + } + } + else if (rule.type === "error") { + evaluateErrorRule(rule, options); + } + else if (rule.type === "tree") { + const endpointOrUndefined = group.evaluateTreeRule(rule, options); + if (endpointOrUndefined) { + return endpointOrUndefined; + } + } + else { + throw new EndpointError(`Unknown endpoint rule: ${rule}`); + } + } + throw new EndpointError(`Rules evaluation failed`); +}; +const evaluateTreeRule = (treeRule, options) => { + const { conditions, rules } = treeRule; + const { result, referenceRecord } = evaluateConditions(conditions, options); + if (!result) { + return; + } + return group.evaluateRules(rules, { + ...options, + referenceRecord: { ...options.referenceRecord, ...referenceRecord }, + }); +}; +const group = { + evaluateRules, + evaluateTreeRule, +}; - } else { - tagHandle = '!'; - } +const resolveEndpoint = (ruleSetObject, options) => { + const { endpointParams, logger } = options; + const { parameters, rules } = ruleSetObject; + options.logger?.debug?.(`${debugId} Initial EndpointParams: ${toDebugString(endpointParams)}`); + const paramsWithDefault = Object.entries(parameters) + .filter(([, v]) => v.default != null) + .map(([k, v]) => [k, v.default]); + if (paramsWithDefault.length > 0) { + for (const [paramKey, paramDefaultValue] of paramsWithDefault) { + endpointParams[paramKey] = endpointParams[paramKey] ?? paramDefaultValue; + } + } + const requiredParams = Object.entries(parameters) + .filter(([, v]) => v.required) + .map(([k]) => k); + for (const requiredParam of requiredParams) { + if (endpointParams[requiredParam] == null) { + throw new EndpointError(`Missing required parameter: '${requiredParam}'`); + } + } + const endpoint = evaluateRules(rules, { endpointParams, logger, referenceRecord: {} }); + options.logger?.debug?.(`${debugId} Resolved endpoint: ${toDebugString(endpoint)}`); + return endpoint; +}; - _position = state.position; +exports.EndpointCache = EndpointCache; +exports.EndpointError = EndpointError; +exports.customEndpointFunctions = customEndpointFunctions; +exports.isIpAddress = isIpAddress; +exports.isValidHostLabel = isValidHostLabel; +exports.resolveEndpoint = resolveEndpoint; - if (isVerbatim) { - do { ch = state.input.charCodeAt(++state.position); } - while (ch !== 0 && ch !== 0x3E/* > */); - if (state.position < state.length) { - tagName = state.input.slice(_position, state.position); - ch = state.input.charCodeAt(++state.position); - } else { - throwError(state, 'unexpected end of the stream within a verbatim tag'); - } - } else { - while (ch !== 0 && !is_WS_OR_EOL(ch)) { +/***/ }), - if (ch === 0x21/* ! */) { - if (!isNamed) { - tagHandle = state.input.slice(_position - 1, state.position + 1); +/***/ 6435: +/***/ ((__unused_webpack_module, exports) => { - if (!PATTERN_TAG_HANDLE.test(tagHandle)) { - throwError(state, 'named tag handle cannot contain such characters'); - } +"use strict"; - isNamed = true; - _position = state.position + 1; - } else { - throwError(state, 'tag suffix cannot contain exclamation marks'); - } - } - ch = state.input.charCodeAt(++state.position); +const SHORT_TO_HEX = {}; +const HEX_TO_SHORT = {}; +for (let i = 0; i < 256; i++) { + let encodedByte = i.toString(16).toLowerCase(); + if (encodedByte.length === 1) { + encodedByte = `0${encodedByte}`; } - - tagName = state.input.slice(_position, state.position); - - if (PATTERN_FLOW_INDICATORS.test(tagName)) { - throwError(state, 'tag suffix cannot contain flow indicator characters'); + SHORT_TO_HEX[i] = encodedByte; + HEX_TO_SHORT[encodedByte] = i; +} +function fromHex(encoded) { + if (encoded.length % 2 !== 0) { + throw new Error("Hex encoded strings must have an even number length"); + } + const out = new Uint8Array(encoded.length / 2); + for (let i = 0; i < encoded.length; i += 2) { + const encodedByte = encoded.slice(i, i + 2).toLowerCase(); + if (encodedByte in HEX_TO_SHORT) { + out[i / 2] = HEX_TO_SHORT[encodedByte]; + } + else { + throw new Error(`Cannot decode unrecognized sequence ${encodedByte} as hexadecimal`); + } } - } + return out; +} +function toHex(bytes) { + let out = ""; + for (let i = 0; i < bytes.byteLength; i++) { + out += SHORT_TO_HEX[bytes[i]]; + } + return out; +} - if (tagName && !PATTERN_TAG_URI.test(tagName)) { - throwError(state, 'tag name cannot contain such characters: ' + tagName); - } +exports.fromHex = fromHex; +exports.toHex = toHex; - if (isVerbatim) { - state.tag = tagName; - } else if (_hasOwnProperty.call(state.tagMap, tagHandle)) { - state.tag = state.tagMap[tagHandle] + tagName; +/***/ }), - } else if (tagHandle === '!') { - state.tag = '!' + tagName; +/***/ 6324: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - } else if (tagHandle === '!!') { - state.tag = 'tag:yaml.org,2002:' + tagName; +"use strict"; - } else { - throwError(state, 'undeclared tag handle "' + tagHandle + '"'); - } - return true; -} +var types = __nccwpck_require__(690); -function readAnchorProperty(state) { - var _position, - ch; +const getSmithyContext = (context) => context[types.SMITHY_CONTEXT_KEY] || (context[types.SMITHY_CONTEXT_KEY] = {}); - ch = state.input.charCodeAt(state.position); +const normalizeProvider = (input) => { + if (typeof input === "function") + return input; + const promisified = Promise.resolve(input); + return () => promisified; +}; - if (ch !== 0x26/* & */) return false; +exports.getSmithyContext = getSmithyContext; +exports.normalizeProvider = normalizeProvider; - if (state.anchor !== null) { - throwError(state, 'duplication of an anchor property'); - } - ch = state.input.charCodeAt(++state.position); - _position = state.position; +/***/ }), - while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) { - ch = state.input.charCodeAt(++state.position); - } +/***/ 5518: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - if (state.position === _position) { - throwError(state, 'name of an anchor node must contain at least one character'); - } +"use strict"; - state.anchor = state.input.slice(_position, state.position); - return true; + +var serviceErrorClassification = __nccwpck_require__(2058); + +exports.RETRY_MODES = void 0; +(function (RETRY_MODES) { + RETRY_MODES["STANDARD"] = "standard"; + RETRY_MODES["ADAPTIVE"] = "adaptive"; +})(exports.RETRY_MODES || (exports.RETRY_MODES = {})); +const DEFAULT_MAX_ATTEMPTS = 3; +const DEFAULT_RETRY_MODE = exports.RETRY_MODES.STANDARD; + +class DefaultRateLimiter { + static setTimeoutFn = setTimeout; + beta; + minCapacity; + minFillRate; + scaleConstant; + smooth; + currentCapacity = 0; + enabled = false; + lastMaxRate = 0; + measuredTxRate = 0; + requestCount = 0; + fillRate; + lastThrottleTime; + lastTimestamp = 0; + lastTxRateBucket; + maxCapacity; + timeWindow = 0; + constructor(options) { + this.beta = options?.beta ?? 0.7; + this.minCapacity = options?.minCapacity ?? 1; + this.minFillRate = options?.minFillRate ?? 0.5; + this.scaleConstant = options?.scaleConstant ?? 0.4; + this.smooth = options?.smooth ?? 0.8; + const currentTimeInSeconds = this.getCurrentTimeInSeconds(); + this.lastThrottleTime = currentTimeInSeconds; + this.lastTxRateBucket = Math.floor(this.getCurrentTimeInSeconds()); + this.fillRate = this.minFillRate; + this.maxCapacity = this.minCapacity; + } + getCurrentTimeInSeconds() { + return Date.now() / 1000; + } + async getSendToken() { + return this.acquireTokenBucket(1); + } + async acquireTokenBucket(amount) { + if (!this.enabled) { + return; + } + this.refillTokenBucket(); + if (amount > this.currentCapacity) { + const delay = ((amount - this.currentCapacity) / this.fillRate) * 1000; + await new Promise((resolve) => DefaultRateLimiter.setTimeoutFn(resolve, delay)); + } + this.currentCapacity = this.currentCapacity - amount; + } + refillTokenBucket() { + const timestamp = this.getCurrentTimeInSeconds(); + if (!this.lastTimestamp) { + this.lastTimestamp = timestamp; + return; + } + const fillAmount = (timestamp - this.lastTimestamp) * this.fillRate; + this.currentCapacity = Math.min(this.maxCapacity, this.currentCapacity + fillAmount); + this.lastTimestamp = timestamp; + } + updateClientSendingRate(response) { + let calculatedRate; + this.updateMeasuredRate(); + if (serviceErrorClassification.isThrottlingError(response)) { + const rateToUse = !this.enabled ? this.measuredTxRate : Math.min(this.measuredTxRate, this.fillRate); + this.lastMaxRate = rateToUse; + this.calculateTimeWindow(); + this.lastThrottleTime = this.getCurrentTimeInSeconds(); + calculatedRate = this.cubicThrottle(rateToUse); + this.enableTokenBucket(); + } + else { + this.calculateTimeWindow(); + calculatedRate = this.cubicSuccess(this.getCurrentTimeInSeconds()); + } + const newRate = Math.min(calculatedRate, 2 * this.measuredTxRate); + this.updateTokenBucketRate(newRate); + } + calculateTimeWindow() { + this.timeWindow = this.getPrecise(Math.pow((this.lastMaxRate * (1 - this.beta)) / this.scaleConstant, 1 / 3)); + } + cubicThrottle(rateToUse) { + return this.getPrecise(rateToUse * this.beta); + } + cubicSuccess(timestamp) { + return this.getPrecise(this.scaleConstant * Math.pow(timestamp - this.lastThrottleTime - this.timeWindow, 3) + this.lastMaxRate); + } + enableTokenBucket() { + this.enabled = true; + } + updateTokenBucketRate(newRate) { + this.refillTokenBucket(); + this.fillRate = Math.max(newRate, this.minFillRate); + this.maxCapacity = Math.max(newRate, this.minCapacity); + this.currentCapacity = Math.min(this.currentCapacity, this.maxCapacity); + } + updateMeasuredRate() { + const t = this.getCurrentTimeInSeconds(); + const timeBucket = Math.floor(t * 2) / 2; + this.requestCount++; + if (timeBucket > this.lastTxRateBucket) { + const currentRate = this.requestCount / (timeBucket - this.lastTxRateBucket); + this.measuredTxRate = this.getPrecise(currentRate * this.smooth + this.measuredTxRate * (1 - this.smooth)); + this.requestCount = 0; + this.lastTxRateBucket = timeBucket; + } + } + getPrecise(num) { + return parseFloat(num.toFixed(8)); + } } -function readAlias(state) { - var _position, alias, - ch; +const DEFAULT_RETRY_DELAY_BASE = 100; +const MAXIMUM_RETRY_DELAY = 20 * 1000; +const THROTTLING_RETRY_DELAY_BASE = 500; +const INITIAL_RETRY_TOKENS = 500; +const RETRY_COST = 5; +const TIMEOUT_RETRY_COST = 10; +const NO_RETRY_INCREMENT = 1; +const INVOCATION_ID_HEADER = "amz-sdk-invocation-id"; +const REQUEST_HEADER = "amz-sdk-request"; + +const getDefaultRetryBackoffStrategy = () => { + let delayBase = DEFAULT_RETRY_DELAY_BASE; + const computeNextBackoffDelay = (attempts) => { + return Math.floor(Math.min(MAXIMUM_RETRY_DELAY, Math.random() * 2 ** attempts * delayBase)); + }; + const setDelayBase = (delay) => { + delayBase = delay; + }; + return { + computeNextBackoffDelay, + setDelayBase, + }; +}; - ch = state.input.charCodeAt(state.position); +const createDefaultRetryToken = ({ retryDelay, retryCount, retryCost, }) => { + const getRetryCount = () => retryCount; + const getRetryDelay = () => Math.min(MAXIMUM_RETRY_DELAY, retryDelay); + const getRetryCost = () => retryCost; + return { + getRetryCount, + getRetryDelay, + getRetryCost, + }; +}; - if (ch !== 0x2A/* * */) return false; +class StandardRetryStrategy { + maxAttempts; + mode = exports.RETRY_MODES.STANDARD; + capacity = INITIAL_RETRY_TOKENS; + retryBackoffStrategy = getDefaultRetryBackoffStrategy(); + maxAttemptsProvider; + constructor(maxAttempts) { + this.maxAttempts = maxAttempts; + this.maxAttemptsProvider = typeof maxAttempts === "function" ? maxAttempts : async () => maxAttempts; + } + async acquireInitialRetryToken(retryTokenScope) { + return createDefaultRetryToken({ + retryDelay: DEFAULT_RETRY_DELAY_BASE, + retryCount: 0, + }); + } + async refreshRetryTokenForRetry(token, errorInfo) { + const maxAttempts = await this.getMaxAttempts(); + if (this.shouldRetry(token, errorInfo, maxAttempts)) { + const errorType = errorInfo.errorType; + this.retryBackoffStrategy.setDelayBase(errorType === "THROTTLING" ? THROTTLING_RETRY_DELAY_BASE : DEFAULT_RETRY_DELAY_BASE); + const delayFromErrorType = this.retryBackoffStrategy.computeNextBackoffDelay(token.getRetryCount()); + const retryDelay = errorInfo.retryAfterHint + ? Math.max(errorInfo.retryAfterHint.getTime() - Date.now() || 0, delayFromErrorType) + : delayFromErrorType; + const capacityCost = this.getCapacityCost(errorType); + this.capacity -= capacityCost; + return createDefaultRetryToken({ + retryDelay, + retryCount: token.getRetryCount() + 1, + retryCost: capacityCost, + }); + } + throw new Error("No retry token available"); + } + recordSuccess(token) { + this.capacity = Math.max(INITIAL_RETRY_TOKENS, this.capacity + (token.getRetryCost() ?? NO_RETRY_INCREMENT)); + } + getCapacity() { + return this.capacity; + } + async getMaxAttempts() { + try { + return await this.maxAttemptsProvider(); + } + catch (error) { + console.warn(`Max attempts provider could not resolve. Using default of ${DEFAULT_MAX_ATTEMPTS}`); + return DEFAULT_MAX_ATTEMPTS; + } + } + shouldRetry(tokenToRenew, errorInfo, maxAttempts) { + const attempts = tokenToRenew.getRetryCount() + 1; + return (attempts < maxAttempts && + this.capacity >= this.getCapacityCost(errorInfo.errorType) && + this.isRetryableError(errorInfo.errorType)); + } + getCapacityCost(errorType) { + return errorType === "TRANSIENT" ? TIMEOUT_RETRY_COST : RETRY_COST; + } + isRetryableError(errorType) { + return errorType === "THROTTLING" || errorType === "TRANSIENT"; + } +} - ch = state.input.charCodeAt(++state.position); - _position = state.position; +class AdaptiveRetryStrategy { + maxAttemptsProvider; + rateLimiter; + standardRetryStrategy; + mode = exports.RETRY_MODES.ADAPTIVE; + constructor(maxAttemptsProvider, options) { + this.maxAttemptsProvider = maxAttemptsProvider; + const { rateLimiter } = options ?? {}; + this.rateLimiter = rateLimiter ?? new DefaultRateLimiter(); + this.standardRetryStrategy = new StandardRetryStrategy(maxAttemptsProvider); + } + async acquireInitialRetryToken(retryTokenScope) { + await this.rateLimiter.getSendToken(); + return this.standardRetryStrategy.acquireInitialRetryToken(retryTokenScope); + } + async refreshRetryTokenForRetry(tokenToRenew, errorInfo) { + this.rateLimiter.updateClientSendingRate(errorInfo); + return this.standardRetryStrategy.refreshRetryTokenForRetry(tokenToRenew, errorInfo); + } + recordSuccess(token) { + this.rateLimiter.updateClientSendingRate({}); + this.standardRetryStrategy.recordSuccess(token); + } +} - while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) { - ch = state.input.charCodeAt(++state.position); - } +class ConfiguredRetryStrategy extends StandardRetryStrategy { + computeNextBackoffDelay; + constructor(maxAttempts, computeNextBackoffDelay = DEFAULT_RETRY_DELAY_BASE) { + super(typeof maxAttempts === "function" ? maxAttempts : async () => maxAttempts); + if (typeof computeNextBackoffDelay === "number") { + this.computeNextBackoffDelay = () => computeNextBackoffDelay; + } + else { + this.computeNextBackoffDelay = computeNextBackoffDelay; + } + } + async refreshRetryTokenForRetry(tokenToRenew, errorInfo) { + const token = await super.refreshRetryTokenForRetry(tokenToRenew, errorInfo); + token.getRetryDelay = () => this.computeNextBackoffDelay(token.getRetryCount()); + return token; + } +} - if (state.position === _position) { - throwError(state, 'name of an alias node must contain at least one character'); - } +exports.AdaptiveRetryStrategy = AdaptiveRetryStrategy; +exports.ConfiguredRetryStrategy = ConfiguredRetryStrategy; +exports.DEFAULT_MAX_ATTEMPTS = DEFAULT_MAX_ATTEMPTS; +exports.DEFAULT_RETRY_DELAY_BASE = DEFAULT_RETRY_DELAY_BASE; +exports.DEFAULT_RETRY_MODE = DEFAULT_RETRY_MODE; +exports.DefaultRateLimiter = DefaultRateLimiter; +exports.INITIAL_RETRY_TOKENS = INITIAL_RETRY_TOKENS; +exports.INVOCATION_ID_HEADER = INVOCATION_ID_HEADER; +exports.MAXIMUM_RETRY_DELAY = MAXIMUM_RETRY_DELAY; +exports.NO_RETRY_INCREMENT = NO_RETRY_INCREMENT; +exports.REQUEST_HEADER = REQUEST_HEADER; +exports.RETRY_COST = RETRY_COST; +exports.StandardRetryStrategy = StandardRetryStrategy; +exports.THROTTLING_RETRY_DELAY_BASE = THROTTLING_RETRY_DELAY_BASE; +exports.TIMEOUT_RETRY_COST = TIMEOUT_RETRY_COST; - alias = state.input.slice(_position, state.position); - if (!state.anchorMap.hasOwnProperty(alias)) { - throwError(state, 'unidentified alias "' + alias + '"'); - } +/***/ }), - state.result = state.anchorMap[alias]; - skipSeparationSpace(state, true, -1); - return true; -} +/***/ 1732: +/***/ ((__unused_webpack_module, exports) => { -function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) { - var allowBlockStyles, - allowBlockScalars, - allowBlockCollections, - indentStatus = 1, // 1: this>parent, 0: this=parent, -1: this { - if (state.lineIndent > parentIndent) { - indentStatus = 1; - } else if (state.lineIndent === parentIndent) { - indentStatus = 0; - } else if (state.lineIndent < parentIndent) { - indentStatus = -1; - } - } - } +"use strict"; - if (indentStatus === 1) { - while (readTagProperty(state) || readAnchorProperty(state)) { - if (skipSeparationSpace(state, true, -1)) { - atNewLine = true; - allowBlockCollections = allowBlockStyles; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ChecksumStream = void 0; +const ReadableStreamRef = typeof ReadableStream === "function" ? ReadableStream : function () { }; +class ChecksumStream extends ReadableStreamRef { +} +exports.ChecksumStream = ChecksumStream; - if (state.lineIndent > parentIndent) { - indentStatus = 1; - } else if (state.lineIndent === parentIndent) { - indentStatus = 0; - } else if (state.lineIndent < parentIndent) { - indentStatus = -1; - } - } else { - allowBlockCollections = false; - } - } - } - if (allowBlockCollections) { - allowBlockCollections = atNewLine || allowCompact; - } +/***/ }), - if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) { - if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) { - flowIndent = parentIndent; - } else { - flowIndent = parentIndent + 1; - } +/***/ 1775: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - blockIndent = state.position - state.lineStart; +"use strict"; - if (indentStatus === 1) { - if (allowBlockCollections && - (readBlockSequence(state, blockIndent) || - readBlockMapping(state, blockIndent, flowIndent)) || - readFlowCollection(state, flowIndent)) { - hasContent = true; - } else { - if ((allowBlockScalars && readBlockScalar(state, flowIndent)) || - readSingleQuotedScalar(state, flowIndent) || - readDoubleQuotedScalar(state, flowIndent)) { - hasContent = true; - - } else if (readAlias(state)) { - hasContent = true; - - if (state.tag !== null || state.anchor !== null) { - throwError(state, 'alias node should not have any properties'); - } - - } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) { - hasContent = true; - - if (state.tag === null) { - state.tag = '?'; - } +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ChecksumStream = void 0; +const util_base64_1 = __nccwpck_require__(8385); +const stream_1 = __nccwpck_require__(2203); +class ChecksumStream extends stream_1.Duplex { + expectedChecksum; + checksumSourceLocation; + checksum; + source; + base64Encoder; + constructor({ expectedChecksum, checksum, source, checksumSourceLocation, base64Encoder, }) { + super(); + if (typeof source.pipe === "function") { + this.source = source; } - - if (state.anchor !== null) { - state.anchorMap[state.anchor] = state.result; + else { + throw new Error(`@smithy/util-stream: unsupported source type ${source?.constructor?.name ?? source} in ChecksumStream.`); } - } - } else if (indentStatus === 0) { - // Special case: block sequences are allowed to have same indentation level as the parent. - // http://www.yaml.org/spec/1.2/spec.html#id2799784 - hasContent = allowBlockCollections && readBlockSequence(state, blockIndent); + this.base64Encoder = base64Encoder ?? util_base64_1.toBase64; + this.expectedChecksum = expectedChecksum; + this.checksum = checksum; + this.checksumSourceLocation = checksumSourceLocation; + this.source.pipe(this); + } + _read(size) { } + _write(chunk, encoding, callback) { + try { + this.checksum.update(chunk); + this.push(chunk); + } + catch (e) { + return callback(e); + } + return callback(); } - } - - if (state.tag !== null && state.tag !== '!') { - if (state.tag === '?') { - // Implicit resolving is not allowed for non-scalar types, and '?' - // non-specific tag is only automatically assigned to plain scalars. - // - // We only need to check kind conformity in case user explicitly assigns '?' - // tag, for example like this: "! [0]" - // - if (state.result !== null && state.kind !== 'scalar') { - throwError(state, 'unacceptable node kind for ! tag; it should be "scalar", not "' + state.kind + '"'); - } - - for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) { - type = state.implicitTypes[typeIndex]; - - if (type.resolve(state.result)) { // `state.result` updated in resolver if matched - state.result = type.construct(state.result); - state.tag = type.tag; - if (state.anchor !== null) { - state.anchorMap[state.anchor] = state.result; - } - break; + async _final(callback) { + try { + const digest = await this.checksum.digest(); + const received = this.base64Encoder(digest); + if (this.expectedChecksum !== received) { + return callback(new Error(`Checksum mismatch: expected "${this.expectedChecksum}" but received "${received}"` + + ` in response header "${this.checksumSourceLocation}".`)); + } } - } - } else if (_hasOwnProperty.call(state.typeMap[state.kind || 'fallback'], state.tag)) { - type = state.typeMap[state.kind || 'fallback'][state.tag]; - - if (state.result !== null && type.kind !== state.kind) { - throwError(state, 'unacceptable node kind for !<' + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"'); - } - - if (!type.resolve(state.result)) { // `state.result` updated in resolver if matched - throwError(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag'); - } else { - state.result = type.construct(state.result); - if (state.anchor !== null) { - state.anchorMap[state.anchor] = state.result; + catch (e) { + return callback(e); } - } - } else { - throwError(state, 'unknown tag !<' + state.tag + '>'); + this.push(null); + return callback(); } - } - - if (state.listener !== null) { - state.listener('close', state); - } - return state.tag !== null || state.anchor !== null || hasContent; } +exports.ChecksumStream = ChecksumStream; -function readDocument(state) { - var documentStart = state.position, - _position, - directiveName, - directiveArgs, - hasDirectives = false, - ch; - state.version = null; - state.checkLineBreaks = state.legacy; - state.tagMap = {}; - state.anchorMap = {}; +/***/ }), - while ((ch = state.input.charCodeAt(state.position)) !== 0) { - skipSeparationSpace(state, true, -1); +/***/ 4129: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - ch = state.input.charCodeAt(state.position); +"use strict"; - if (state.lineIndent > 0 || ch !== 0x25/* % */) { - break; - } +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.createChecksumStream = void 0; +const util_base64_1 = __nccwpck_require__(8385); +const stream_type_check_1 = __nccwpck_require__(4414); +const ChecksumStream_browser_1 = __nccwpck_require__(7753); +const createChecksumStream = ({ expectedChecksum, checksum, source, checksumSourceLocation, base64Encoder, }) => { + if (!(0, stream_type_check_1.isReadableStream)(source)) { + throw new Error(`@smithy/util-stream: unsupported source type ${source?.constructor?.name ?? source} in ChecksumStream.`); + } + const encoder = base64Encoder ?? util_base64_1.toBase64; + if (typeof TransformStream !== "function") { + throw new Error("@smithy/util-stream: unable to instantiate ChecksumStream because API unavailable: ReadableStream/TransformStream."); + } + const transform = new TransformStream({ + start() { }, + async transform(chunk, controller) { + checksum.update(chunk); + controller.enqueue(chunk); + }, + async flush(controller) { + const digest = await checksum.digest(); + const received = encoder(digest); + if (expectedChecksum !== received) { + const error = new Error(`Checksum mismatch: expected "${expectedChecksum}" but received "${received}"` + + ` in response header "${checksumSourceLocation}".`); + controller.error(error); + } + else { + controller.terminate(); + } + }, + }); + source.pipeThrough(transform); + const readable = transform.readable; + Object.setPrototypeOf(readable, ChecksumStream_browser_1.ChecksumStream.prototype); + return readable; +}; +exports.createChecksumStream = createChecksumStream; - hasDirectives = true; - ch = state.input.charCodeAt(++state.position); - _position = state.position; - while (ch !== 0 && !is_WS_OR_EOL(ch)) { - ch = state.input.charCodeAt(++state.position); - } +/***/ }), - directiveName = state.input.slice(_position, state.position); - directiveArgs = []; +/***/ 5639: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - if (directiveName.length < 1) { - throwError(state, 'directive name must not be less than one character in length'); +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.createChecksumStream = createChecksumStream; +const stream_type_check_1 = __nccwpck_require__(4414); +const ChecksumStream_1 = __nccwpck_require__(1775); +const createChecksumStream_browser_1 = __nccwpck_require__(4129); +function createChecksumStream(init) { + if (typeof ReadableStream === "function" && (0, stream_type_check_1.isReadableStream)(init.source)) { + return (0, createChecksumStream_browser_1.createChecksumStream)(init); } + return new ChecksumStream_1.ChecksumStream(init); +} - while (ch !== 0) { - while (is_WHITE_SPACE(ch)) { - ch = state.input.charCodeAt(++state.position); - } - if (ch === 0x23/* # */) { - do { ch = state.input.charCodeAt(++state.position); } - while (ch !== 0 && !is_EOL(ch)); - break; - } +/***/ }), - if (is_EOL(ch)) break; +/***/ 2005: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - _position = state.position; +"use strict"; - while (ch !== 0 && !is_WS_OR_EOL(ch)) { - ch = state.input.charCodeAt(++state.position); - } +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.createBufferedReadable = createBufferedReadable; +const node_stream_1 = __nccwpck_require__(7075); +const ByteArrayCollector_1 = __nccwpck_require__(1732); +const createBufferedReadableStream_1 = __nccwpck_require__(8213); +const stream_type_check_1 = __nccwpck_require__(4414); +function createBufferedReadable(upstream, size, logger) { + if ((0, stream_type_check_1.isReadableStream)(upstream)) { + return (0, createBufferedReadableStream_1.createBufferedReadableStream)(upstream, size, logger); + } + const downstream = new node_stream_1.Readable({ read() { } }); + let streamBufferingLoggedWarning = false; + let bytesSeen = 0; + const buffers = [ + "", + new ByteArrayCollector_1.ByteArrayCollector((size) => new Uint8Array(size)), + new ByteArrayCollector_1.ByteArrayCollector((size) => Buffer.from(new Uint8Array(size))), + ]; + let mode = -1; + upstream.on("data", (chunk) => { + const chunkMode = (0, createBufferedReadableStream_1.modeOf)(chunk, true); + if (mode !== chunkMode) { + if (mode >= 0) { + downstream.push((0, createBufferedReadableStream_1.flush)(buffers, mode)); + } + mode = chunkMode; + } + if (mode === -1) { + downstream.push(chunk); + return; + } + const chunkSize = (0, createBufferedReadableStream_1.sizeOf)(chunk); + bytesSeen += chunkSize; + const bufferSize = (0, createBufferedReadableStream_1.sizeOf)(buffers[mode]); + if (chunkSize >= size && bufferSize === 0) { + downstream.push(chunk); + } + else { + const newSize = (0, createBufferedReadableStream_1.merge)(buffers, mode, chunk); + if (!streamBufferingLoggedWarning && bytesSeen > size * 2) { + streamBufferingLoggedWarning = true; + logger?.warn(`@smithy/util-stream - stream chunk size ${chunkSize} is below threshold of ${size}, automatically buffering.`); + } + if (newSize >= size) { + downstream.push((0, createBufferedReadableStream_1.flush)(buffers, mode)); + } + } + }); + upstream.on("end", () => { + if (mode !== -1) { + const remainder = (0, createBufferedReadableStream_1.flush)(buffers, mode); + if ((0, createBufferedReadableStream_1.sizeOf)(remainder) > 0) { + downstream.push(remainder); + } + } + downstream.push(null); + }); + return downstream; +} - directiveArgs.push(state.input.slice(_position, state.position)); - } - if (ch !== 0) readLineBreak(state); +/***/ }), - if (_hasOwnProperty.call(directiveHandlers, directiveName)) { - directiveHandlers[directiveName](state, directiveName, directiveArgs); - } else { - throwWarning(state, 'unknown document directive "' + directiveName + '"'); +/***/ 8213: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.createBufferedReadable = void 0; +exports.createBufferedReadableStream = createBufferedReadableStream; +exports.merge = merge; +exports.flush = flush; +exports.sizeOf = sizeOf; +exports.modeOf = modeOf; +const ByteArrayCollector_1 = __nccwpck_require__(1732); +function createBufferedReadableStream(upstream, size, logger) { + const reader = upstream.getReader(); + let streamBufferingLoggedWarning = false; + let bytesSeen = 0; + const buffers = ["", new ByteArrayCollector_1.ByteArrayCollector((size) => new Uint8Array(size))]; + let mode = -1; + const pull = async (controller) => { + const { value, done } = await reader.read(); + const chunk = value; + if (done) { + if (mode !== -1) { + const remainder = flush(buffers, mode); + if (sizeOf(remainder) > 0) { + controller.enqueue(remainder); + } + } + controller.close(); + } + else { + const chunkMode = modeOf(chunk, false); + if (mode !== chunkMode) { + if (mode >= 0) { + controller.enqueue(flush(buffers, mode)); + } + mode = chunkMode; + } + if (mode === -1) { + controller.enqueue(chunk); + return; + } + const chunkSize = sizeOf(chunk); + bytesSeen += chunkSize; + const bufferSize = sizeOf(buffers[mode]); + if (chunkSize >= size && bufferSize === 0) { + controller.enqueue(chunk); + } + else { + const newSize = merge(buffers, mode, chunk); + if (!streamBufferingLoggedWarning && bytesSeen > size * 2) { + streamBufferingLoggedWarning = true; + logger?.warn(`@smithy/util-stream - stream chunk size ${chunkSize} is below threshold of ${size}, automatically buffering.`); + } + if (newSize >= size) { + controller.enqueue(flush(buffers, mode)); + } + else { + await pull(controller); + } + } + } + }; + return new ReadableStream({ + pull, + }); +} +exports.createBufferedReadable = createBufferedReadableStream; +function merge(buffers, mode, chunk) { + switch (mode) { + case 0: + buffers[0] += chunk; + return sizeOf(buffers[0]); + case 1: + case 2: + buffers[mode].push(chunk); + return sizeOf(buffers[mode]); } - } +} +function flush(buffers, mode) { + switch (mode) { + case 0: + const s = buffers[0]; + buffers[0] = ""; + return s; + case 1: + case 2: + return buffers[mode].flush(); + } + throw new Error(`@smithy/util-stream - invalid index ${mode} given to flush()`); +} +function sizeOf(chunk) { + return chunk?.byteLength ?? chunk?.length ?? 0; +} +function modeOf(chunk, allowBuffer = true) { + if (allowBuffer && typeof Buffer !== "undefined" && chunk instanceof Buffer) { + return 2; + } + if (chunk instanceof Uint8Array) { + return 1; + } + if (typeof chunk === "string") { + return 0; + } + return -1; +} - skipSeparationSpace(state, true, -1); - if (state.lineIndent === 0 && - state.input.charCodeAt(state.position) === 0x2D/* - */ && - state.input.charCodeAt(state.position + 1) === 0x2D/* - */ && - state.input.charCodeAt(state.position + 2) === 0x2D/* - */) { - state.position += 3; - skipSeparationSpace(state, true, -1); +/***/ }), - } else if (hasDirectives) { - throwError(state, 'directives end mark is expected'); - } +/***/ 3492: +/***/ ((__unused_webpack_module, exports) => { - composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true); - skipSeparationSpace(state, true, -1); +"use strict"; - if (state.checkLineBreaks && - PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) { - throwWarning(state, 'non-ASCII line breaks are interpreted as content'); - } +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getAwsChunkedEncodingStream = void 0; +const getAwsChunkedEncodingStream = (readableStream, options) => { + const { base64Encoder, bodyLengthChecker, checksumAlgorithmFn, checksumLocationName, streamHasher } = options; + const checksumRequired = base64Encoder !== undefined && + bodyLengthChecker !== undefined && + checksumAlgorithmFn !== undefined && + checksumLocationName !== undefined && + streamHasher !== undefined; + const digest = checksumRequired ? streamHasher(checksumAlgorithmFn, readableStream) : undefined; + const reader = readableStream.getReader(); + return new ReadableStream({ + async pull(controller) { + const { value, done } = await reader.read(); + if (done) { + controller.enqueue(`0\r\n`); + if (checksumRequired) { + const checksum = base64Encoder(await digest); + controller.enqueue(`${checksumLocationName}:${checksum}\r\n`); + controller.enqueue(`\r\n`); + } + controller.close(); + } + else { + controller.enqueue(`${(bodyLengthChecker(value) || 0).toString(16)}\r\n${value}\r\n`); + } + }, + }); +}; +exports.getAwsChunkedEncodingStream = getAwsChunkedEncodingStream; - state.documents.push(state.result); - if (state.position === state.lineStart && testDocumentSeparator(state)) { +/***/ }), - if (state.input.charCodeAt(state.position) === 0x2E/* . */) { - state.position += 3; - skipSeparationSpace(state, true, -1); - } - return; - } +/***/ 6522: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - if (state.position < (state.length - 1)) { - throwError(state, 'end of the stream or a document separator is expected'); - } else { - return; - } +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getAwsChunkedEncodingStream = getAwsChunkedEncodingStream; +const node_stream_1 = __nccwpck_require__(7075); +const getAwsChunkedEncodingStream_browser_1 = __nccwpck_require__(3492); +const stream_type_check_1 = __nccwpck_require__(4414); +function getAwsChunkedEncodingStream(stream, options) { + const readable = stream; + const readableStream = stream; + if ((0, stream_type_check_1.isReadableStream)(readableStream)) { + return (0, getAwsChunkedEncodingStream_browser_1.getAwsChunkedEncodingStream)(readableStream, options); + } + const { base64Encoder, bodyLengthChecker, checksumAlgorithmFn, checksumLocationName, streamHasher } = options; + const checksumRequired = base64Encoder !== undefined && + checksumAlgorithmFn !== undefined && + checksumLocationName !== undefined && + streamHasher !== undefined; + const digest = checksumRequired ? streamHasher(checksumAlgorithmFn, readable) : undefined; + const awsChunkedEncodingStream = new node_stream_1.Readable({ + read: () => { }, + }); + readable.on("data", (data) => { + const length = bodyLengthChecker(data) || 0; + if (length === 0) { + return; + } + awsChunkedEncodingStream.push(`${length.toString(16)}\r\n`); + awsChunkedEncodingStream.push(data); + awsChunkedEncodingStream.push("\r\n"); + }); + readable.on("end", async () => { + awsChunkedEncodingStream.push(`0\r\n`); + if (checksumRequired) { + const checksum = base64Encoder(await digest); + awsChunkedEncodingStream.push(`${checksumLocationName}:${checksum}\r\n`); + awsChunkedEncodingStream.push(`\r\n`); + } + awsChunkedEncodingStream.push(null); + }); + return awsChunkedEncodingStream; } -function loadDocuments(input, options) { - input = String(input); - options = options || {}; +/***/ }), - if (input.length !== 0) { +/***/ 66: +/***/ ((__unused_webpack_module, exports) => { - // Add tailing `\n` if not exists - if (input.charCodeAt(input.length - 1) !== 0x0A/* LF */ && - input.charCodeAt(input.length - 1) !== 0x0D/* CR */) { - input += '\n'; - } +"use strict"; - // Strip BOM - if (input.charCodeAt(0) === 0xFEFF) { - input = input.slice(1); +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.headStream = headStream; +async function headStream(stream, bytes) { + let byteLengthCounter = 0; + const chunks = []; + const reader = stream.getReader(); + let isDone = false; + while (!isDone) { + const { done, value } = await reader.read(); + if (value) { + chunks.push(value); + byteLengthCounter += value?.byteLength ?? 0; + } + if (byteLengthCounter >= bytes) { + break; + } + isDone = done; + } + reader.releaseLock(); + const collected = new Uint8Array(Math.min(bytes, byteLengthCounter)); + let offset = 0; + for (const chunk of chunks) { + if (chunk.byteLength > collected.byteLength - offset) { + collected.set(chunk.subarray(0, collected.byteLength - offset), offset); + break; + } + else { + collected.set(chunk, offset); + } + offset += chunk.length; } - } + return collected; +} - var state = new State(input, options); - var nullpos = input.indexOf('\0'); +/***/ }), - if (nullpos !== -1) { - state.position = nullpos; - throwError(state, 'null byte is not allowed in input'); - } +/***/ 8412: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - // Use 0 as string terminator. That significantly simplifies bounds check. - state.input += '\0'; +"use strict"; - while (state.input.charCodeAt(state.position) === 0x20/* Space */) { - state.lineIndent += 1; - state.position += 1; - } - - while (state.position < (state.length - 1)) { - readDocument(state); - } - - return state.documents; -} - - -function loadAll(input, iterator, options) { - if (iterator !== null && typeof iterator === 'object' && typeof options === 'undefined') { - options = iterator; - iterator = null; - } - - var documents = loadDocuments(input, options); - - if (typeof iterator !== 'function') { - return documents; - } - - for (var index = 0, length = documents.length; index < length; index += 1) { - iterator(documents[index]); - } +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.headStream = void 0; +const stream_1 = __nccwpck_require__(2203); +const headStream_browser_1 = __nccwpck_require__(66); +const stream_type_check_1 = __nccwpck_require__(4414); +const headStream = (stream, bytes) => { + if ((0, stream_type_check_1.isReadableStream)(stream)) { + return (0, headStream_browser_1.headStream)(stream, bytes); + } + return new Promise((resolve, reject) => { + const collector = new Collector(); + collector.limit = bytes; + stream.pipe(collector); + stream.on("error", (err) => { + collector.end(); + reject(err); + }); + collector.on("error", reject); + collector.on("finish", function () { + const bytes = new Uint8Array(Buffer.concat(this.buffers)); + resolve(bytes); + }); + }); +}; +exports.headStream = headStream; +class Collector extends stream_1.Writable { + buffers = []; + limit = Infinity; + bytesBuffered = 0; + _write(chunk, encoding, callback) { + this.buffers.push(chunk); + this.bytesBuffered += chunk.byteLength ?? 0; + if (this.bytesBuffered >= this.limit) { + const excess = this.bytesBuffered - this.limit; + const tailBuffer = this.buffers[this.buffers.length - 1]; + this.buffers[this.buffers.length - 1] = tailBuffer.subarray(0, tailBuffer.byteLength - excess); + this.emit("finish"); + } + callback(); + } } -function load(input, options) { - var documents = loadDocuments(input, options); - - if (documents.length === 0) { - /*eslint-disable no-undefined*/ - return undefined; - } else if (documents.length === 1) { - return documents[0]; - } - throw new YAMLException('expected a single document in the stream, but found more'); -} - +/***/ }), -function safeLoadAll(input, iterator, options) { - if (typeof iterator === 'object' && iterator !== null && typeof options === 'undefined') { - options = iterator; - iterator = null; - } +/***/ 4252: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - return loadAll(input, iterator, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options)); -} +"use strict"; -function safeLoad(input, options) { - return load(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options)); +var utilBase64 = __nccwpck_require__(8385); +var utilUtf8 = __nccwpck_require__(1577); +var ChecksumStream = __nccwpck_require__(1775); +var createChecksumStream = __nccwpck_require__(5639); +var createBufferedReadable = __nccwpck_require__(2005); +var getAwsChunkedEncodingStream = __nccwpck_require__(6522); +var headStream = __nccwpck_require__(8412); +var sdkStreamMixin = __nccwpck_require__(7201); +var splitStream = __nccwpck_require__(2108); +var streamTypeCheck = __nccwpck_require__(4414); + +class Uint8ArrayBlobAdapter extends Uint8Array { + static fromString(source, encoding = "utf-8") { + if (typeof source === "string") { + if (encoding === "base64") { + return Uint8ArrayBlobAdapter.mutate(utilBase64.fromBase64(source)); + } + return Uint8ArrayBlobAdapter.mutate(utilUtf8.fromUtf8(source)); + } + throw new Error(`Unsupported conversion from ${typeof source} to Uint8ArrayBlobAdapter.`); + } + static mutate(source) { + Object.setPrototypeOf(source, Uint8ArrayBlobAdapter.prototype); + return source; + } + transformToString(encoding = "utf-8") { + if (encoding === "base64") { + return utilBase64.toBase64(this); + } + return utilUtf8.toUtf8(this); + } } - -module.exports.loadAll = loadAll; -module.exports.load = load; -module.exports.safeLoadAll = safeLoadAll; -module.exports.safeLoad = safeLoad; - - -/***/ }), - -/***/ 2459: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2014-10-31","endpointPrefix":"rds","protocol":"query","serviceAbbreviation":"Amazon DocDB","serviceFullName":"Amazon DocumentDB with MongoDB compatibility","serviceId":"DocDB","signatureVersion":"v4","signingName":"rds","uid":"docdb-2014-10-31","xmlNamespace":"http://rds.amazonaws.com/doc/2014-10-31/"},"operations":{"AddTagsToResource":{"input":{"type":"structure","required":["ResourceName","Tags"],"members":{"ResourceName":{},"Tags":{"shape":"S3"}}}},"ApplyPendingMaintenanceAction":{"input":{"type":"structure","required":["ResourceIdentifier","ApplyAction","OptInType"],"members":{"ResourceIdentifier":{},"ApplyAction":{},"OptInType":{}}},"output":{"resultWrapper":"ApplyPendingMaintenanceActionResult","type":"structure","members":{"ResourcePendingMaintenanceActions":{"shape":"S7"}}}},"CopyDBClusterParameterGroup":{"input":{"type":"structure","required":["SourceDBClusterParameterGroupIdentifier","TargetDBClusterParameterGroupIdentifier","TargetDBClusterParameterGroupDescription"],"members":{"SourceDBClusterParameterGroupIdentifier":{},"TargetDBClusterParameterGroupIdentifier":{},"TargetDBClusterParameterGroupDescription":{},"Tags":{"shape":"S3"}}},"output":{"resultWrapper":"CopyDBClusterParameterGroupResult","type":"structure","members":{"DBClusterParameterGroup":{"shape":"Sd"}}}},"CopyDBClusterSnapshot":{"input":{"type":"structure","required":["SourceDBClusterSnapshotIdentifier","TargetDBClusterSnapshotIdentifier"],"members":{"SourceDBClusterSnapshotIdentifier":{},"TargetDBClusterSnapshotIdentifier":{},"KmsKeyId":{},"PreSignedUrl":{},"CopyTags":{"type":"boolean"},"Tags":{"shape":"S3"}}},"output":{"resultWrapper":"CopyDBClusterSnapshotResult","type":"structure","members":{"DBClusterSnapshot":{"shape":"Sh"}}}},"CreateDBCluster":{"input":{"type":"structure","required":["DBClusterIdentifier","Engine","MasterUsername","MasterUserPassword"],"members":{"AvailabilityZones":{"shape":"Si"},"BackupRetentionPeriod":{"type":"integer"},"DBClusterIdentifier":{},"DBClusterParameterGroupName":{},"VpcSecurityGroupIds":{"shape":"Sn"},"DBSubnetGroupName":{},"Engine":{},"EngineVersion":{},"Port":{"type":"integer"},"MasterUsername":{},"MasterUserPassword":{},"PreferredBackupWindow":{},"PreferredMaintenanceWindow":{},"Tags":{"shape":"S3"},"StorageEncrypted":{"type":"boolean"},"KmsKeyId":{},"EnableCloudwatchLogsExports":{"shape":"So"},"DeletionProtection":{"type":"boolean"}}},"output":{"resultWrapper":"CreateDBClusterResult","type":"structure","members":{"DBCluster":{"shape":"Sq"}}}},"CreateDBClusterParameterGroup":{"input":{"type":"structure","required":["DBClusterParameterGroupName","DBParameterGroupFamily","Description"],"members":{"DBClusterParameterGroupName":{},"DBParameterGroupFamily":{},"Description":{},"Tags":{"shape":"S3"}}},"output":{"resultWrapper":"CreateDBClusterParameterGroupResult","type":"structure","members":{"DBClusterParameterGroup":{"shape":"Sd"}}}},"CreateDBClusterSnapshot":{"input":{"type":"structure","required":["DBClusterSnapshotIdentifier","DBClusterIdentifier"],"members":{"DBClusterSnapshotIdentifier":{},"DBClusterIdentifier":{},"Tags":{"shape":"S3"}}},"output":{"resultWrapper":"CreateDBClusterSnapshotResult","type":"structure","members":{"DBClusterSnapshot":{"shape":"Sh"}}}},"CreateDBInstance":{"input":{"type":"structure","required":["DBInstanceIdentifier","DBInstanceClass","Engine","DBClusterIdentifier"],"members":{"DBInstanceIdentifier":{},"DBInstanceClass":{},"Engine":{},"AvailabilityZone":{},"PreferredMaintenanceWindow":{},"AutoMinorVersionUpgrade":{"type":"boolean"},"Tags":{"shape":"S3"},"DBClusterIdentifier":{},"PromotionTier":{"type":"integer"}}},"output":{"resultWrapper":"CreateDBInstanceResult","type":"structure","members":{"DBInstance":{"shape":"S13"}}}},"CreateDBSubnetGroup":{"input":{"type":"structure","required":["DBSubnetGroupName","DBSubnetGroupDescription","SubnetIds"],"members":{"DBSubnetGroupName":{},"DBSubnetGroupDescription":{},"SubnetIds":{"shape":"S1e"},"Tags":{"shape":"S3"}}},"output":{"resultWrapper":"CreateDBSubnetGroupResult","type":"structure","members":{"DBSubnetGroup":{"shape":"S15"}}}},"DeleteDBCluster":{"input":{"type":"structure","required":["DBClusterIdentifier"],"members":{"DBClusterIdentifier":{},"SkipFinalSnapshot":{"type":"boolean"},"FinalDBSnapshotIdentifier":{}}},"output":{"resultWrapper":"DeleteDBClusterResult","type":"structure","members":{"DBCluster":{"shape":"Sq"}}}},"DeleteDBClusterParameterGroup":{"input":{"type":"structure","required":["DBClusterParameterGroupName"],"members":{"DBClusterParameterGroupName":{}}}},"DeleteDBClusterSnapshot":{"input":{"type":"structure","required":["DBClusterSnapshotIdentifier"],"members":{"DBClusterSnapshotIdentifier":{}}},"output":{"resultWrapper":"DeleteDBClusterSnapshotResult","type":"structure","members":{"DBClusterSnapshot":{"shape":"Sh"}}}},"DeleteDBInstance":{"input":{"type":"structure","required":["DBInstanceIdentifier"],"members":{"DBInstanceIdentifier":{}}},"output":{"resultWrapper":"DeleteDBInstanceResult","type":"structure","members":{"DBInstance":{"shape":"S13"}}}},"DeleteDBSubnetGroup":{"input":{"type":"structure","required":["DBSubnetGroupName"],"members":{"DBSubnetGroupName":{}}}},"DescribeCertificates":{"input":{"type":"structure","members":{"CertificateIdentifier":{},"Filters":{"shape":"S1p"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeCertificatesResult","type":"structure","members":{"Certificates":{"type":"list","member":{"locationName":"Certificate","type":"structure","members":{"CertificateIdentifier":{},"CertificateType":{},"Thumbprint":{},"ValidFrom":{"type":"timestamp"},"ValidTill":{"type":"timestamp"},"CertificateArn":{}},"wrapper":true}},"Marker":{}}}},"DescribeDBClusterParameterGroups":{"input":{"type":"structure","members":{"DBClusterParameterGroupName":{},"Filters":{"shape":"S1p"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeDBClusterParameterGroupsResult","type":"structure","members":{"Marker":{},"DBClusterParameterGroups":{"type":"list","member":{"shape":"Sd","locationName":"DBClusterParameterGroup"}}}}},"DescribeDBClusterParameters":{"input":{"type":"structure","required":["DBClusterParameterGroupName"],"members":{"DBClusterParameterGroupName":{},"Source":{},"Filters":{"shape":"S1p"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeDBClusterParametersResult","type":"structure","members":{"Parameters":{"shape":"S20"},"Marker":{}}}},"DescribeDBClusterSnapshotAttributes":{"input":{"type":"structure","required":["DBClusterSnapshotIdentifier"],"members":{"DBClusterSnapshotIdentifier":{}}},"output":{"resultWrapper":"DescribeDBClusterSnapshotAttributesResult","type":"structure","members":{"DBClusterSnapshotAttributesResult":{"shape":"S25"}}}},"DescribeDBClusterSnapshots":{"input":{"type":"structure","members":{"DBClusterIdentifier":{},"DBClusterSnapshotIdentifier":{},"SnapshotType":{},"Filters":{"shape":"S1p"},"MaxRecords":{"type":"integer"},"Marker":{},"IncludeShared":{"type":"boolean"},"IncludePublic":{"type":"boolean"}}},"output":{"resultWrapper":"DescribeDBClusterSnapshotsResult","type":"structure","members":{"Marker":{},"DBClusterSnapshots":{"type":"list","member":{"shape":"Sh","locationName":"DBClusterSnapshot"}}}}},"DescribeDBClusters":{"input":{"type":"structure","members":{"DBClusterIdentifier":{},"Filters":{"shape":"S1p"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeDBClustersResult","type":"structure","members":{"Marker":{},"DBClusters":{"type":"list","member":{"shape":"Sq","locationName":"DBCluster"}}}}},"DescribeDBEngineVersions":{"input":{"type":"structure","members":{"Engine":{},"EngineVersion":{},"DBParameterGroupFamily":{},"Filters":{"shape":"S1p"},"MaxRecords":{"type":"integer"},"Marker":{},"DefaultOnly":{"type":"boolean"},"ListSupportedCharacterSets":{"type":"boolean"},"ListSupportedTimezones":{"type":"boolean"}}},"output":{"resultWrapper":"DescribeDBEngineVersionsResult","type":"structure","members":{"Marker":{},"DBEngineVersions":{"type":"list","member":{"locationName":"DBEngineVersion","type":"structure","members":{"Engine":{},"EngineVersion":{},"DBParameterGroupFamily":{},"DBEngineDescription":{},"DBEngineVersionDescription":{},"ValidUpgradeTarget":{"type":"list","member":{"locationName":"UpgradeTarget","type":"structure","members":{"Engine":{},"EngineVersion":{},"Description":{},"AutoUpgrade":{"type":"boolean"},"IsMajorVersionUpgrade":{"type":"boolean"}}}},"ExportableLogTypes":{"shape":"So"},"SupportsLogExportsToCloudwatchLogs":{"type":"boolean"}}}}}}},"DescribeDBInstances":{"input":{"type":"structure","members":{"DBInstanceIdentifier":{},"Filters":{"shape":"S1p"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeDBInstancesResult","type":"structure","members":{"Marker":{},"DBInstances":{"type":"list","member":{"shape":"S13","locationName":"DBInstance"}}}}},"DescribeDBSubnetGroups":{"input":{"type":"structure","members":{"DBSubnetGroupName":{},"Filters":{"shape":"S1p"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeDBSubnetGroupsResult","type":"structure","members":{"Marker":{},"DBSubnetGroups":{"type":"list","member":{"shape":"S15","locationName":"DBSubnetGroup"}}}}},"DescribeEngineDefaultClusterParameters":{"input":{"type":"structure","required":["DBParameterGroupFamily"],"members":{"DBParameterGroupFamily":{},"Filters":{"shape":"S1p"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeEngineDefaultClusterParametersResult","type":"structure","members":{"EngineDefaults":{"type":"structure","members":{"DBParameterGroupFamily":{},"Marker":{},"Parameters":{"shape":"S20"}},"wrapper":true}}}},"DescribeEventCategories":{"input":{"type":"structure","members":{"SourceType":{},"Filters":{"shape":"S1p"}}},"output":{"resultWrapper":"DescribeEventCategoriesResult","type":"structure","members":{"EventCategoriesMapList":{"type":"list","member":{"locationName":"EventCategoriesMap","type":"structure","members":{"SourceType":{},"EventCategories":{"shape":"S2y"}},"wrapper":true}}}}},"DescribeEvents":{"input":{"type":"structure","members":{"SourceIdentifier":{},"SourceType":{},"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"Duration":{"type":"integer"},"EventCategories":{"shape":"S2y"},"Filters":{"shape":"S1p"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeEventsResult","type":"structure","members":{"Marker":{},"Events":{"type":"list","member":{"locationName":"Event","type":"structure","members":{"SourceIdentifier":{},"SourceType":{},"Message":{},"EventCategories":{"shape":"S2y"},"Date":{"type":"timestamp"},"SourceArn":{}}}}}}},"DescribeOrderableDBInstanceOptions":{"input":{"type":"structure","required":["Engine"],"members":{"Engine":{},"EngineVersion":{},"DBInstanceClass":{},"LicenseModel":{},"Vpc":{"type":"boolean"},"Filters":{"shape":"S1p"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeOrderableDBInstanceOptionsResult","type":"structure","members":{"OrderableDBInstanceOptions":{"type":"list","member":{"locationName":"OrderableDBInstanceOption","type":"structure","members":{"Engine":{},"EngineVersion":{},"DBInstanceClass":{},"LicenseModel":{},"AvailabilityZones":{"type":"list","member":{"shape":"S18","locationName":"AvailabilityZone"}},"Vpc":{"type":"boolean"}},"wrapper":true}},"Marker":{}}}},"DescribePendingMaintenanceActions":{"input":{"type":"structure","members":{"ResourceIdentifier":{},"Filters":{"shape":"S1p"},"Marker":{},"MaxRecords":{"type":"integer"}}},"output":{"resultWrapper":"DescribePendingMaintenanceActionsResult","type":"structure","members":{"PendingMaintenanceActions":{"type":"list","member":{"shape":"S7","locationName":"ResourcePendingMaintenanceActions"}},"Marker":{}}}},"FailoverDBCluster":{"input":{"type":"structure","members":{"DBClusterIdentifier":{},"TargetDBInstanceIdentifier":{}}},"output":{"resultWrapper":"FailoverDBClusterResult","type":"structure","members":{"DBCluster":{"shape":"Sq"}}}},"ListTagsForResource":{"input":{"type":"structure","required":["ResourceName"],"members":{"ResourceName":{},"Filters":{"shape":"S1p"}}},"output":{"resultWrapper":"ListTagsForResourceResult","type":"structure","members":{"TagList":{"shape":"S3"}}}},"ModifyDBCluster":{"input":{"type":"structure","required":["DBClusterIdentifier"],"members":{"DBClusterIdentifier":{},"NewDBClusterIdentifier":{},"ApplyImmediately":{"type":"boolean"},"BackupRetentionPeriod":{"type":"integer"},"DBClusterParameterGroupName":{},"VpcSecurityGroupIds":{"shape":"Sn"},"Port":{"type":"integer"},"MasterUserPassword":{},"PreferredBackupWindow":{},"PreferredMaintenanceWindow":{},"CloudwatchLogsExportConfiguration":{"type":"structure","members":{"EnableLogTypes":{"shape":"So"},"DisableLogTypes":{"shape":"So"}}},"EngineVersion":{},"DeletionProtection":{"type":"boolean"}}},"output":{"resultWrapper":"ModifyDBClusterResult","type":"structure","members":{"DBCluster":{"shape":"Sq"}}}},"ModifyDBClusterParameterGroup":{"input":{"type":"structure","required":["DBClusterParameterGroupName","Parameters"],"members":{"DBClusterParameterGroupName":{},"Parameters":{"shape":"S20"}}},"output":{"shape":"S3k","resultWrapper":"ModifyDBClusterParameterGroupResult"}},"ModifyDBClusterSnapshotAttribute":{"input":{"type":"structure","required":["DBClusterSnapshotIdentifier","AttributeName"],"members":{"DBClusterSnapshotIdentifier":{},"AttributeName":{},"ValuesToAdd":{"shape":"S28"},"ValuesToRemove":{"shape":"S28"}}},"output":{"resultWrapper":"ModifyDBClusterSnapshotAttributeResult","type":"structure","members":{"DBClusterSnapshotAttributesResult":{"shape":"S25"}}}},"ModifyDBInstance":{"input":{"type":"structure","required":["DBInstanceIdentifier"],"members":{"DBInstanceIdentifier":{},"DBInstanceClass":{},"ApplyImmediately":{"type":"boolean"},"PreferredMaintenanceWindow":{},"AutoMinorVersionUpgrade":{"type":"boolean"},"NewDBInstanceIdentifier":{},"CACertificateIdentifier":{},"PromotionTier":{"type":"integer"}}},"output":{"resultWrapper":"ModifyDBInstanceResult","type":"structure","members":{"DBInstance":{"shape":"S13"}}}},"ModifyDBSubnetGroup":{"input":{"type":"structure","required":["DBSubnetGroupName","SubnetIds"],"members":{"DBSubnetGroupName":{},"DBSubnetGroupDescription":{},"SubnetIds":{"shape":"S1e"}}},"output":{"resultWrapper":"ModifyDBSubnetGroupResult","type":"structure","members":{"DBSubnetGroup":{"shape":"S15"}}}},"RebootDBInstance":{"input":{"type":"structure","required":["DBInstanceIdentifier"],"members":{"DBInstanceIdentifier":{},"ForceFailover":{"type":"boolean"}}},"output":{"resultWrapper":"RebootDBInstanceResult","type":"structure","members":{"DBInstance":{"shape":"S13"}}}},"RemoveTagsFromResource":{"input":{"type":"structure","required":["ResourceName","TagKeys"],"members":{"ResourceName":{},"TagKeys":{"type":"list","member":{}}}}},"ResetDBClusterParameterGroup":{"input":{"type":"structure","required":["DBClusterParameterGroupName"],"members":{"DBClusterParameterGroupName":{},"ResetAllParameters":{"type":"boolean"},"Parameters":{"shape":"S20"}}},"output":{"shape":"S3k","resultWrapper":"ResetDBClusterParameterGroupResult"}},"RestoreDBClusterFromSnapshot":{"input":{"type":"structure","required":["DBClusterIdentifier","SnapshotIdentifier","Engine"],"members":{"AvailabilityZones":{"shape":"Si"},"DBClusterIdentifier":{},"SnapshotIdentifier":{},"Engine":{},"EngineVersion":{},"Port":{"type":"integer"},"DBSubnetGroupName":{},"VpcSecurityGroupIds":{"shape":"Sn"},"Tags":{"shape":"S3"},"KmsKeyId":{},"EnableCloudwatchLogsExports":{"shape":"So"},"DeletionProtection":{"type":"boolean"}}},"output":{"resultWrapper":"RestoreDBClusterFromSnapshotResult","type":"structure","members":{"DBCluster":{"shape":"Sq"}}}},"RestoreDBClusterToPointInTime":{"input":{"type":"structure","required":["DBClusterIdentifier","SourceDBClusterIdentifier"],"members":{"DBClusterIdentifier":{},"SourceDBClusterIdentifier":{},"RestoreToTime":{"type":"timestamp"},"UseLatestRestorableTime":{"type":"boolean"},"Port":{"type":"integer"},"DBSubnetGroupName":{},"VpcSecurityGroupIds":{"shape":"Sn"},"Tags":{"shape":"S3"},"KmsKeyId":{},"EnableCloudwatchLogsExports":{"shape":"So"},"DeletionProtection":{"type":"boolean"}}},"output":{"resultWrapper":"RestoreDBClusterToPointInTimeResult","type":"structure","members":{"DBCluster":{"shape":"Sq"}}}},"StartDBCluster":{"input":{"type":"structure","required":["DBClusterIdentifier"],"members":{"DBClusterIdentifier":{}}},"output":{"resultWrapper":"StartDBClusterResult","type":"structure","members":{"DBCluster":{"shape":"Sq"}}}},"StopDBCluster":{"input":{"type":"structure","required":["DBClusterIdentifier"],"members":{"DBClusterIdentifier":{}}},"output":{"resultWrapper":"StopDBClusterResult","type":"structure","members":{"DBCluster":{"shape":"Sq"}}}}},"shapes":{"S3":{"type":"list","member":{"locationName":"Tag","type":"structure","members":{"Key":{},"Value":{}}}},"S7":{"type":"structure","members":{"ResourceIdentifier":{},"PendingMaintenanceActionDetails":{"type":"list","member":{"locationName":"PendingMaintenanceAction","type":"structure","members":{"Action":{},"AutoAppliedAfterDate":{"type":"timestamp"},"ForcedApplyDate":{"type":"timestamp"},"OptInStatus":{},"CurrentApplyDate":{"type":"timestamp"},"Description":{}}}}},"wrapper":true},"Sd":{"type":"structure","members":{"DBClusterParameterGroupName":{},"DBParameterGroupFamily":{},"Description":{},"DBClusterParameterGroupArn":{}},"wrapper":true},"Sh":{"type":"structure","members":{"AvailabilityZones":{"shape":"Si"},"DBClusterSnapshotIdentifier":{},"DBClusterIdentifier":{},"SnapshotCreateTime":{"type":"timestamp"},"Engine":{},"Status":{},"Port":{"type":"integer"},"VpcId":{},"ClusterCreateTime":{"type":"timestamp"},"MasterUsername":{},"EngineVersion":{},"SnapshotType":{},"PercentProgress":{"type":"integer"},"StorageEncrypted":{"type":"boolean"},"KmsKeyId":{},"DBClusterSnapshotArn":{},"SourceDBClusterSnapshotArn":{}},"wrapper":true},"Si":{"type":"list","member":{"locationName":"AvailabilityZone"}},"Sn":{"type":"list","member":{"locationName":"VpcSecurityGroupId"}},"So":{"type":"list","member":{}},"Sq":{"type":"structure","members":{"AvailabilityZones":{"shape":"Si"},"BackupRetentionPeriod":{"type":"integer"},"DBClusterIdentifier":{},"DBClusterParameterGroup":{},"DBSubnetGroup":{},"Status":{},"PercentProgress":{},"EarliestRestorableTime":{"type":"timestamp"},"Endpoint":{},"ReaderEndpoint":{},"MultiAZ":{"type":"boolean"},"Engine":{},"EngineVersion":{},"LatestRestorableTime":{"type":"timestamp"},"Port":{"type":"integer"},"MasterUsername":{},"PreferredBackupWindow":{},"PreferredMaintenanceWindow":{},"DBClusterMembers":{"type":"list","member":{"locationName":"DBClusterMember","type":"structure","members":{"DBInstanceIdentifier":{},"IsClusterWriter":{"type":"boolean"},"DBClusterParameterGroupStatus":{},"PromotionTier":{"type":"integer"}},"wrapper":true}},"VpcSecurityGroups":{"shape":"St"},"HostedZoneId":{},"StorageEncrypted":{"type":"boolean"},"KmsKeyId":{},"DbClusterResourceId":{},"DBClusterArn":{},"AssociatedRoles":{"type":"list","member":{"locationName":"DBClusterRole","type":"structure","members":{"RoleArn":{},"Status":{}}}},"ClusterCreateTime":{"type":"timestamp"},"EnabledCloudwatchLogsExports":{"shape":"So"},"DeletionProtection":{"type":"boolean"}},"wrapper":true},"St":{"type":"list","member":{"locationName":"VpcSecurityGroupMembership","type":"structure","members":{"VpcSecurityGroupId":{},"Status":{}}}},"S13":{"type":"structure","members":{"DBInstanceIdentifier":{},"DBInstanceClass":{},"Engine":{},"DBInstanceStatus":{},"Endpoint":{"type":"structure","members":{"Address":{},"Port":{"type":"integer"},"HostedZoneId":{}}},"InstanceCreateTime":{"type":"timestamp"},"PreferredBackupWindow":{},"BackupRetentionPeriod":{"type":"integer"},"VpcSecurityGroups":{"shape":"St"},"AvailabilityZone":{},"DBSubnetGroup":{"shape":"S15"},"PreferredMaintenanceWindow":{},"PendingModifiedValues":{"type":"structure","members":{"DBInstanceClass":{},"AllocatedStorage":{"type":"integer"},"MasterUserPassword":{},"Port":{"type":"integer"},"BackupRetentionPeriod":{"type":"integer"},"MultiAZ":{"type":"boolean"},"EngineVersion":{},"LicenseModel":{},"Iops":{"type":"integer"},"DBInstanceIdentifier":{},"StorageType":{},"CACertificateIdentifier":{},"DBSubnetGroupName":{},"PendingCloudwatchLogsExports":{"type":"structure","members":{"LogTypesToEnable":{"shape":"So"},"LogTypesToDisable":{"shape":"So"}}}}},"LatestRestorableTime":{"type":"timestamp"},"EngineVersion":{},"AutoMinorVersionUpgrade":{"type":"boolean"},"PubliclyAccessible":{"type":"boolean"},"StatusInfos":{"type":"list","member":{"locationName":"DBInstanceStatusInfo","type":"structure","members":{"StatusType":{},"Normal":{"type":"boolean"},"Status":{},"Message":{}}}},"DBClusterIdentifier":{},"StorageEncrypted":{"type":"boolean"},"KmsKeyId":{},"DbiResourceId":{},"CACertificateIdentifier":{},"PromotionTier":{"type":"integer"},"DBInstanceArn":{},"EnabledCloudwatchLogsExports":{"shape":"So"}},"wrapper":true},"S15":{"type":"structure","members":{"DBSubnetGroupName":{},"DBSubnetGroupDescription":{},"VpcId":{},"SubnetGroupStatus":{},"Subnets":{"type":"list","member":{"locationName":"Subnet","type":"structure","members":{"SubnetIdentifier":{},"SubnetAvailabilityZone":{"shape":"S18"},"SubnetStatus":{}}}},"DBSubnetGroupArn":{}},"wrapper":true},"S18":{"type":"structure","members":{"Name":{}},"wrapper":true},"S1e":{"type":"list","member":{"locationName":"SubnetIdentifier"}},"S1p":{"type":"list","member":{"locationName":"Filter","type":"structure","required":["Name","Values"],"members":{"Name":{},"Values":{"type":"list","member":{"locationName":"Value"}}}}},"S20":{"type":"list","member":{"locationName":"Parameter","type":"structure","members":{"ParameterName":{},"ParameterValue":{},"Description":{},"Source":{},"ApplyType":{},"DataType":{},"AllowedValues":{},"IsModifiable":{"type":"boolean"},"MinimumEngineVersion":{},"ApplyMethod":{}}}},"S25":{"type":"structure","members":{"DBClusterSnapshotIdentifier":{},"DBClusterSnapshotAttributes":{"type":"list","member":{"locationName":"DBClusterSnapshotAttribute","type":"structure","members":{"AttributeName":{},"AttributeValues":{"shape":"S28"}}}}},"wrapper":true},"S28":{"type":"list","member":{"locationName":"AttributeValue"}},"S2y":{"type":"list","member":{"locationName":"EventCategory"}},"S3k":{"type":"structure","members":{"DBClusterParameterGroupName":{}}}}}; - -/***/ }), - -/***/ 2467: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['accessanalyzer'] = {}; -AWS.AccessAnalyzer = Service.defineService('accessanalyzer', ['2019-11-01']); -Object.defineProperty(apiLoader.services['accessanalyzer'], '2019-11-01', { - get: function get() { - var model = __webpack_require__(4575); - model.paginators = __webpack_require__(7291).pagination; - return model; - }, - enumerable: true, - configurable: true +Object.defineProperty(exports, "isBlob", ({ + enumerable: true, + get: function () { return streamTypeCheck.isBlob; } +})); +Object.defineProperty(exports, "isReadableStream", ({ + enumerable: true, + get: function () { return streamTypeCheck.isReadableStream; } +})); +exports.Uint8ArrayBlobAdapter = Uint8ArrayBlobAdapter; +Object.keys(ChecksumStream).forEach(function (k) { + if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, { + enumerable: true, + get: function () { return ChecksumStream[k]; } + }); +}); +Object.keys(createChecksumStream).forEach(function (k) { + if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, { + enumerable: true, + get: function () { return createChecksumStream[k]; } + }); +}); +Object.keys(createBufferedReadable).forEach(function (k) { + if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, { + enumerable: true, + get: function () { return createBufferedReadable[k]; } + }); +}); +Object.keys(getAwsChunkedEncodingStream).forEach(function (k) { + if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, { + enumerable: true, + get: function () { return getAwsChunkedEncodingStream[k]; } + }); +}); +Object.keys(headStream).forEach(function (k) { + if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, { + enumerable: true, + get: function () { return headStream[k]; } + }); +}); +Object.keys(sdkStreamMixin).forEach(function (k) { + if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, { + enumerable: true, + get: function () { return sdkStreamMixin[k]; } + }); +}); +Object.keys(splitStream).forEach(function (k) { + if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, { + enumerable: true, + get: function () { return splitStream[k]; } + }); }); -module.exports = AWS.AccessAnalyzer; - - -/***/ }), - -/***/ 2474: -/***/ (function(module) { - -module.exports = {"pagination":{}}; /***/ }), -/***/ 2476: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -// Generated by CoffeeScript 1.12.7 -(function() { - "use strict"; - var builder, defaults, escapeCDATA, requiresCDATA, wrapCDATA, - hasProp = {}.hasOwnProperty; - - builder = __webpack_require__(312); - - defaults = __webpack_require__(1514).defaults; - - requiresCDATA = function(entry) { - return typeof entry === "string" && (entry.indexOf('&') >= 0 || entry.indexOf('>') >= 0 || entry.indexOf('<') >= 0); - }; - - wrapCDATA = function(entry) { - return ""; - }; +/***/ 2207: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - escapeCDATA = function(entry) { - return entry.replace(']]>', ']]]]>'); - }; +"use strict"; - exports.Builder = (function() { - function Builder(opts) { - var key, ref, value; - this.options = {}; - ref = defaults["0.2"]; - for (key in ref) { - if (!hasProp.call(ref, key)) continue; - value = ref[key]; - this.options[key] = value; - } - for (key in opts) { - if (!hasProp.call(opts, key)) continue; - value = opts[key]; - this.options[key] = value; - } - } - - Builder.prototype.buildObject = function(rootObj) { - var attrkey, charkey, render, rootElement, rootName; - attrkey = this.options.attrkey; - charkey = this.options.charkey; - if ((Object.keys(rootObj).length === 1) && (this.options.rootName === defaults['0.2'].rootName)) { - rootName = Object.keys(rootObj)[0]; - rootObj = rootObj[rootName]; - } else { - rootName = this.options.rootName; - } - render = (function(_this) { - return function(element, obj) { - var attr, child, entry, index, key, value; - if (typeof obj !== 'object') { - if (_this.options.cdata && requiresCDATA(obj)) { - element.raw(wrapCDATA(obj)); - } else { - element.txt(obj); - } - } else if (Array.isArray(obj)) { - for (index in obj) { - if (!hasProp.call(obj, index)) continue; - child = obj[index]; - for (key in child) { - entry = child[key]; - element = render(element.ele(key), entry).up(); - } +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.sdkStreamMixin = void 0; +const fetch_http_handler_1 = __nccwpck_require__(7809); +const util_base64_1 = __nccwpck_require__(8385); +const util_hex_encoding_1 = __nccwpck_require__(6435); +const util_utf8_1 = __nccwpck_require__(1577); +const stream_type_check_1 = __nccwpck_require__(4414); +const ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED = "The stream has already been transformed."; +const sdkStreamMixin = (stream) => { + if (!isBlobInstance(stream) && !(0, stream_type_check_1.isReadableStream)(stream)) { + const name = stream?.__proto__?.constructor?.name || stream; + throw new Error(`Unexpected stream implementation, expect Blob or ReadableStream, got ${name}`); + } + let transformed = false; + const transformToByteArray = async () => { + if (transformed) { + throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED); + } + transformed = true; + return await (0, fetch_http_handler_1.streamCollector)(stream); + }; + const blobToWebStream = (blob) => { + if (typeof blob.stream !== "function") { + throw new Error("Cannot transform payload Blob to web stream. Please make sure the Blob.stream() is polyfilled.\n" + + "If you are using React Native, this API is not yet supported, see: https://react-native.canny.io/feature-requests/p/fetch-streaming-body"); + } + return blob.stream(); + }; + return Object.assign(stream, { + transformToByteArray: transformToByteArray, + transformToString: async (encoding) => { + const buf = await transformToByteArray(); + if (encoding === "base64") { + return (0, util_base64_1.toBase64)(buf); } - } else { - for (key in obj) { - if (!hasProp.call(obj, key)) continue; - child = obj[key]; - if (key === attrkey) { - if (typeof child === "object") { - for (attr in child) { - value = child[attr]; - element = element.att(attr, value); - } - } - } else if (key === charkey) { - if (_this.options.cdata && requiresCDATA(child)) { - element = element.raw(wrapCDATA(child)); - } else { - element = element.txt(child); - } - } else if (Array.isArray(child)) { - for (index in child) { - if (!hasProp.call(child, index)) continue; - entry = child[index]; - if (typeof entry === 'string') { - if (_this.options.cdata && requiresCDATA(entry)) { - element = element.ele(key).raw(wrapCDATA(entry)).up(); - } else { - element = element.ele(key, entry).up(); - } - } else { - element = render(element.ele(key), entry).up(); - } - } - } else if (typeof child === "object") { - element = render(element.ele(key), child).up(); - } else { - if (typeof child === 'string' && _this.options.cdata && requiresCDATA(child)) { - element = element.ele(key).raw(wrapCDATA(child)).up(); - } else { - if (child == null) { - child = ''; - } - element = element.ele(key, child.toString()).up(); - } - } + else if (encoding === "hex") { + return (0, util_hex_encoding_1.toHex)(buf); } - } - return element; - }; - })(this); - rootElement = builder.create(rootName, this.options.xmldec, this.options.doctype, { - headless: this.options.headless, - allowSurrogateChars: this.options.allowSurrogateChars - }); - return render(rootElement, rootObj).end(this.options.renderOpts); - }; - - return Builder; - - })(); - -}).call(this); - - -/***/ }), - -/***/ 2481: -/***/ (function(module) { - -module.exports = {"pagination":{"GetUsageStatistics":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListDetectors":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults","result_key":"DetectorIds"},"ListFilters":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults","result_key":"FilterNames"},"ListFindings":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults","result_key":"FindingIds"},"ListIPSets":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults","result_key":"IpSetIds"},"ListInvitations":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults","result_key":"Invitations"},"ListMembers":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults","result_key":"Members"},"ListOrganizationAdminAccounts":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults","result_key":"AdminAccounts"},"ListPublishingDestinations":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListThreatIntelSets":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults","result_key":"ThreatIntelSetIds"}}}; - -/***/ }), - -/***/ 2490: -/***/ (function(module) { + else if (encoding === undefined || encoding === "utf8" || encoding === "utf-8") { + return (0, util_utf8_1.toUtf8)(buf); + } + else if (typeof TextDecoder === "function") { + return new TextDecoder(encoding).decode(buf); + } + else { + throw new Error("TextDecoder is not available, please make sure polyfill is provided."); + } + }, + transformToWebStream: () => { + if (transformed) { + throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED); + } + transformed = true; + if (isBlobInstance(stream)) { + return blobToWebStream(stream); + } + else if ((0, stream_type_check_1.isReadableStream)(stream)) { + return stream; + } + else { + throw new Error(`Cannot transform payload to web stream, got ${stream}`); + } + }, + }); +}; +exports.sdkStreamMixin = sdkStreamMixin; +const isBlobInstance = (stream) => typeof Blob === "function" && stream instanceof Blob; -module.exports = {"version":"2.0","metadata":{"apiVersion":"2018-02-27","endpointPrefix":"pi","jsonVersion":"1.1","protocol":"json","serviceAbbreviation":"AWS PI","serviceFullName":"AWS Performance Insights","serviceId":"PI","signatureVersion":"v4","signingName":"pi","targetPrefix":"PerformanceInsightsv20180227","uid":"pi-2018-02-27"},"operations":{"DescribeDimensionKeys":{"input":{"type":"structure","required":["ServiceType","Identifier","StartTime","EndTime","Metric","GroupBy"],"members":{"ServiceType":{},"Identifier":{},"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"Metric":{},"PeriodInSeconds":{"type":"integer"},"GroupBy":{"shape":"S6"},"PartitionBy":{"shape":"S6"},"Filter":{"shape":"S9"},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"AlignedStartTime":{"type":"timestamp"},"AlignedEndTime":{"type":"timestamp"},"PartitionKeys":{"type":"list","member":{"type":"structure","required":["Dimensions"],"members":{"Dimensions":{"shape":"Se"}}}},"Keys":{"type":"list","member":{"type":"structure","members":{"Dimensions":{"shape":"Se"},"Total":{"type":"double"},"Partitions":{"type":"list","member":{"type":"double"}}}}},"NextToken":{}}}},"GetResourceMetrics":{"input":{"type":"structure","required":["ServiceType","Identifier","MetricQueries","StartTime","EndTime"],"members":{"ServiceType":{},"Identifier":{},"MetricQueries":{"type":"list","member":{"type":"structure","required":["Metric"],"members":{"Metric":{},"GroupBy":{"shape":"S6"},"Filter":{"shape":"S9"}}}},"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"PeriodInSeconds":{"type":"integer"},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"AlignedStartTime":{"type":"timestamp"},"AlignedEndTime":{"type":"timestamp"},"Identifier":{},"MetricList":{"type":"list","member":{"type":"structure","members":{"Key":{"type":"structure","required":["Metric"],"members":{"Metric":{},"Dimensions":{"shape":"Se"}}},"DataPoints":{"type":"list","member":{"type":"structure","required":["Timestamp","Value"],"members":{"Timestamp":{"type":"timestamp"},"Value":{"type":"double"}}}}}}},"NextToken":{}}}}},"shapes":{"S6":{"type":"structure","required":["Group"],"members":{"Group":{},"Dimensions":{"type":"list","member":{}},"Limit":{"type":"integer"}}},"S9":{"type":"map","key":{},"value":{}},"Se":{"type":"map","key":{},"value":{}}}}; /***/ }), -/***/ 2491: -/***/ (function(module, __unusedexports, __webpack_require__) { - -// Generated by CoffeeScript 1.12.7 -(function() { - var XMLNode, XMLProcessingInstruction, - extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, - hasProp = {}.hasOwnProperty; +/***/ 7201: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - XMLNode = __webpack_require__(6855); - - module.exports = XMLProcessingInstruction = (function(superClass) { - extend(XMLProcessingInstruction, superClass); +"use strict"; - function XMLProcessingInstruction(parent, target, value) { - XMLProcessingInstruction.__super__.constructor.call(this, parent); - if (target == null) { - throw new Error("Missing instruction target"); - } - this.target = this.stringify.insTarget(target); - if (value) { - this.value = this.stringify.insValue(value); - } +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.sdkStreamMixin = void 0; +const node_http_handler_1 = __nccwpck_require__(9245); +const util_buffer_from_1 = __nccwpck_require__(4151); +const stream_1 = __nccwpck_require__(2203); +const sdk_stream_mixin_browser_1 = __nccwpck_require__(2207); +const ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED = "The stream has already been transformed."; +const sdkStreamMixin = (stream) => { + if (!(stream instanceof stream_1.Readable)) { + try { + return (0, sdk_stream_mixin_browser_1.sdkStreamMixin)(stream); + } + catch (e) { + const name = stream?.__proto__?.constructor?.name || stream; + throw new Error(`Unexpected stream implementation, expect Stream.Readable instance, got ${name}`); + } } - - XMLProcessingInstruction.prototype.clone = function() { - return Object.create(this); - }; - - XMLProcessingInstruction.prototype.toString = function(options) { - return this.options.writer.set(options).processingInstruction(this); + let transformed = false; + const transformToByteArray = async () => { + if (transformed) { + throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED); + } + transformed = true; + return await (0, node_http_handler_1.streamCollector)(stream); }; - - return XMLProcessingInstruction; - - })(XMLNode); - -}).call(this); + return Object.assign(stream, { + transformToByteArray, + transformToString: async (encoding) => { + const buf = await transformToByteArray(); + if (encoding === undefined || Buffer.isEncoding(encoding)) { + return (0, util_buffer_from_1.fromArrayBuffer)(buf.buffer, buf.byteOffset, buf.byteLength).toString(encoding); + } + else { + const decoder = new TextDecoder(encoding); + return decoder.decode(buf); + } + }, + transformToWebStream: () => { + if (transformed) { + throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED); + } + if (stream.readableFlowing !== null) { + throw new Error("The stream has been consumed by other callbacks."); + } + if (typeof stream_1.Readable.toWeb !== "function") { + throw new Error("Readable.toWeb() is not supported. Please ensure a polyfill is available."); + } + transformed = true; + return stream_1.Readable.toWeb(stream); + }, + }); +}; +exports.sdkStreamMixin = sdkStreamMixin; /***/ }), -/***/ 2492: -/***/ (function(module, __unusedexports, __webpack_require__) { - -var util = __webpack_require__(153); -var XmlNode = __webpack_require__(404).XmlNode; -var XmlText = __webpack_require__(4948).XmlText; +/***/ 7570: +/***/ ((__unused_webpack_module, exports) => { -function XmlBuilder() { } - -XmlBuilder.prototype.toXML = function(params, shape, rootElement, noEmpty) { - var xml = new XmlNode(rootElement); - applyNamespaces(xml, shape, true); - serialize(xml, params, shape); - return xml.children.length > 0 || noEmpty ? xml.toString() : ''; -}; - -function serialize(xml, value, shape) { - switch (shape.type) { - case 'structure': return serializeStructure(xml, value, shape); - case 'map': return serializeMap(xml, value, shape); - case 'list': return serializeList(xml, value, shape); - default: return serializeScalar(xml, value, shape); - } -} - -function serializeStructure(xml, params, shape) { - util.arrayEach(shape.memberNames, function(memberName) { - var memberShape = shape.members[memberName]; - if (memberShape.location !== 'body') return; +"use strict"; - var value = params[memberName]; - var name = memberShape.name; - if (value !== undefined && value !== null) { - if (memberShape.isXmlAttribute) { - xml.addAttribute(name, value); - } else if (memberShape.flattened) { - serialize(xml, value, memberShape); - } else { - var element = new XmlNode(name); - xml.addChildNode(element); - applyNamespaces(element, memberShape); - serialize(element, value, memberShape); - } +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.splitStream = splitStream; +async function splitStream(stream) { + if (typeof stream.stream === "function") { + stream = stream.stream(); } - }); + const readableStream = stream; + return readableStream.tee(); } -function serializeMap(xml, map, shape) { - var xmlKey = shape.key.name || 'key'; - var xmlValue = shape.value.name || 'value'; - - util.each(map, function(key, value) { - var entry = new XmlNode(shape.flattened ? shape.name : 'entry'); - xml.addChildNode(entry); - - var entryKey = new XmlNode(xmlKey); - var entryValue = new XmlNode(xmlValue); - entry.addChildNode(entryKey); - entry.addChildNode(entryValue); - serialize(entryKey, key, shape.key); - serialize(entryValue, value, shape.value); - }); -} - -function serializeList(xml, list, shape) { - if (shape.flattened) { - util.arrayEach(list, function(value) { - var name = shape.member.name || shape.name; - var element = new XmlNode(name); - xml.addChildNode(element); - serialize(element, value, shape.member); - }); - } else { - util.arrayEach(list, function(value) { - var name = shape.member.name || 'member'; - var element = new XmlNode(name); - xml.addChildNode(element); - serialize(element, value, shape.member); - }); - } -} +/***/ }), -function serializeScalar(xml, value, shape) { - xml.addChildNode( - new XmlText(shape.toWireFormat(value)) - ); -} +/***/ 2108: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -function applyNamespaces(xml, shape, isRoot) { - var uri, prefix = 'xmlns'; - if (shape.xmlNamespaceUri) { - uri = shape.xmlNamespaceUri; - if (shape.xmlNamespacePrefix) prefix += ':' + shape.xmlNamespacePrefix; - } else if (isRoot && shape.api.xmlNamespaceUri) { - uri = shape.api.xmlNamespaceUri; - } +"use strict"; - if (uri) xml.addAttribute(prefix, uri); +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.splitStream = splitStream; +const stream_1 = __nccwpck_require__(2203); +const splitStream_browser_1 = __nccwpck_require__(7570); +const stream_type_check_1 = __nccwpck_require__(4414); +async function splitStream(stream) { + if ((0, stream_type_check_1.isReadableStream)(stream) || (0, stream_type_check_1.isBlob)(stream)) { + return (0, splitStream_browser_1.splitStream)(stream); + } + const stream1 = new stream_1.PassThrough(); + const stream2 = new stream_1.PassThrough(); + stream.pipe(stream1); + stream.pipe(stream2); + return [stream1, stream2]; } -/** - * @api private - */ -module.exports = XmlBuilder; - - -/***/ }), - -/***/ 2510: -/***/ (function(module) { - -module.exports = {"pagination":{"ListSigningJobs":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"ListSigningPlatforms":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"ListSigningProfiles":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"}}}; /***/ }), -/***/ 2522: -/***/ (function(module) { - -module.exports = {"pagination":{"GetOfferingStatus":{"input_token":"nextToken","output_token":"nextToken","result_key":["current","nextPeriod"]},"ListArtifacts":{"input_token":"nextToken","output_token":"nextToken","result_key":"artifacts"},"ListDevicePools":{"input_token":"nextToken","output_token":"nextToken","result_key":"devicePools"},"ListDevices":{"input_token":"nextToken","output_token":"nextToken","result_key":"devices"},"ListJobs":{"input_token":"nextToken","output_token":"nextToken","result_key":"jobs"},"ListOfferingTransactions":{"input_token":"nextToken","output_token":"nextToken","result_key":"offeringTransactions"},"ListOfferings":{"input_token":"nextToken","output_token":"nextToken","result_key":"offerings"},"ListProjects":{"input_token":"nextToken","output_token":"nextToken","result_key":"projects"},"ListRuns":{"input_token":"nextToken","output_token":"nextToken","result_key":"runs"},"ListSamples":{"input_token":"nextToken","output_token":"nextToken","result_key":"samples"},"ListSuites":{"input_token":"nextToken","output_token":"nextToken","result_key":"suites"},"ListTestGridProjects":{"input_token":"nextToken","limit_key":"maxResult","output_token":"nextToken"},"ListTestGridSessionActions":{"input_token":"nextToken","limit_key":"maxResult","output_token":"nextToken"},"ListTestGridSessionArtifacts":{"input_token":"nextToken","limit_key":"maxResult","output_token":"nextToken"},"ListTestGridSessions":{"input_token":"nextToken","limit_key":"maxResult","output_token":"nextToken"},"ListTests":{"input_token":"nextToken","output_token":"nextToken","result_key":"tests"},"ListUniqueProblems":{"input_token":"nextToken","output_token":"nextToken","result_key":"uniqueProblems"},"ListUploads":{"input_token":"nextToken","output_token":"nextToken","result_key":"uploads"}}}; +/***/ 4414: +/***/ ((__unused_webpack_module, exports) => { -/***/ }), +"use strict"; -/***/ 2528: -/***/ (function(module) { +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.isBlob = exports.isReadableStream = void 0; +const isReadableStream = (stream) => typeof ReadableStream === "function" && + (stream?.constructor?.name === ReadableStream.name || stream instanceof ReadableStream); +exports.isReadableStream = isReadableStream; +const isBlob = (blob) => { + return typeof Blob === "function" && (blob?.constructor?.name === Blob.name || blob instanceof Blob); +}; +exports.isBlob = isBlob; -module.exports = {"version":"2.0","metadata":{"apiVersion":"2017-01-06","endpointPrefix":"cur","jsonVersion":"1.1","protocol":"json","serviceFullName":"AWS Cost and Usage Report Service","serviceId":"Cost and Usage Report Service","signatureVersion":"v4","signingName":"cur","targetPrefix":"AWSOrigamiServiceGatewayService","uid":"cur-2017-01-06"},"operations":{"DeleteReportDefinition":{"input":{"type":"structure","members":{"ReportName":{}}},"output":{"type":"structure","members":{"ResponseMessage":{}}}},"DescribeReportDefinitions":{"input":{"type":"structure","members":{"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"ReportDefinitions":{"type":"list","member":{"shape":"Sa"}},"NextToken":{}}}},"ModifyReportDefinition":{"input":{"type":"structure","required":["ReportName","ReportDefinition"],"members":{"ReportName":{},"ReportDefinition":{"shape":"Sa"}}},"output":{"type":"structure","members":{}}},"PutReportDefinition":{"input":{"type":"structure","required":["ReportDefinition"],"members":{"ReportDefinition":{"shape":"Sa"}}},"output":{"type":"structure","members":{}}}},"shapes":{"Sa":{"type":"structure","required":["ReportName","TimeUnit","Format","Compression","AdditionalSchemaElements","S3Bucket","S3Prefix","S3Region"],"members":{"ReportName":{},"TimeUnit":{},"Format":{},"Compression":{},"AdditionalSchemaElements":{"type":"list","member":{}},"S3Bucket":{},"S3Prefix":{},"S3Region":{},"AdditionalArtifacts":{"type":"list","member":{}},"RefreshClosedReports":{"type":"boolean"},"ReportVersioning":{}}}}}; /***/ }), -/***/ 2533: -/***/ (function(module) { +/***/ 9245: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -module.exports = {"version":"2.0","metadata":{"apiVersion":"2015-07-09","endpointPrefix":"apigateway","protocol":"rest-json","serviceFullName":"Amazon API Gateway","serviceId":"API Gateway","signatureVersion":"v4","uid":"apigateway-2015-07-09"},"operations":{"CreateApiKey":{"http":{"requestUri":"/apikeys","responseCode":201},"input":{"type":"structure","members":{"name":{},"description":{},"enabled":{"type":"boolean"},"generateDistinctId":{"type":"boolean"},"value":{},"stageKeys":{"type":"list","member":{"type":"structure","members":{"restApiId":{},"stageName":{}}}},"customerId":{},"tags":{"shape":"S6"}}},"output":{"shape":"S7"}},"CreateAuthorizer":{"http":{"requestUri":"/restapis/{restapi_id}/authorizers","responseCode":201},"input":{"type":"structure","required":["restApiId","name","type"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"name":{},"type":{},"providerARNs":{"shape":"Sc"},"authType":{},"authorizerUri":{},"authorizerCredentials":{},"identitySource":{},"identityValidationExpression":{},"authorizerResultTtlInSeconds":{"type":"integer"}}},"output":{"shape":"Sf"}},"CreateBasePathMapping":{"http":{"requestUri":"/domainnames/{domain_name}/basepathmappings","responseCode":201},"input":{"type":"structure","required":["domainName","restApiId"],"members":{"domainName":{"location":"uri","locationName":"domain_name"},"basePath":{},"restApiId":{},"stage":{}}},"output":{"shape":"Sh"}},"CreateDeployment":{"http":{"requestUri":"/restapis/{restapi_id}/deployments","responseCode":201},"input":{"type":"structure","required":["restApiId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"stageName":{},"stageDescription":{},"description":{},"cacheClusterEnabled":{"type":"boolean"},"cacheClusterSize":{},"variables":{"shape":"S6"},"canarySettings":{"type":"structure","members":{"percentTraffic":{"type":"double"},"stageVariableOverrides":{"shape":"S6"},"useStageCache":{"type":"boolean"}}},"tracingEnabled":{"type":"boolean"}}},"output":{"shape":"Sn"}},"CreateDocumentationPart":{"http":{"requestUri":"/restapis/{restapi_id}/documentation/parts","responseCode":201},"input":{"type":"structure","required":["restApiId","location","properties"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"location":{"shape":"Ss"},"properties":{}}},"output":{"shape":"Sv"}},"CreateDocumentationVersion":{"http":{"requestUri":"/restapis/{restapi_id}/documentation/versions","responseCode":201},"input":{"type":"structure","required":["restApiId","documentationVersion"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"documentationVersion":{},"stageName":{},"description":{}}},"output":{"shape":"Sx"}},"CreateDomainName":{"http":{"requestUri":"/domainnames","responseCode":201},"input":{"type":"structure","required":["domainName"],"members":{"domainName":{},"certificateName":{},"certificateBody":{},"certificatePrivateKey":{},"certificateChain":{},"certificateArn":{},"regionalCertificateName":{},"regionalCertificateArn":{},"endpointConfiguration":{"shape":"Sz"},"tags":{"shape":"S6"},"securityPolicy":{}}},"output":{"shape":"S13"}},"CreateModel":{"http":{"requestUri":"/restapis/{restapi_id}/models","responseCode":201},"input":{"type":"structure","required":["restApiId","name","contentType"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"name":{},"description":{},"schema":{},"contentType":{}}},"output":{"shape":"S16"}},"CreateRequestValidator":{"http":{"requestUri":"/restapis/{restapi_id}/requestvalidators","responseCode":201},"input":{"type":"structure","required":["restApiId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"name":{},"validateRequestBody":{"type":"boolean"},"validateRequestParameters":{"type":"boolean"}}},"output":{"shape":"S18"}},"CreateResource":{"http":{"requestUri":"/restapis/{restapi_id}/resources/{parent_id}","responseCode":201},"input":{"type":"structure","required":["restApiId","parentId","pathPart"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"parentId":{"location":"uri","locationName":"parent_id"},"pathPart":{}}},"output":{"shape":"S1a"}},"CreateRestApi":{"http":{"requestUri":"/restapis","responseCode":201},"input":{"type":"structure","required":["name"],"members":{"name":{},"description":{},"version":{},"cloneFrom":{},"binaryMediaTypes":{"shape":"S9"},"minimumCompressionSize":{"type":"integer"},"apiKeySource":{},"endpointConfiguration":{"shape":"Sz"},"policy":{},"tags":{"shape":"S6"}}},"output":{"shape":"S1r"}},"CreateStage":{"http":{"requestUri":"/restapis/{restapi_id}/stages","responseCode":201},"input":{"type":"structure","required":["restApiId","stageName","deploymentId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"stageName":{},"deploymentId":{},"description":{},"cacheClusterEnabled":{"type":"boolean"},"cacheClusterSize":{},"variables":{"shape":"S6"},"documentationVersion":{},"canarySettings":{"shape":"S1t"},"tracingEnabled":{"type":"boolean"},"tags":{"shape":"S6"}}},"output":{"shape":"S1u"}},"CreateUsagePlan":{"http":{"requestUri":"/usageplans","responseCode":201},"input":{"type":"structure","required":["name"],"members":{"name":{},"description":{},"apiStages":{"shape":"S21"},"throttle":{"shape":"S24"},"quota":{"shape":"S25"},"tags":{"shape":"S6"}}},"output":{"shape":"S27"}},"CreateUsagePlanKey":{"http":{"requestUri":"/usageplans/{usageplanId}/keys","responseCode":201},"input":{"type":"structure","required":["usagePlanId","keyId","keyType"],"members":{"usagePlanId":{"location":"uri","locationName":"usageplanId"},"keyId":{},"keyType":{}}},"output":{"shape":"S29"}},"CreateVpcLink":{"http":{"requestUri":"/vpclinks","responseCode":202},"input":{"type":"structure","required":["name","targetArns"],"members":{"name":{},"description":{},"targetArns":{"shape":"S9"},"tags":{"shape":"S6"}}},"output":{"shape":"S2b"}},"DeleteApiKey":{"http":{"method":"DELETE","requestUri":"/apikeys/{api_Key}","responseCode":202},"input":{"type":"structure","required":["apiKey"],"members":{"apiKey":{"location":"uri","locationName":"api_Key"}}}},"DeleteAuthorizer":{"http":{"method":"DELETE","requestUri":"/restapis/{restapi_id}/authorizers/{authorizer_id}","responseCode":202},"input":{"type":"structure","required":["restApiId","authorizerId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"authorizerId":{"location":"uri","locationName":"authorizer_id"}}}},"DeleteBasePathMapping":{"http":{"method":"DELETE","requestUri":"/domainnames/{domain_name}/basepathmappings/{base_path}","responseCode":202},"input":{"type":"structure","required":["domainName","basePath"],"members":{"domainName":{"location":"uri","locationName":"domain_name"},"basePath":{"location":"uri","locationName":"base_path"}}}},"DeleteClientCertificate":{"http":{"method":"DELETE","requestUri":"/clientcertificates/{clientcertificate_id}","responseCode":202},"input":{"type":"structure","required":["clientCertificateId"],"members":{"clientCertificateId":{"location":"uri","locationName":"clientcertificate_id"}}}},"DeleteDeployment":{"http":{"method":"DELETE","requestUri":"/restapis/{restapi_id}/deployments/{deployment_id}","responseCode":202},"input":{"type":"structure","required":["restApiId","deploymentId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"deploymentId":{"location":"uri","locationName":"deployment_id"}}}},"DeleteDocumentationPart":{"http":{"method":"DELETE","requestUri":"/restapis/{restapi_id}/documentation/parts/{part_id}","responseCode":202},"input":{"type":"structure","required":["restApiId","documentationPartId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"documentationPartId":{"location":"uri","locationName":"part_id"}}}},"DeleteDocumentationVersion":{"http":{"method":"DELETE","requestUri":"/restapis/{restapi_id}/documentation/versions/{doc_version}","responseCode":202},"input":{"type":"structure","required":["restApiId","documentationVersion"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"documentationVersion":{"location":"uri","locationName":"doc_version"}}}},"DeleteDomainName":{"http":{"method":"DELETE","requestUri":"/domainnames/{domain_name}","responseCode":202},"input":{"type":"structure","required":["domainName"],"members":{"domainName":{"location":"uri","locationName":"domain_name"}}}},"DeleteGatewayResponse":{"http":{"method":"DELETE","requestUri":"/restapis/{restapi_id}/gatewayresponses/{response_type}","responseCode":202},"input":{"type":"structure","required":["restApiId","responseType"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"responseType":{"location":"uri","locationName":"response_type"}}}},"DeleteIntegration":{"http":{"method":"DELETE","requestUri":"/restapis/{restapi_id}/resources/{resource_id}/methods/{http_method}/integration","responseCode":204},"input":{"type":"structure","required":["restApiId","resourceId","httpMethod"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"resourceId":{"location":"uri","locationName":"resource_id"},"httpMethod":{"location":"uri","locationName":"http_method"}}}},"DeleteIntegrationResponse":{"http":{"method":"DELETE","requestUri":"/restapis/{restapi_id}/resources/{resource_id}/methods/{http_method}/integration/responses/{status_code}","responseCode":204},"input":{"type":"structure","required":["restApiId","resourceId","httpMethod","statusCode"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"resourceId":{"location":"uri","locationName":"resource_id"},"httpMethod":{"location":"uri","locationName":"http_method"},"statusCode":{"location":"uri","locationName":"status_code"}}}},"DeleteMethod":{"http":{"method":"DELETE","requestUri":"/restapis/{restapi_id}/resources/{resource_id}/methods/{http_method}","responseCode":204},"input":{"type":"structure","required":["restApiId","resourceId","httpMethod"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"resourceId":{"location":"uri","locationName":"resource_id"},"httpMethod":{"location":"uri","locationName":"http_method"}}}},"DeleteMethodResponse":{"http":{"method":"DELETE","requestUri":"/restapis/{restapi_id}/resources/{resource_id}/methods/{http_method}/responses/{status_code}","responseCode":204},"input":{"type":"structure","required":["restApiId","resourceId","httpMethod","statusCode"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"resourceId":{"location":"uri","locationName":"resource_id"},"httpMethod":{"location":"uri","locationName":"http_method"},"statusCode":{"location":"uri","locationName":"status_code"}}}},"DeleteModel":{"http":{"method":"DELETE","requestUri":"/restapis/{restapi_id}/models/{model_name}","responseCode":202},"input":{"type":"structure","required":["restApiId","modelName"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"modelName":{"location":"uri","locationName":"model_name"}}}},"DeleteRequestValidator":{"http":{"method":"DELETE","requestUri":"/restapis/{restapi_id}/requestvalidators/{requestvalidator_id}","responseCode":202},"input":{"type":"structure","required":["restApiId","requestValidatorId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"requestValidatorId":{"location":"uri","locationName":"requestvalidator_id"}}}},"DeleteResource":{"http":{"method":"DELETE","requestUri":"/restapis/{restapi_id}/resources/{resource_id}","responseCode":202},"input":{"type":"structure","required":["restApiId","resourceId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"resourceId":{"location":"uri","locationName":"resource_id"}}}},"DeleteRestApi":{"http":{"method":"DELETE","requestUri":"/restapis/{restapi_id}","responseCode":202},"input":{"type":"structure","required":["restApiId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"}}}},"DeleteStage":{"http":{"method":"DELETE","requestUri":"/restapis/{restapi_id}/stages/{stage_name}","responseCode":202},"input":{"type":"structure","required":["restApiId","stageName"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"stageName":{"location":"uri","locationName":"stage_name"}}}},"DeleteUsagePlan":{"http":{"method":"DELETE","requestUri":"/usageplans/{usageplanId}","responseCode":202},"input":{"type":"structure","required":["usagePlanId"],"members":{"usagePlanId":{"location":"uri","locationName":"usageplanId"}}}},"DeleteUsagePlanKey":{"http":{"method":"DELETE","requestUri":"/usageplans/{usageplanId}/keys/{keyId}","responseCode":202},"input":{"type":"structure","required":["usagePlanId","keyId"],"members":{"usagePlanId":{"location":"uri","locationName":"usageplanId"},"keyId":{"location":"uri","locationName":"keyId"}}}},"DeleteVpcLink":{"http":{"method":"DELETE","requestUri":"/vpclinks/{vpclink_id}","responseCode":202},"input":{"type":"structure","required":["vpcLinkId"],"members":{"vpcLinkId":{"location":"uri","locationName":"vpclink_id"}}}},"FlushStageAuthorizersCache":{"http":{"method":"DELETE","requestUri":"/restapis/{restapi_id}/stages/{stage_name}/cache/authorizers","responseCode":202},"input":{"type":"structure","required":["restApiId","stageName"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"stageName":{"location":"uri","locationName":"stage_name"}}}},"FlushStageCache":{"http":{"method":"DELETE","requestUri":"/restapis/{restapi_id}/stages/{stage_name}/cache/data","responseCode":202},"input":{"type":"structure","required":["restApiId","stageName"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"stageName":{"location":"uri","locationName":"stage_name"}}}},"GenerateClientCertificate":{"http":{"requestUri":"/clientcertificates","responseCode":201},"input":{"type":"structure","members":{"description":{},"tags":{"shape":"S6"}}},"output":{"shape":"S32"}},"GetAccount":{"http":{"method":"GET","requestUri":"/account"},"input":{"type":"structure","members":{}},"output":{"shape":"S34"}},"GetApiKey":{"http":{"method":"GET","requestUri":"/apikeys/{api_Key}"},"input":{"type":"structure","required":["apiKey"],"members":{"apiKey":{"location":"uri","locationName":"api_Key"},"includeValue":{"location":"querystring","locationName":"includeValue","type":"boolean"}}},"output":{"shape":"S7"}},"GetApiKeys":{"http":{"method":"GET","requestUri":"/apikeys"},"input":{"type":"structure","members":{"position":{"location":"querystring","locationName":"position"},"limit":{"location":"querystring","locationName":"limit","type":"integer"},"nameQuery":{"location":"querystring","locationName":"name"},"customerId":{"location":"querystring","locationName":"customerId"},"includeValues":{"location":"querystring","locationName":"includeValues","type":"boolean"}}},"output":{"type":"structure","members":{"warnings":{"shape":"S9"},"position":{},"items":{"locationName":"item","type":"list","member":{"shape":"S7"}}}}},"GetAuthorizer":{"http":{"method":"GET","requestUri":"/restapis/{restapi_id}/authorizers/{authorizer_id}"},"input":{"type":"structure","required":["restApiId","authorizerId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"authorizerId":{"location":"uri","locationName":"authorizer_id"}}},"output":{"shape":"Sf"}},"GetAuthorizers":{"http":{"method":"GET","requestUri":"/restapis/{restapi_id}/authorizers"},"input":{"type":"structure","required":["restApiId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"position":{"location":"querystring","locationName":"position"},"limit":{"location":"querystring","locationName":"limit","type":"integer"}}},"output":{"type":"structure","members":{"position":{},"items":{"locationName":"item","type":"list","member":{"shape":"Sf"}}}}},"GetBasePathMapping":{"http":{"method":"GET","requestUri":"/domainnames/{domain_name}/basepathmappings/{base_path}"},"input":{"type":"structure","required":["domainName","basePath"],"members":{"domainName":{"location":"uri","locationName":"domain_name"},"basePath":{"location":"uri","locationName":"base_path"}}},"output":{"shape":"Sh"}},"GetBasePathMappings":{"http":{"method":"GET","requestUri":"/domainnames/{domain_name}/basepathmappings"},"input":{"type":"structure","required":["domainName"],"members":{"domainName":{"location":"uri","locationName":"domain_name"},"position":{"location":"querystring","locationName":"position"},"limit":{"location":"querystring","locationName":"limit","type":"integer"}}},"output":{"type":"structure","members":{"position":{},"items":{"locationName":"item","type":"list","member":{"shape":"Sh"}}}}},"GetClientCertificate":{"http":{"method":"GET","requestUri":"/clientcertificates/{clientcertificate_id}"},"input":{"type":"structure","required":["clientCertificateId"],"members":{"clientCertificateId":{"location":"uri","locationName":"clientcertificate_id"}}},"output":{"shape":"S32"}},"GetClientCertificates":{"http":{"method":"GET","requestUri":"/clientcertificates"},"input":{"type":"structure","members":{"position":{"location":"querystring","locationName":"position"},"limit":{"location":"querystring","locationName":"limit","type":"integer"}}},"output":{"type":"structure","members":{"position":{},"items":{"locationName":"item","type":"list","member":{"shape":"S32"}}}}},"GetDeployment":{"http":{"method":"GET","requestUri":"/restapis/{restapi_id}/deployments/{deployment_id}"},"input":{"type":"structure","required":["restApiId","deploymentId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"deploymentId":{"location":"uri","locationName":"deployment_id"},"embed":{"shape":"S9","location":"querystring","locationName":"embed"}}},"output":{"shape":"Sn"}},"GetDeployments":{"http":{"method":"GET","requestUri":"/restapis/{restapi_id}/deployments"},"input":{"type":"structure","required":["restApiId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"position":{"location":"querystring","locationName":"position"},"limit":{"location":"querystring","locationName":"limit","type":"integer"}}},"output":{"type":"structure","members":{"position":{},"items":{"locationName":"item","type":"list","member":{"shape":"Sn"}}}}},"GetDocumentationPart":{"http":{"method":"GET","requestUri":"/restapis/{restapi_id}/documentation/parts/{part_id}"},"input":{"type":"structure","required":["restApiId","documentationPartId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"documentationPartId":{"location":"uri","locationName":"part_id"}}},"output":{"shape":"Sv"}},"GetDocumentationParts":{"http":{"method":"GET","requestUri":"/restapis/{restapi_id}/documentation/parts"},"input":{"type":"structure","required":["restApiId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"type":{"location":"querystring","locationName":"type"},"nameQuery":{"location":"querystring","locationName":"name"},"path":{"location":"querystring","locationName":"path"},"position":{"location":"querystring","locationName":"position"},"limit":{"location":"querystring","locationName":"limit","type":"integer"},"locationStatus":{"location":"querystring","locationName":"locationStatus"}}},"output":{"type":"structure","members":{"position":{},"items":{"locationName":"item","type":"list","member":{"shape":"Sv"}}}}},"GetDocumentationVersion":{"http":{"method":"GET","requestUri":"/restapis/{restapi_id}/documentation/versions/{doc_version}"},"input":{"type":"structure","required":["restApiId","documentationVersion"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"documentationVersion":{"location":"uri","locationName":"doc_version"}}},"output":{"shape":"Sx"}},"GetDocumentationVersions":{"http":{"method":"GET","requestUri":"/restapis/{restapi_id}/documentation/versions"},"input":{"type":"structure","required":["restApiId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"position":{"location":"querystring","locationName":"position"},"limit":{"location":"querystring","locationName":"limit","type":"integer"}}},"output":{"type":"structure","members":{"position":{},"items":{"locationName":"item","type":"list","member":{"shape":"Sx"}}}}},"GetDomainName":{"http":{"method":"GET","requestUri":"/domainnames/{domain_name}"},"input":{"type":"structure","required":["domainName"],"members":{"domainName":{"location":"uri","locationName":"domain_name"}}},"output":{"shape":"S13"}},"GetDomainNames":{"http":{"method":"GET","requestUri":"/domainnames"},"input":{"type":"structure","members":{"position":{"location":"querystring","locationName":"position"},"limit":{"location":"querystring","locationName":"limit","type":"integer"}}},"output":{"type":"structure","members":{"position":{},"items":{"locationName":"item","type":"list","member":{"shape":"S13"}}}}},"GetExport":{"http":{"method":"GET","requestUri":"/restapis/{restapi_id}/stages/{stage_name}/exports/{export_type}","responseCode":200},"input":{"type":"structure","required":["restApiId","stageName","exportType"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"stageName":{"location":"uri","locationName":"stage_name"},"exportType":{"location":"uri","locationName":"export_type"},"parameters":{"shape":"S6","location":"querystring"},"accepts":{"location":"header","locationName":"Accept"}}},"output":{"type":"structure","members":{"contentType":{"location":"header","locationName":"Content-Type"},"contentDisposition":{"location":"header","locationName":"Content-Disposition"},"body":{"type":"blob"}},"payload":"body"}},"GetGatewayResponse":{"http":{"method":"GET","requestUri":"/restapis/{restapi_id}/gatewayresponses/{response_type}"},"input":{"type":"structure","required":["restApiId","responseType"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"responseType":{"location":"uri","locationName":"response_type"}}},"output":{"shape":"S46"}},"GetGatewayResponses":{"http":{"method":"GET","requestUri":"/restapis/{restapi_id}/gatewayresponses"},"input":{"type":"structure","required":["restApiId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"position":{"location":"querystring","locationName":"position"},"limit":{"location":"querystring","locationName":"limit","type":"integer"}}},"output":{"type":"structure","members":{"position":{},"items":{"locationName":"item","type":"list","member":{"shape":"S46"}}}}},"GetIntegration":{"http":{"method":"GET","requestUri":"/restapis/{restapi_id}/resources/{resource_id}/methods/{http_method}/integration"},"input":{"type":"structure","required":["restApiId","resourceId","httpMethod"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"resourceId":{"location":"uri","locationName":"resource_id"},"httpMethod":{"location":"uri","locationName":"http_method"}}},"output":{"shape":"S1h"}},"GetIntegrationResponse":{"http":{"method":"GET","requestUri":"/restapis/{restapi_id}/resources/{resource_id}/methods/{http_method}/integration/responses/{status_code}"},"input":{"type":"structure","required":["restApiId","resourceId","httpMethod","statusCode"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"resourceId":{"location":"uri","locationName":"resource_id"},"httpMethod":{"location":"uri","locationName":"http_method"},"statusCode":{"location":"uri","locationName":"status_code"}}},"output":{"shape":"S1n"}},"GetMethod":{"http":{"method":"GET","requestUri":"/restapis/{restapi_id}/resources/{resource_id}/methods/{http_method}"},"input":{"type":"structure","required":["restApiId","resourceId","httpMethod"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"resourceId":{"location":"uri","locationName":"resource_id"},"httpMethod":{"location":"uri","locationName":"http_method"}}},"output":{"shape":"S1c"}},"GetMethodResponse":{"http":{"method":"GET","requestUri":"/restapis/{restapi_id}/resources/{resource_id}/methods/{http_method}/responses/{status_code}"},"input":{"type":"structure","required":["restApiId","resourceId","httpMethod","statusCode"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"resourceId":{"location":"uri","locationName":"resource_id"},"httpMethod":{"location":"uri","locationName":"http_method"},"statusCode":{"location":"uri","locationName":"status_code"}}},"output":{"shape":"S1f"}},"GetModel":{"http":{"method":"GET","requestUri":"/restapis/{restapi_id}/models/{model_name}"},"input":{"type":"structure","required":["restApiId","modelName"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"modelName":{"location":"uri","locationName":"model_name"},"flatten":{"location":"querystring","locationName":"flatten","type":"boolean"}}},"output":{"shape":"S16"}},"GetModelTemplate":{"http":{"method":"GET","requestUri":"/restapis/{restapi_id}/models/{model_name}/default_template"},"input":{"type":"structure","required":["restApiId","modelName"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"modelName":{"location":"uri","locationName":"model_name"}}},"output":{"type":"structure","members":{"value":{}}}},"GetModels":{"http":{"method":"GET","requestUri":"/restapis/{restapi_id}/models"},"input":{"type":"structure","required":["restApiId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"position":{"location":"querystring","locationName":"position"},"limit":{"location":"querystring","locationName":"limit","type":"integer"}}},"output":{"type":"structure","members":{"position":{},"items":{"locationName":"item","type":"list","member":{"shape":"S16"}}}}},"GetRequestValidator":{"http":{"method":"GET","requestUri":"/restapis/{restapi_id}/requestvalidators/{requestvalidator_id}"},"input":{"type":"structure","required":["restApiId","requestValidatorId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"requestValidatorId":{"location":"uri","locationName":"requestvalidator_id"}}},"output":{"shape":"S18"}},"GetRequestValidators":{"http":{"method":"GET","requestUri":"/restapis/{restapi_id}/requestvalidators"},"input":{"type":"structure","required":["restApiId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"position":{"location":"querystring","locationName":"position"},"limit":{"location":"querystring","locationName":"limit","type":"integer"}}},"output":{"type":"structure","members":{"position":{},"items":{"locationName":"item","type":"list","member":{"shape":"S18"}}}}},"GetResource":{"http":{"method":"GET","requestUri":"/restapis/{restapi_id}/resources/{resource_id}"},"input":{"type":"structure","required":["restApiId","resourceId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"resourceId":{"location":"uri","locationName":"resource_id"},"embed":{"shape":"S9","location":"querystring","locationName":"embed"}}},"output":{"shape":"S1a"}},"GetResources":{"http":{"method":"GET","requestUri":"/restapis/{restapi_id}/resources"},"input":{"type":"structure","required":["restApiId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"position":{"location":"querystring","locationName":"position"},"limit":{"location":"querystring","locationName":"limit","type":"integer"},"embed":{"shape":"S9","location":"querystring","locationName":"embed"}}},"output":{"type":"structure","members":{"position":{},"items":{"locationName":"item","type":"list","member":{"shape":"S1a"}}}}},"GetRestApi":{"http":{"method":"GET","requestUri":"/restapis/{restapi_id}"},"input":{"type":"structure","required":["restApiId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"}}},"output":{"shape":"S1r"}},"GetRestApis":{"http":{"method":"GET","requestUri":"/restapis"},"input":{"type":"structure","members":{"position":{"location":"querystring","locationName":"position"},"limit":{"location":"querystring","locationName":"limit","type":"integer"}}},"output":{"type":"structure","members":{"position":{},"items":{"locationName":"item","type":"list","member":{"shape":"S1r"}}}}},"GetSdk":{"http":{"method":"GET","requestUri":"/restapis/{restapi_id}/stages/{stage_name}/sdks/{sdk_type}","responseCode":200},"input":{"type":"structure","required":["restApiId","stageName","sdkType"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"stageName":{"location":"uri","locationName":"stage_name"},"sdkType":{"location":"uri","locationName":"sdk_type"},"parameters":{"shape":"S6","location":"querystring"}}},"output":{"type":"structure","members":{"contentType":{"location":"header","locationName":"Content-Type"},"contentDisposition":{"location":"header","locationName":"Content-Disposition"},"body":{"type":"blob"}},"payload":"body"}},"GetSdkType":{"http":{"method":"GET","requestUri":"/sdktypes/{sdktype_id}"},"input":{"type":"structure","required":["id"],"members":{"id":{"location":"uri","locationName":"sdktype_id"}}},"output":{"shape":"S4z"}},"GetSdkTypes":{"http":{"method":"GET","requestUri":"/sdktypes"},"input":{"type":"structure","members":{"position":{"location":"querystring","locationName":"position"},"limit":{"location":"querystring","locationName":"limit","type":"integer"}}},"output":{"type":"structure","members":{"position":{},"items":{"locationName":"item","type":"list","member":{"shape":"S4z"}}}}},"GetStage":{"http":{"method":"GET","requestUri":"/restapis/{restapi_id}/stages/{stage_name}"},"input":{"type":"structure","required":["restApiId","stageName"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"stageName":{"location":"uri","locationName":"stage_name"}}},"output":{"shape":"S1u"}},"GetStages":{"http":{"method":"GET","requestUri":"/restapis/{restapi_id}/stages"},"input":{"type":"structure","required":["restApiId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"deploymentId":{"location":"querystring","locationName":"deploymentId"}}},"output":{"type":"structure","members":{"item":{"type":"list","member":{"shape":"S1u"}}}}},"GetTags":{"http":{"method":"GET","requestUri":"/tags/{resource_arn}"},"input":{"type":"structure","required":["resourceArn"],"members":{"resourceArn":{"location":"uri","locationName":"resource_arn"},"position":{"location":"querystring","locationName":"position"},"limit":{"location":"querystring","locationName":"limit","type":"integer"}}},"output":{"type":"structure","members":{"tags":{"shape":"S6"}}}},"GetUsage":{"http":{"method":"GET","requestUri":"/usageplans/{usageplanId}/usage"},"input":{"type":"structure","required":["usagePlanId","startDate","endDate"],"members":{"usagePlanId":{"location":"uri","locationName":"usageplanId"},"keyId":{"location":"querystring","locationName":"keyId"},"startDate":{"location":"querystring","locationName":"startDate"},"endDate":{"location":"querystring","locationName":"endDate"},"position":{"location":"querystring","locationName":"position"},"limit":{"location":"querystring","locationName":"limit","type":"integer"}}},"output":{"shape":"S5c"}},"GetUsagePlan":{"http":{"method":"GET","requestUri":"/usageplans/{usageplanId}"},"input":{"type":"structure","required":["usagePlanId"],"members":{"usagePlanId":{"location":"uri","locationName":"usageplanId"}}},"output":{"shape":"S27"}},"GetUsagePlanKey":{"http":{"method":"GET","requestUri":"/usageplans/{usageplanId}/keys/{keyId}","responseCode":200},"input":{"type":"structure","required":["usagePlanId","keyId"],"members":{"usagePlanId":{"location":"uri","locationName":"usageplanId"},"keyId":{"location":"uri","locationName":"keyId"}}},"output":{"shape":"S29"}},"GetUsagePlanKeys":{"http":{"method":"GET","requestUri":"/usageplans/{usageplanId}/keys"},"input":{"type":"structure","required":["usagePlanId"],"members":{"usagePlanId":{"location":"uri","locationName":"usageplanId"},"position":{"location":"querystring","locationName":"position"},"limit":{"location":"querystring","locationName":"limit","type":"integer"},"nameQuery":{"location":"querystring","locationName":"name"}}},"output":{"type":"structure","members":{"position":{},"items":{"locationName":"item","type":"list","member":{"shape":"S29"}}}}},"GetUsagePlans":{"http":{"method":"GET","requestUri":"/usageplans"},"input":{"type":"structure","members":{"position":{"location":"querystring","locationName":"position"},"keyId":{"location":"querystring","locationName":"keyId"},"limit":{"location":"querystring","locationName":"limit","type":"integer"}}},"output":{"type":"structure","members":{"position":{},"items":{"locationName":"item","type":"list","member":{"shape":"S27"}}}}},"GetVpcLink":{"http":{"method":"GET","requestUri":"/vpclinks/{vpclink_id}"},"input":{"type":"structure","required":["vpcLinkId"],"members":{"vpcLinkId":{"location":"uri","locationName":"vpclink_id"}}},"output":{"shape":"S2b"}},"GetVpcLinks":{"http":{"method":"GET","requestUri":"/vpclinks"},"input":{"type":"structure","members":{"position":{"location":"querystring","locationName":"position"},"limit":{"location":"querystring","locationName":"limit","type":"integer"}}},"output":{"type":"structure","members":{"position":{},"items":{"locationName":"item","type":"list","member":{"shape":"S2b"}}}}},"ImportApiKeys":{"http":{"requestUri":"/apikeys?mode=import","responseCode":201},"input":{"type":"structure","required":["body","format"],"members":{"body":{"type":"blob"},"format":{"location":"querystring","locationName":"format"},"failOnWarnings":{"location":"querystring","locationName":"failonwarnings","type":"boolean"}},"payload":"body"},"output":{"type":"structure","members":{"ids":{"shape":"S9"},"warnings":{"shape":"S9"}}}},"ImportDocumentationParts":{"http":{"method":"PUT","requestUri":"/restapis/{restapi_id}/documentation/parts"},"input":{"type":"structure","required":["restApiId","body"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"mode":{"location":"querystring","locationName":"mode"},"failOnWarnings":{"location":"querystring","locationName":"failonwarnings","type":"boolean"},"body":{"type":"blob"}},"payload":"body"},"output":{"type":"structure","members":{"ids":{"shape":"S9"},"warnings":{"shape":"S9"}}}},"ImportRestApi":{"http":{"requestUri":"/restapis?mode=import","responseCode":201},"input":{"type":"structure","required":["body"],"members":{"failOnWarnings":{"location":"querystring","locationName":"failonwarnings","type":"boolean"},"parameters":{"shape":"S6","location":"querystring"},"body":{"type":"blob"}},"payload":"body"},"output":{"shape":"S1r"}},"PutGatewayResponse":{"http":{"method":"PUT","requestUri":"/restapis/{restapi_id}/gatewayresponses/{response_type}","responseCode":201},"input":{"type":"structure","required":["restApiId","responseType"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"responseType":{"location":"uri","locationName":"response_type"},"statusCode":{},"responseParameters":{"shape":"S6"},"responseTemplates":{"shape":"S6"}}},"output":{"shape":"S46"}},"PutIntegration":{"http":{"method":"PUT","requestUri":"/restapis/{restapi_id}/resources/{resource_id}/methods/{http_method}/integration","responseCode":201},"input":{"type":"structure","required":["restApiId","resourceId","httpMethod","type"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"resourceId":{"location":"uri","locationName":"resource_id"},"httpMethod":{"location":"uri","locationName":"http_method"},"type":{},"integrationHttpMethod":{"locationName":"httpMethod"},"uri":{},"connectionType":{},"connectionId":{},"credentials":{},"requestParameters":{"shape":"S6"},"requestTemplates":{"shape":"S6"},"passthroughBehavior":{},"cacheNamespace":{},"cacheKeyParameters":{"shape":"S9"},"contentHandling":{},"timeoutInMillis":{"type":"integer"},"tlsConfig":{"shape":"S1o"}}},"output":{"shape":"S1h"}},"PutIntegrationResponse":{"http":{"method":"PUT","requestUri":"/restapis/{restapi_id}/resources/{resource_id}/methods/{http_method}/integration/responses/{status_code}","responseCode":201},"input":{"type":"structure","required":["restApiId","resourceId","httpMethod","statusCode"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"resourceId":{"location":"uri","locationName":"resource_id"},"httpMethod":{"location":"uri","locationName":"http_method"},"statusCode":{"location":"uri","locationName":"status_code"},"selectionPattern":{},"responseParameters":{"shape":"S6"},"responseTemplates":{"shape":"S6"},"contentHandling":{}}},"output":{"shape":"S1n"}},"PutMethod":{"http":{"method":"PUT","requestUri":"/restapis/{restapi_id}/resources/{resource_id}/methods/{http_method}","responseCode":201},"input":{"type":"structure","required":["restApiId","resourceId","httpMethod","authorizationType"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"resourceId":{"location":"uri","locationName":"resource_id"},"httpMethod":{"location":"uri","locationName":"http_method"},"authorizationType":{},"authorizerId":{},"apiKeyRequired":{"type":"boolean"},"operationName":{},"requestParameters":{"shape":"S1d"},"requestModels":{"shape":"S6"},"requestValidatorId":{},"authorizationScopes":{"shape":"S9"}}},"output":{"shape":"S1c"}},"PutMethodResponse":{"http":{"method":"PUT","requestUri":"/restapis/{restapi_id}/resources/{resource_id}/methods/{http_method}/responses/{status_code}","responseCode":201},"input":{"type":"structure","required":["restApiId","resourceId","httpMethod","statusCode"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"resourceId":{"location":"uri","locationName":"resource_id"},"httpMethod":{"location":"uri","locationName":"http_method"},"statusCode":{"location":"uri","locationName":"status_code"},"responseParameters":{"shape":"S1d"},"responseModels":{"shape":"S6"}}},"output":{"shape":"S1f"}},"PutRestApi":{"http":{"method":"PUT","requestUri":"/restapis/{restapi_id}"},"input":{"type":"structure","required":["restApiId","body"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"mode":{"location":"querystring","locationName":"mode"},"failOnWarnings":{"location":"querystring","locationName":"failonwarnings","type":"boolean"},"parameters":{"shape":"S6","location":"querystring"},"body":{"type":"blob"}},"payload":"body"},"output":{"shape":"S1r"}},"TagResource":{"http":{"method":"PUT","requestUri":"/tags/{resource_arn}","responseCode":204},"input":{"type":"structure","required":["resourceArn","tags"],"members":{"resourceArn":{"location":"uri","locationName":"resource_arn"},"tags":{"shape":"S6"}}}},"TestInvokeAuthorizer":{"http":{"requestUri":"/restapis/{restapi_id}/authorizers/{authorizer_id}"},"input":{"type":"structure","required":["restApiId","authorizerId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"authorizerId":{"location":"uri","locationName":"authorizer_id"},"headers":{"shape":"S6"},"multiValueHeaders":{"shape":"S68"},"pathWithQueryString":{},"body":{},"stageVariables":{"shape":"S6"},"additionalContext":{"shape":"S6"}}},"output":{"type":"structure","members":{"clientStatus":{"type":"integer"},"log":{},"latency":{"type":"long"},"principalId":{},"policy":{},"authorization":{"shape":"S68"},"claims":{"shape":"S6"}}}},"TestInvokeMethod":{"http":{"requestUri":"/restapis/{restapi_id}/resources/{resource_id}/methods/{http_method}"},"input":{"type":"structure","required":["restApiId","resourceId","httpMethod"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"resourceId":{"location":"uri","locationName":"resource_id"},"httpMethod":{"location":"uri","locationName":"http_method"},"pathWithQueryString":{},"body":{},"headers":{"shape":"S6"},"multiValueHeaders":{"shape":"S68"},"clientCertificateId":{},"stageVariables":{"shape":"S6"}}},"output":{"type":"structure","members":{"status":{"type":"integer"},"body":{},"headers":{"shape":"S6"},"multiValueHeaders":{"shape":"S68"},"log":{},"latency":{"type":"long"}}}},"UntagResource":{"http":{"method":"DELETE","requestUri":"/tags/{resource_arn}","responseCode":204},"input":{"type":"structure","required":["resourceArn","tagKeys"],"members":{"resourceArn":{"location":"uri","locationName":"resource_arn"},"tagKeys":{"shape":"S9","location":"querystring","locationName":"tagKeys"}}}},"UpdateAccount":{"http":{"method":"PATCH","requestUri":"/account"},"input":{"type":"structure","members":{"patchOperations":{"shape":"S6e"}}},"output":{"shape":"S34"}},"UpdateApiKey":{"http":{"method":"PATCH","requestUri":"/apikeys/{api_Key}"},"input":{"type":"structure","required":["apiKey"],"members":{"apiKey":{"location":"uri","locationName":"api_Key"},"patchOperations":{"shape":"S6e"}}},"output":{"shape":"S7"}},"UpdateAuthorizer":{"http":{"method":"PATCH","requestUri":"/restapis/{restapi_id}/authorizers/{authorizer_id}"},"input":{"type":"structure","required":["restApiId","authorizerId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"authorizerId":{"location":"uri","locationName":"authorizer_id"},"patchOperations":{"shape":"S6e"}}},"output":{"shape":"Sf"}},"UpdateBasePathMapping":{"http":{"method":"PATCH","requestUri":"/domainnames/{domain_name}/basepathmappings/{base_path}"},"input":{"type":"structure","required":["domainName","basePath"],"members":{"domainName":{"location":"uri","locationName":"domain_name"},"basePath":{"location":"uri","locationName":"base_path"},"patchOperations":{"shape":"S6e"}}},"output":{"shape":"Sh"}},"UpdateClientCertificate":{"http":{"method":"PATCH","requestUri":"/clientcertificates/{clientcertificate_id}"},"input":{"type":"structure","required":["clientCertificateId"],"members":{"clientCertificateId":{"location":"uri","locationName":"clientcertificate_id"},"patchOperations":{"shape":"S6e"}}},"output":{"shape":"S32"}},"UpdateDeployment":{"http":{"method":"PATCH","requestUri":"/restapis/{restapi_id}/deployments/{deployment_id}"},"input":{"type":"structure","required":["restApiId","deploymentId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"deploymentId":{"location":"uri","locationName":"deployment_id"},"patchOperations":{"shape":"S6e"}}},"output":{"shape":"Sn"}},"UpdateDocumentationPart":{"http":{"method":"PATCH","requestUri":"/restapis/{restapi_id}/documentation/parts/{part_id}"},"input":{"type":"structure","required":["restApiId","documentationPartId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"documentationPartId":{"location":"uri","locationName":"part_id"},"patchOperations":{"shape":"S6e"}}},"output":{"shape":"Sv"}},"UpdateDocumentationVersion":{"http":{"method":"PATCH","requestUri":"/restapis/{restapi_id}/documentation/versions/{doc_version}"},"input":{"type":"structure","required":["restApiId","documentationVersion"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"documentationVersion":{"location":"uri","locationName":"doc_version"},"patchOperations":{"shape":"S6e"}}},"output":{"shape":"Sx"}},"UpdateDomainName":{"http":{"method":"PATCH","requestUri":"/domainnames/{domain_name}"},"input":{"type":"structure","required":["domainName"],"members":{"domainName":{"location":"uri","locationName":"domain_name"},"patchOperations":{"shape":"S6e"}}},"output":{"shape":"S13"}},"UpdateGatewayResponse":{"http":{"method":"PATCH","requestUri":"/restapis/{restapi_id}/gatewayresponses/{response_type}"},"input":{"type":"structure","required":["restApiId","responseType"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"responseType":{"location":"uri","locationName":"response_type"},"patchOperations":{"shape":"S6e"}}},"output":{"shape":"S46"}},"UpdateIntegration":{"http":{"method":"PATCH","requestUri":"/restapis/{restapi_id}/resources/{resource_id}/methods/{http_method}/integration"},"input":{"type":"structure","required":["restApiId","resourceId","httpMethod"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"resourceId":{"location":"uri","locationName":"resource_id"},"httpMethod":{"location":"uri","locationName":"http_method"},"patchOperations":{"shape":"S6e"}}},"output":{"shape":"S1h"}},"UpdateIntegrationResponse":{"http":{"method":"PATCH","requestUri":"/restapis/{restapi_id}/resources/{resource_id}/methods/{http_method}/integration/responses/{status_code}"},"input":{"type":"structure","required":["restApiId","resourceId","httpMethod","statusCode"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"resourceId":{"location":"uri","locationName":"resource_id"},"httpMethod":{"location":"uri","locationName":"http_method"},"statusCode":{"location":"uri","locationName":"status_code"},"patchOperations":{"shape":"S6e"}}},"output":{"shape":"S1n"}},"UpdateMethod":{"http":{"method":"PATCH","requestUri":"/restapis/{restapi_id}/resources/{resource_id}/methods/{http_method}"},"input":{"type":"structure","required":["restApiId","resourceId","httpMethod"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"resourceId":{"location":"uri","locationName":"resource_id"},"httpMethod":{"location":"uri","locationName":"http_method"},"patchOperations":{"shape":"S6e"}}},"output":{"shape":"S1c"}},"UpdateMethodResponse":{"http":{"method":"PATCH","requestUri":"/restapis/{restapi_id}/resources/{resource_id}/methods/{http_method}/responses/{status_code}","responseCode":201},"input":{"type":"structure","required":["restApiId","resourceId","httpMethod","statusCode"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"resourceId":{"location":"uri","locationName":"resource_id"},"httpMethod":{"location":"uri","locationName":"http_method"},"statusCode":{"location":"uri","locationName":"status_code"},"patchOperations":{"shape":"S6e"}}},"output":{"shape":"S1f"}},"UpdateModel":{"http":{"method":"PATCH","requestUri":"/restapis/{restapi_id}/models/{model_name}"},"input":{"type":"structure","required":["restApiId","modelName"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"modelName":{"location":"uri","locationName":"model_name"},"patchOperations":{"shape":"S6e"}}},"output":{"shape":"S16"}},"UpdateRequestValidator":{"http":{"method":"PATCH","requestUri":"/restapis/{restapi_id}/requestvalidators/{requestvalidator_id}"},"input":{"type":"structure","required":["restApiId","requestValidatorId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"requestValidatorId":{"location":"uri","locationName":"requestvalidator_id"},"patchOperations":{"shape":"S6e"}}},"output":{"shape":"S18"}},"UpdateResource":{"http":{"method":"PATCH","requestUri":"/restapis/{restapi_id}/resources/{resource_id}"},"input":{"type":"structure","required":["restApiId","resourceId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"resourceId":{"location":"uri","locationName":"resource_id"},"patchOperations":{"shape":"S6e"}}},"output":{"shape":"S1a"}},"UpdateRestApi":{"http":{"method":"PATCH","requestUri":"/restapis/{restapi_id}"},"input":{"type":"structure","required":["restApiId"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"patchOperations":{"shape":"S6e"}}},"output":{"shape":"S1r"}},"UpdateStage":{"http":{"method":"PATCH","requestUri":"/restapis/{restapi_id}/stages/{stage_name}"},"input":{"type":"structure","required":["restApiId","stageName"],"members":{"restApiId":{"location":"uri","locationName":"restapi_id"},"stageName":{"location":"uri","locationName":"stage_name"},"patchOperations":{"shape":"S6e"}}},"output":{"shape":"S1u"}},"UpdateUsage":{"http":{"method":"PATCH","requestUri":"/usageplans/{usageplanId}/keys/{keyId}/usage"},"input":{"type":"structure","required":["usagePlanId","keyId"],"members":{"usagePlanId":{"location":"uri","locationName":"usageplanId"},"keyId":{"location":"uri","locationName":"keyId"},"patchOperations":{"shape":"S6e"}}},"output":{"shape":"S5c"}},"UpdateUsagePlan":{"http":{"method":"PATCH","requestUri":"/usageplans/{usageplanId}"},"input":{"type":"structure","required":["usagePlanId"],"members":{"usagePlanId":{"location":"uri","locationName":"usageplanId"},"patchOperations":{"shape":"S6e"}}},"output":{"shape":"S27"}},"UpdateVpcLink":{"http":{"method":"PATCH","requestUri":"/vpclinks/{vpclink_id}"},"input":{"type":"structure","required":["vpcLinkId"],"members":{"vpcLinkId":{"location":"uri","locationName":"vpclink_id"},"patchOperations":{"shape":"S6e"}}},"output":{"shape":"S2b"}}},"shapes":{"S6":{"type":"map","key":{},"value":{}},"S7":{"type":"structure","members":{"id":{},"value":{},"name":{},"customerId":{},"description":{},"enabled":{"type":"boolean"},"createdDate":{"type":"timestamp"},"lastUpdatedDate":{"type":"timestamp"},"stageKeys":{"shape":"S9"},"tags":{"shape":"S6"}}},"S9":{"type":"list","member":{}},"Sc":{"type":"list","member":{}},"Sf":{"type":"structure","members":{"id":{},"name":{},"type":{},"providerARNs":{"shape":"Sc"},"authType":{},"authorizerUri":{},"authorizerCredentials":{},"identitySource":{},"identityValidationExpression":{},"authorizerResultTtlInSeconds":{"type":"integer"}}},"Sh":{"type":"structure","members":{"basePath":{},"restApiId":{},"stage":{}}},"Sn":{"type":"structure","members":{"id":{},"description":{},"createdDate":{"type":"timestamp"},"apiSummary":{"type":"map","key":{},"value":{"type":"map","key":{},"value":{"type":"structure","members":{"authorizationType":{},"apiKeyRequired":{"type":"boolean"}}}}}}},"Ss":{"type":"structure","required":["type"],"members":{"type":{},"path":{},"method":{},"statusCode":{},"name":{}}},"Sv":{"type":"structure","members":{"id":{},"location":{"shape":"Ss"},"properties":{}}},"Sx":{"type":"structure","members":{"version":{},"createdDate":{"type":"timestamp"},"description":{}}},"Sz":{"type":"structure","members":{"types":{"type":"list","member":{}},"vpcEndpointIds":{"shape":"S9"}}},"S13":{"type":"structure","members":{"domainName":{},"certificateName":{},"certificateArn":{},"certificateUploadDate":{"type":"timestamp"},"regionalDomainName":{},"regionalHostedZoneId":{},"regionalCertificateName":{},"regionalCertificateArn":{},"distributionDomainName":{},"distributionHostedZoneId":{},"endpointConfiguration":{"shape":"Sz"},"domainNameStatus":{},"domainNameStatusMessage":{},"securityPolicy":{},"tags":{"shape":"S6"}}},"S16":{"type":"structure","members":{"id":{},"name":{},"description":{},"schema":{},"contentType":{}}},"S18":{"type":"structure","members":{"id":{},"name":{},"validateRequestBody":{"type":"boolean"},"validateRequestParameters":{"type":"boolean"}}},"S1a":{"type":"structure","members":{"id":{},"parentId":{},"pathPart":{},"path":{},"resourceMethods":{"type":"map","key":{},"value":{"shape":"S1c"}}}},"S1c":{"type":"structure","members":{"httpMethod":{},"authorizationType":{},"authorizerId":{},"apiKeyRequired":{"type":"boolean"},"requestValidatorId":{},"operationName":{},"requestParameters":{"shape":"S1d"},"requestModels":{"shape":"S6"},"methodResponses":{"type":"map","key":{},"value":{"shape":"S1f"}},"methodIntegration":{"shape":"S1h"},"authorizationScopes":{"shape":"S9"}}},"S1d":{"type":"map","key":{},"value":{"type":"boolean"}},"S1f":{"type":"structure","members":{"statusCode":{},"responseParameters":{"shape":"S1d"},"responseModels":{"shape":"S6"}}},"S1h":{"type":"structure","members":{"type":{},"httpMethod":{},"uri":{},"connectionType":{},"connectionId":{},"credentials":{},"requestParameters":{"shape":"S6"},"requestTemplates":{"shape":"S6"},"passthroughBehavior":{},"contentHandling":{},"timeoutInMillis":{"type":"integer"},"cacheNamespace":{},"cacheKeyParameters":{"shape":"S9"},"integrationResponses":{"type":"map","key":{},"value":{"shape":"S1n"}},"tlsConfig":{"shape":"S1o"}}},"S1n":{"type":"structure","members":{"statusCode":{},"selectionPattern":{},"responseParameters":{"shape":"S6"},"responseTemplates":{"shape":"S6"},"contentHandling":{}}},"S1o":{"type":"structure","members":{"insecureSkipVerification":{"type":"boolean"}}},"S1r":{"type":"structure","members":{"id":{},"name":{},"description":{},"createdDate":{"type":"timestamp"},"version":{},"warnings":{"shape":"S9"},"binaryMediaTypes":{"shape":"S9"},"minimumCompressionSize":{"type":"integer"},"apiKeySource":{},"endpointConfiguration":{"shape":"Sz"},"policy":{},"tags":{"shape":"S6"}}},"S1t":{"type":"structure","members":{"percentTraffic":{"type":"double"},"deploymentId":{},"stageVariableOverrides":{"shape":"S6"},"useStageCache":{"type":"boolean"}}},"S1u":{"type":"structure","members":{"deploymentId":{},"clientCertificateId":{},"stageName":{},"description":{},"cacheClusterEnabled":{"type":"boolean"},"cacheClusterSize":{},"cacheClusterStatus":{},"methodSettings":{"type":"map","key":{},"value":{"type":"structure","members":{"metricsEnabled":{"type":"boolean"},"loggingLevel":{},"dataTraceEnabled":{"type":"boolean"},"throttlingBurstLimit":{"type":"integer"},"throttlingRateLimit":{"type":"double"},"cachingEnabled":{"type":"boolean"},"cacheTtlInSeconds":{"type":"integer"},"cacheDataEncrypted":{"type":"boolean"},"requireAuthorizationForCacheControl":{"type":"boolean"},"unauthorizedCacheControlHeaderStrategy":{}}}},"variables":{"shape":"S6"},"documentationVersion":{},"accessLogSettings":{"type":"structure","members":{"format":{},"destinationArn":{}}},"canarySettings":{"shape":"S1t"},"tracingEnabled":{"type":"boolean"},"webAclArn":{},"tags":{"shape":"S6"},"createdDate":{"type":"timestamp"},"lastUpdatedDate":{"type":"timestamp"}}},"S21":{"type":"list","member":{"type":"structure","members":{"apiId":{},"stage":{},"throttle":{"type":"map","key":{},"value":{"shape":"S24"}}}}},"S24":{"type":"structure","members":{"burstLimit":{"type":"integer"},"rateLimit":{"type":"double"}}},"S25":{"type":"structure","members":{"limit":{"type":"integer"},"offset":{"type":"integer"},"period":{}}},"S27":{"type":"structure","members":{"id":{},"name":{},"description":{},"apiStages":{"shape":"S21"},"throttle":{"shape":"S24"},"quota":{"shape":"S25"},"productCode":{},"tags":{"shape":"S6"}}},"S29":{"type":"structure","members":{"id":{},"type":{},"value":{},"name":{}}},"S2b":{"type":"structure","members":{"id":{},"name":{},"description":{},"targetArns":{"shape":"S9"},"status":{},"statusMessage":{},"tags":{"shape":"S6"}}},"S32":{"type":"structure","members":{"clientCertificateId":{},"description":{},"pemEncodedCertificate":{},"createdDate":{"type":"timestamp"},"expirationDate":{"type":"timestamp"},"tags":{"shape":"S6"}}},"S34":{"type":"structure","members":{"cloudwatchRoleArn":{},"throttleSettings":{"shape":"S24"},"features":{"shape":"S9"},"apiKeyVersion":{}}},"S46":{"type":"structure","members":{"responseType":{},"statusCode":{},"responseParameters":{"shape":"S6"},"responseTemplates":{"shape":"S6"},"defaultResponse":{"type":"boolean"}}},"S4z":{"type":"structure","members":{"id":{},"friendlyName":{},"description":{},"configurationProperties":{"type":"list","member":{"type":"structure","members":{"name":{},"friendlyName":{},"description":{},"required":{"type":"boolean"},"defaultValue":{}}}}}},"S5c":{"type":"structure","members":{"usagePlanId":{},"startDate":{},"endDate":{},"position":{},"items":{"locationName":"values","type":"map","key":{},"value":{"type":"list","member":{"type":"list","member":{"type":"long"}}}}}},"S68":{"type":"map","key":{},"value":{"shape":"S9"}},"S6e":{"type":"list","member":{"type":"structure","members":{"op":{},"path":{},"value":{},"from":{}}}}}}; +"use strict"; -/***/ }), -/***/ 2541: -/***/ (function(module, __unusedexports, __webpack_require__) { +var protocolHttp = __nccwpck_require__(2356); +var querystringBuilder = __nccwpck_require__(8256); +var http = __nccwpck_require__(8611); +var https = __nccwpck_require__(5692); +var stream = __nccwpck_require__(2203); +var http2 = __nccwpck_require__(5675); -__webpack_require__(3234); -module.exports = { - ACM: __webpack_require__(9427), - APIGateway: __webpack_require__(7126), - ApplicationAutoScaling: __webpack_require__(170), - AppStream: __webpack_require__(7624), - AutoScaling: __webpack_require__(9595), - Batch: __webpack_require__(6605), - Budgets: __webpack_require__(1836), - CloudDirectory: __webpack_require__(469), - CloudFormation: __webpack_require__(8021), - CloudFront: __webpack_require__(4779), - CloudHSM: __webpack_require__(5701), - CloudSearch: __webpack_require__(9890), - CloudSearchDomain: __webpack_require__(8395), - CloudTrail: __webpack_require__(768), - CloudWatch: __webpack_require__(5967), - CloudWatchEvents: __webpack_require__(5114), - CloudWatchLogs: __webpack_require__(4227), - CodeBuild: __webpack_require__(665), - CodeCommit: __webpack_require__(4086), - CodeDeploy: __webpack_require__(2317), - CodePipeline: __webpack_require__(8773), - CognitoIdentity: __webpack_require__(2214), - CognitoIdentityServiceProvider: __webpack_require__(9291), - CognitoSync: __webpack_require__(1186), - ConfigService: __webpack_require__(6458), - CUR: __webpack_require__(4671), - DataPipeline: __webpack_require__(5109), - DeviceFarm: __webpack_require__(1372), - DirectConnect: __webpack_require__(8331), - DirectoryService: __webpack_require__(7883), - Discovery: __webpack_require__(4341), - DMS: __webpack_require__(6261), - DynamoDB: __webpack_require__(7502), - DynamoDBStreams: __webpack_require__(9822), - EC2: __webpack_require__(3877), - ECR: __webpack_require__(5773), - ECS: __webpack_require__(6211), - EFS: __webpack_require__(6887), - ElastiCache: __webpack_require__(9236), - ElasticBeanstalk: __webpack_require__(9452), - ELB: __webpack_require__(600), - ELBv2: __webpack_require__(1420), - EMR: __webpack_require__(1928), - ES: __webpack_require__(1920), - ElasticTranscoder: __webpack_require__(8930), - Firehose: __webpack_require__(9405), - GameLift: __webpack_require__(8307), - Glacier: __webpack_require__(9096), - Health: __webpack_require__(7715), - IAM: __webpack_require__(7845), - ImportExport: __webpack_require__(6384), - Inspector: __webpack_require__(4343), - Iot: __webpack_require__(6255), - IotData: __webpack_require__(1291), - Kinesis: __webpack_require__(7221), - KinesisAnalytics: __webpack_require__(3506), - KMS: __webpack_require__(9374), - Lambda: __webpack_require__(6382), - LexRuntime: __webpack_require__(1879), - Lightsail: __webpack_require__(7350), - MachineLearning: __webpack_require__(5889), - MarketplaceCommerceAnalytics: __webpack_require__(8458), - MarketplaceMetering: __webpack_require__(9225), - MTurk: __webpack_require__(6427), - MobileAnalytics: __webpack_require__(6117), - OpsWorks: __webpack_require__(5542), - OpsWorksCM: __webpack_require__(6738), - Organizations: __webpack_require__(7106), - Pinpoint: __webpack_require__(5381), - Polly: __webpack_require__(4211), - RDS: __webpack_require__(1071), - Redshift: __webpack_require__(5609), - Rekognition: __webpack_require__(8991), - ResourceGroupsTaggingAPI: __webpack_require__(6205), - Route53: __webpack_require__(5707), - Route53Domains: __webpack_require__(3206), - S3: __webpack_require__(1777), - S3Control: __webpack_require__(2617), - ServiceCatalog: __webpack_require__(2673), - SES: __webpack_require__(5311), - Shield: __webpack_require__(8057), - SimpleDB: __webpack_require__(7645), - SMS: __webpack_require__(5103), - Snowball: __webpack_require__(2259), - SNS: __webpack_require__(6735), - SQS: __webpack_require__(8779), - SSM: __webpack_require__(2883), - StorageGateway: __webpack_require__(910), - StepFunctions: __webpack_require__(5835), - STS: __webpack_require__(1733), - Support: __webpack_require__(3042), - SWF: __webpack_require__(8866), - XRay: __webpack_require__(1015), - WAF: __webpack_require__(4258), - WAFRegional: __webpack_require__(2709), - WorkDocs: __webpack_require__(4469), - WorkSpaces: __webpack_require__(4400), - CodeStar: __webpack_require__(7205), - LexModelBuildingService: __webpack_require__(1536), - MarketplaceEntitlementService: __webpack_require__(8265), - Athena: __webpack_require__(7207), - Greengrass: __webpack_require__(4290), - DAX: __webpack_require__(7258), - MigrationHub: __webpack_require__(2106), - CloudHSMV2: __webpack_require__(6900), - Glue: __webpack_require__(1711), - Mobile: __webpack_require__(758), - Pricing: __webpack_require__(3989), - CostExplorer: __webpack_require__(332), - MediaConvert: __webpack_require__(9568), - MediaLive: __webpack_require__(99), - MediaPackage: __webpack_require__(6515), - MediaStore: __webpack_require__(1401), - MediaStoreData: __webpack_require__(2271), - AppSync: __webpack_require__(8847), - GuardDuty: __webpack_require__(5939), - MQ: __webpack_require__(3346), - Comprehend: __webpack_require__(9627), - IoTJobsDataPlane: __webpack_require__(6394), - KinesisVideoArchivedMedia: __webpack_require__(6454), - KinesisVideoMedia: __webpack_require__(4487), - KinesisVideo: __webpack_require__(3707), - SageMakerRuntime: __webpack_require__(2747), - SageMaker: __webpack_require__(7151), - Translate: __webpack_require__(1602), - ResourceGroups: __webpack_require__(215), - AlexaForBusiness: __webpack_require__(8679), - Cloud9: __webpack_require__(877), - ServerlessApplicationRepository: __webpack_require__(1592), - ServiceDiscovery: __webpack_require__(6688), - WorkMail: __webpack_require__(7404), - AutoScalingPlans: __webpack_require__(3099), - TranscribeService: __webpack_require__(8577), - Connect: __webpack_require__(697), - ACMPCA: __webpack_require__(2386), - FMS: __webpack_require__(7923), - SecretsManager: __webpack_require__(585), - IoTAnalytics: __webpack_require__(7010), - IoT1ClickDevicesService: __webpack_require__(8859), - IoT1ClickProjects: __webpack_require__(9523), - PI: __webpack_require__(1032), - Neptune: __webpack_require__(8660), - MediaTailor: __webpack_require__(466), - EKS: __webpack_require__(1429), - Macie: __webpack_require__(7899), - DLM: __webpack_require__(160), - Signer: __webpack_require__(4795), - Chime: __webpack_require__(7409), - PinpointEmail: __webpack_require__(8843), - RAM: __webpack_require__(8421), - Route53Resolver: __webpack_require__(4915), - PinpointSMSVoice: __webpack_require__(1187), - QuickSight: __webpack_require__(9475), - RDSDataService: __webpack_require__(408), - Amplify: __webpack_require__(8375), - DataSync: __webpack_require__(9980), - RoboMaker: __webpack_require__(4802), - Transfer: __webpack_require__(7830), - GlobalAccelerator: __webpack_require__(7443), - ComprehendMedical: __webpack_require__(9457), - KinesisAnalyticsV2: __webpack_require__(7043), - MediaConnect: __webpack_require__(9526), - FSx: __webpack_require__(8937), - SecurityHub: __webpack_require__(1353), - AppMesh: __webpack_require__(7555), - LicenseManager: __webpack_require__(3110), - Kafka: __webpack_require__(1275), - ApiGatewayManagementApi: __webpack_require__(5319), - ApiGatewayV2: __webpack_require__(2020), - DocDB: __webpack_require__(7223), - Backup: __webpack_require__(4604), - WorkLink: __webpack_require__(1250), - Textract: __webpack_require__(3223), - ManagedBlockchain: __webpack_require__(3220), - MediaPackageVod: __webpack_require__(2339), - GroundStation: __webpack_require__(9976), - IoTThingsGraph: __webpack_require__(2327), - IoTEvents: __webpack_require__(3222), - IoTEventsData: __webpack_require__(7581), - Personalize: __webpack_require__(8478), - PersonalizeEvents: __webpack_require__(8280), - PersonalizeRuntime: __webpack_require__(1349), - ApplicationInsights: __webpack_require__(9512), - ServiceQuotas: __webpack_require__(6723), - EC2InstanceConnect: __webpack_require__(5107), - EventBridge: __webpack_require__(4105), - LakeFormation: __webpack_require__(7026), - ForecastService: __webpack_require__(1798), - ForecastQueryService: __webpack_require__(4068), - QLDB: __webpack_require__(9086), - QLDBSession: __webpack_require__(2447), - WorkMailMessageFlow: __webpack_require__(2145), - CodeStarNotifications: __webpack_require__(3853), - SavingsPlans: __webpack_require__(686), - SSO: __webpack_require__(4612), - SSOOIDC: __webpack_require__(1786), - MarketplaceCatalog: __webpack_require__(6773), - DataExchange: __webpack_require__(8433), - SESV2: __webpack_require__(837), - MigrationHubConfig: __webpack_require__(8049), - ConnectParticipant: __webpack_require__(4122), - AppConfig: __webpack_require__(5821), - IoTSecureTunneling: __webpack_require__(6992), - WAFV2: __webpack_require__(42), - ElasticInference: __webpack_require__(5252), - Imagebuilder: __webpack_require__(6244), - Schemas: __webpack_require__(3694), - AccessAnalyzer: __webpack_require__(2467), - CodeGuruReviewer: __webpack_require__(1917), - CodeGuruProfiler: __webpack_require__(623), - ComputeOptimizer: __webpack_require__(1530), - FraudDetector: __webpack_require__(9196), - Kendra: __webpack_require__(6906), - NetworkManager: __webpack_require__(4128), - Outposts: __webpack_require__(8119), - AugmentedAIRuntime: __webpack_require__(7508), - EBS: __webpack_require__(7646), - KinesisVideoSignalingChannels: __webpack_require__(2641), - Detective: __webpack_require__(1068), - CodeStarconnections: __webpack_require__(1096), - Synthetics: __webpack_require__(2110), - IoTSiteWise: __webpack_require__(2221), - Macie2: __webpack_require__(9489), - CodeArtifact: __webpack_require__(4035), - Honeycode: __webpack_require__(4388), - IVS: __webpack_require__(4291) -}; - -/***/ }), - -/***/ 2572: -/***/ (function(module) { - -module.exports = {"rules":{"*/*":{"endpoint":"{service}.{region}.amazonaws.com"},"cn-*/*":{"endpoint":"{service}.{region}.amazonaws.com.cn"},"us-iso-*/*":{"endpoint":"{service}.{region}.c2s.ic.gov"},"us-isob-*/*":{"endpoint":"{service}.{region}.sc2s.sgov.gov"},"*/budgets":"globalSSL","*/cloudfront":"globalSSL","*/sts":"globalSSL","*/importexport":{"endpoint":"{service}.amazonaws.com","signatureVersion":"v2","globalEndpoint":true},"*/route53":"globalSSL","cn-*/route53":{"endpoint":"{service}.amazonaws.com.cn","globalEndpoint":true,"signingRegion":"cn-northwest-1"},"us-gov-*/route53":"globalGovCloud","*/waf":"globalSSL","*/iam":"globalSSL","cn-*/iam":{"endpoint":"{service}.cn-north-1.amazonaws.com.cn","globalEndpoint":true,"signingRegion":"cn-north-1"},"us-gov-*/iam":"globalGovCloud","us-gov-*/sts":{"endpoint":"{service}.{region}.amazonaws.com"},"us-gov-west-1/s3":"s3signature","us-west-1/s3":"s3signature","us-west-2/s3":"s3signature","eu-west-1/s3":"s3signature","ap-southeast-1/s3":"s3signature","ap-southeast-2/s3":"s3signature","ap-northeast-1/s3":"s3signature","sa-east-1/s3":"s3signature","us-east-1/s3":{"endpoint":"{service}.amazonaws.com","signatureVersion":"s3"},"us-east-1/sdb":{"endpoint":"{service}.amazonaws.com","signatureVersion":"v2"},"*/sdb":{"endpoint":"{service}.{region}.amazonaws.com","signatureVersion":"v2"}},"patterns":{"globalSSL":{"endpoint":"https://{service}.amazonaws.com","globalEndpoint":true,"signingRegion":"us-east-1"},"globalGovCloud":{"endpoint":"{service}.us-gov.amazonaws.com","globalEndpoint":true,"signingRegion":"us-gov-west-1"},"s3signature":{"endpoint":"{service}.{region}.amazonaws.com","signatureVersion":"s3"}}}; - -/***/ }), - -/***/ 2592: -/***/ (function(module) { - -module.exports = {"pagination":{"ListAccessPoints":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListJobs":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"}}}; - -/***/ }), - -/***/ 2599: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2018-11-05","endpointPrefix":"transfer","jsonVersion":"1.1","protocol":"json","serviceAbbreviation":"AWS Transfer","serviceFullName":"AWS Transfer Family","serviceId":"Transfer","signatureVersion":"v4","signingName":"transfer","targetPrefix":"TransferService","uid":"transfer-2018-11-05"},"operations":{"CreateServer":{"input":{"type":"structure","members":{"Certificate":{},"EndpointDetails":{"shape":"S3"},"EndpointType":{},"HostKey":{"shape":"Sb"},"IdentityProviderDetails":{"shape":"Sc"},"IdentityProviderType":{},"LoggingRole":{},"Protocols":{"shape":"Sg"},"Tags":{"shape":"Si"}}},"output":{"type":"structure","required":["ServerId"],"members":{"ServerId":{}}}},"CreateUser":{"input":{"type":"structure","required":["Role","ServerId","UserName"],"members":{"HomeDirectory":{},"HomeDirectoryType":{},"HomeDirectoryMappings":{"shape":"Sr"},"Policy":{},"Role":{},"ServerId":{},"SshPublicKeyBody":{},"Tags":{"shape":"Si"},"UserName":{}}},"output":{"type":"structure","required":["ServerId","UserName"],"members":{"ServerId":{},"UserName":{}}}},"DeleteServer":{"input":{"type":"structure","required":["ServerId"],"members":{"ServerId":{}}}},"DeleteSshPublicKey":{"input":{"type":"structure","required":["ServerId","SshPublicKeyId","UserName"],"members":{"ServerId":{},"SshPublicKeyId":{},"UserName":{}}}},"DeleteUser":{"input":{"type":"structure","required":["ServerId","UserName"],"members":{"ServerId":{},"UserName":{}}}},"DescribeServer":{"input":{"type":"structure","required":["ServerId"],"members":{"ServerId":{}}},"output":{"type":"structure","required":["Server"],"members":{"Server":{"type":"structure","required":["Arn"],"members":{"Arn":{},"Certificate":{},"EndpointDetails":{"shape":"S3"},"EndpointType":{},"HostKeyFingerprint":{},"IdentityProviderDetails":{"shape":"Sc"},"IdentityProviderType":{},"LoggingRole":{},"Protocols":{"shape":"Sg"},"ServerId":{},"State":{},"Tags":{"shape":"Si"},"UserCount":{"type":"integer"}}}}}},"DescribeUser":{"input":{"type":"structure","required":["ServerId","UserName"],"members":{"ServerId":{},"UserName":{}}},"output":{"type":"structure","required":["ServerId","User"],"members":{"ServerId":{},"User":{"type":"structure","required":["Arn"],"members":{"Arn":{},"HomeDirectory":{},"HomeDirectoryMappings":{"shape":"Sr"},"HomeDirectoryType":{},"Policy":{},"Role":{},"SshPublicKeys":{"type":"list","member":{"type":"structure","required":["DateImported","SshPublicKeyBody","SshPublicKeyId"],"members":{"DateImported":{"type":"timestamp"},"SshPublicKeyBody":{},"SshPublicKeyId":{}}}},"Tags":{"shape":"Si"},"UserName":{}}}}}},"ImportSshPublicKey":{"input":{"type":"structure","required":["ServerId","SshPublicKeyBody","UserName"],"members":{"ServerId":{},"SshPublicKeyBody":{},"UserName":{}}},"output":{"type":"structure","required":["ServerId","SshPublicKeyId","UserName"],"members":{"ServerId":{},"SshPublicKeyId":{},"UserName":{}}}},"ListServers":{"input":{"type":"structure","members":{"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","required":["Servers"],"members":{"NextToken":{},"Servers":{"type":"list","member":{"type":"structure","required":["Arn"],"members":{"Arn":{},"IdentityProviderType":{},"EndpointType":{},"LoggingRole":{},"ServerId":{},"State":{},"UserCount":{"type":"integer"}}}}}}},"ListTagsForResource":{"input":{"type":"structure","required":["Arn"],"members":{"Arn":{},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"Arn":{},"NextToken":{},"Tags":{"shape":"Si"}}}},"ListUsers":{"input":{"type":"structure","required":["ServerId"],"members":{"MaxResults":{"type":"integer"},"NextToken":{},"ServerId":{}}},"output":{"type":"structure","required":["ServerId","Users"],"members":{"NextToken":{},"ServerId":{},"Users":{"type":"list","member":{"type":"structure","required":["Arn"],"members":{"Arn":{},"HomeDirectory":{},"HomeDirectoryType":{},"Role":{},"SshPublicKeyCount":{"type":"integer"},"UserName":{}}}}}}},"StartServer":{"input":{"type":"structure","required":["ServerId"],"members":{"ServerId":{}}}},"StopServer":{"input":{"type":"structure","required":["ServerId"],"members":{"ServerId":{}}}},"TagResource":{"input":{"type":"structure","required":["Arn","Tags"],"members":{"Arn":{},"Tags":{"shape":"Si"}}}},"TestIdentityProvider":{"input":{"type":"structure","required":["ServerId","UserName"],"members":{"ServerId":{},"ServerProtocol":{},"SourceIp":{},"UserName":{},"UserPassword":{"type":"string","sensitive":true}}},"output":{"type":"structure","required":["StatusCode","Url"],"members":{"Response":{},"StatusCode":{"type":"integer"},"Message":{},"Url":{}}}},"UntagResource":{"input":{"type":"structure","required":["Arn","TagKeys"],"members":{"Arn":{},"TagKeys":{"type":"list","member":{}}}}},"UpdateServer":{"input":{"type":"structure","required":["ServerId"],"members":{"Certificate":{},"EndpointDetails":{"shape":"S3"},"EndpointType":{},"HostKey":{"shape":"Sb"},"IdentityProviderDetails":{"shape":"Sc"},"LoggingRole":{},"Protocols":{"shape":"Sg"},"ServerId":{}}},"output":{"type":"structure","required":["ServerId"],"members":{"ServerId":{}}}},"UpdateUser":{"input":{"type":"structure","required":["ServerId","UserName"],"members":{"HomeDirectory":{},"HomeDirectoryType":{},"HomeDirectoryMappings":{"shape":"Sr"},"Policy":{},"Role":{},"ServerId":{},"UserName":{}}},"output":{"type":"structure","required":["ServerId","UserName"],"members":{"ServerId":{},"UserName":{}}}}},"shapes":{"S3":{"type":"structure","members":{"AddressAllocationIds":{"type":"list","member":{}},"SubnetIds":{"type":"list","member":{}},"VpcEndpointId":{},"VpcId":{}}},"Sb":{"type":"string","sensitive":true},"Sc":{"type":"structure","members":{"Url":{},"InvocationRole":{}}},"Sg":{"type":"list","member":{}},"Si":{"type":"list","member":{"type":"structure","required":["Key","Value"],"members":{"Key":{},"Value":{}}}},"Sr":{"type":"list","member":{"type":"structure","required":["Entry","Target"],"members":{"Entry":{},"Target":{}}}}}}; - -/***/ }), - -/***/ 2617: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['s3control'] = {}; -AWS.S3Control = Service.defineService('s3control', ['2018-08-20']); -__webpack_require__(1489); -Object.defineProperty(apiLoader.services['s3control'], '2018-08-20', { - get: function get() { - var model = __webpack_require__(6539); - model.paginators = __webpack_require__(2592).pagination; - return model; - }, - enumerable: true, - configurable: true -}); +const NODEJS_TIMEOUT_ERROR_CODES = ["ECONNRESET", "EPIPE", "ETIMEDOUT"]; -module.exports = AWS.S3Control; +const getTransformedHeaders = (headers) => { + const transformedHeaders = {}; + for (const name of Object.keys(headers)) { + const headerValues = headers[name]; + transformedHeaders[name] = Array.isArray(headerValues) ? headerValues.join(",") : headerValues; + } + return transformedHeaders; +}; +const timing = { + setTimeout: (cb, ms) => setTimeout(cb, ms), + clearTimeout: (timeoutId) => clearTimeout(timeoutId), +}; -/***/ }), +const DEFER_EVENT_LISTENER_TIME$2 = 1000; +const setConnectionTimeout = (request, reject, timeoutInMs = 0) => { + if (!timeoutInMs) { + return -1; + } + const registerTimeout = (offset) => { + const timeoutId = timing.setTimeout(() => { + request.destroy(); + reject(Object.assign(new Error(`@smithy/node-http-handler - the request socket did not establish a connection with the server within the configured timeout of ${timeoutInMs} ms.`), { + name: "TimeoutError", + })); + }, timeoutInMs - offset); + const doWithSocket = (socket) => { + if (socket?.connecting) { + socket.on("connect", () => { + timing.clearTimeout(timeoutId); + }); + } + else { + timing.clearTimeout(timeoutId); + } + }; + if (request.socket) { + doWithSocket(request.socket); + } + else { + request.on("socket", doWithSocket); + } + }; + if (timeoutInMs < 2000) { + registerTimeout(0); + return 0; + } + return timing.setTimeout(registerTimeout.bind(null, DEFER_EVENT_LISTENER_TIME$2), DEFER_EVENT_LISTENER_TIME$2); +}; -/***/ 2638: -/***/ (function(module) { +const setRequestTimeout = (req, reject, timeoutInMs = 0, throwOnRequestTimeout, logger) => { + if (timeoutInMs) { + return timing.setTimeout(() => { + let msg = `@smithy/node-http-handler - [${throwOnRequestTimeout ? "ERROR" : "WARN"}] a request has exceeded the configured ${timeoutInMs} ms requestTimeout.`; + if (throwOnRequestTimeout) { + const error = Object.assign(new Error(msg), { + name: "TimeoutError", + code: "ETIMEDOUT", + }); + req.destroy(error); + reject(error); + } + else { + msg += ` Init client requestHandler with throwOnRequestTimeout=true to turn this into an error.`; + logger?.warn?.(msg); + } + }, timeoutInMs); + } + return -1; +}; -module.exports = {"version":"2.0","metadata":{"apiVersion":"2017-01-11","endpointPrefix":"clouddirectory","protocol":"rest-json","serviceFullName":"Amazon CloudDirectory","serviceId":"CloudDirectory","signatureVersion":"v4","signingName":"clouddirectory","uid":"clouddirectory-2017-01-11"},"operations":{"AddFacetToObject":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/object/facets","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","SchemaFacet","ObjectReference"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"SchemaFacet":{"shape":"S3"},"ObjectAttributeList":{"shape":"S5"},"ObjectReference":{"shape":"Sf"}}},"output":{"type":"structure","members":{}}},"ApplySchema":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/schema/apply","responseCode":200},"input":{"type":"structure","required":["PublishedSchemaArn","DirectoryArn"],"members":{"PublishedSchemaArn":{},"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"}}},"output":{"type":"structure","members":{"AppliedSchemaArn":{},"DirectoryArn":{}}}},"AttachObject":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/object/attach","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","ParentReference","ChildReference","LinkName"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"ParentReference":{"shape":"Sf"},"ChildReference":{"shape":"Sf"},"LinkName":{}}},"output":{"type":"structure","members":{"AttachedObjectIdentifier":{}}}},"AttachPolicy":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/policy/attach","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","PolicyReference","ObjectReference"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"PolicyReference":{"shape":"Sf"},"ObjectReference":{"shape":"Sf"}}},"output":{"type":"structure","members":{}}},"AttachToIndex":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/index/attach","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","IndexReference","TargetReference"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"IndexReference":{"shape":"Sf"},"TargetReference":{"shape":"Sf"}}},"output":{"type":"structure","members":{"AttachedObjectIdentifier":{}}}},"AttachTypedLink":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/typedlink/attach","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","SourceObjectReference","TargetObjectReference","TypedLinkFacet","Attributes"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"SourceObjectReference":{"shape":"Sf"},"TargetObjectReference":{"shape":"Sf"},"TypedLinkFacet":{"shape":"St"},"Attributes":{"shape":"Sv"}}},"output":{"type":"structure","members":{"TypedLinkSpecifier":{"shape":"Sy"}}}},"BatchRead":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/batchread","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","Operations"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"Operations":{"type":"list","member":{"type":"structure","members":{"ListObjectAttributes":{"type":"structure","required":["ObjectReference"],"members":{"ObjectReference":{"shape":"Sf"},"NextToken":{},"MaxResults":{"type":"integer"},"FacetFilter":{"shape":"S3"}}},"ListObjectChildren":{"type":"structure","required":["ObjectReference"],"members":{"ObjectReference":{"shape":"Sf"},"NextToken":{},"MaxResults":{"type":"integer"}}},"ListAttachedIndices":{"type":"structure","required":["TargetReference"],"members":{"TargetReference":{"shape":"Sf"},"NextToken":{},"MaxResults":{"type":"integer"}}},"ListObjectParentPaths":{"type":"structure","required":["ObjectReference"],"members":{"ObjectReference":{"shape":"Sf"},"NextToken":{},"MaxResults":{"type":"integer"}}},"GetObjectInformation":{"type":"structure","required":["ObjectReference"],"members":{"ObjectReference":{"shape":"Sf"}}},"GetObjectAttributes":{"type":"structure","required":["ObjectReference","SchemaFacet","AttributeNames"],"members":{"ObjectReference":{"shape":"Sf"},"SchemaFacet":{"shape":"S3"},"AttributeNames":{"shape":"S1a"}}},"ListObjectParents":{"type":"structure","required":["ObjectReference"],"members":{"ObjectReference":{"shape":"Sf"},"NextToken":{},"MaxResults":{"type":"integer"}}},"ListObjectPolicies":{"type":"structure","required":["ObjectReference"],"members":{"ObjectReference":{"shape":"Sf"},"NextToken":{},"MaxResults":{"type":"integer"}}},"ListPolicyAttachments":{"type":"structure","required":["PolicyReference"],"members":{"PolicyReference":{"shape":"Sf"},"NextToken":{},"MaxResults":{"type":"integer"}}},"LookupPolicy":{"type":"structure","required":["ObjectReference"],"members":{"ObjectReference":{"shape":"Sf"},"NextToken":{},"MaxResults":{"type":"integer"}}},"ListIndex":{"type":"structure","required":["IndexReference"],"members":{"RangesOnIndexedValues":{"shape":"S1g"},"IndexReference":{"shape":"Sf"},"MaxResults":{"type":"integer"},"NextToken":{}}},"ListOutgoingTypedLinks":{"type":"structure","required":["ObjectReference"],"members":{"ObjectReference":{"shape":"Sf"},"FilterAttributeRanges":{"shape":"S1l"},"FilterTypedLink":{"shape":"St"},"NextToken":{},"MaxResults":{"type":"integer"}}},"ListIncomingTypedLinks":{"type":"structure","required":["ObjectReference"],"members":{"ObjectReference":{"shape":"Sf"},"FilterAttributeRanges":{"shape":"S1l"},"FilterTypedLink":{"shape":"St"},"NextToken":{},"MaxResults":{"type":"integer"}}},"GetLinkAttributes":{"type":"structure","required":["TypedLinkSpecifier","AttributeNames"],"members":{"TypedLinkSpecifier":{"shape":"Sy"},"AttributeNames":{"shape":"S1a"}}}}}},"ConsistencyLevel":{"location":"header","locationName":"x-amz-consistency-level"}}},"output":{"type":"structure","members":{"Responses":{"type":"list","member":{"type":"structure","members":{"SuccessfulResponse":{"type":"structure","members":{"ListObjectAttributes":{"type":"structure","members":{"Attributes":{"shape":"S5"},"NextToken":{}}},"ListObjectChildren":{"type":"structure","members":{"Children":{"shape":"S1w"},"NextToken":{}}},"GetObjectInformation":{"type":"structure","members":{"SchemaFacets":{"shape":"S1y"},"ObjectIdentifier":{}}},"GetObjectAttributes":{"type":"structure","members":{"Attributes":{"shape":"S5"}}},"ListAttachedIndices":{"type":"structure","members":{"IndexAttachments":{"shape":"S21"},"NextToken":{}}},"ListObjectParentPaths":{"type":"structure","members":{"PathToObjectIdentifiersList":{"shape":"S24"},"NextToken":{}}},"ListObjectPolicies":{"type":"structure","members":{"AttachedPolicyIds":{"shape":"S27"},"NextToken":{}}},"ListPolicyAttachments":{"type":"structure","members":{"ObjectIdentifiers":{"shape":"S27"},"NextToken":{}}},"LookupPolicy":{"type":"structure","members":{"PolicyToPathList":{"shape":"S2b"},"NextToken":{}}},"ListIndex":{"type":"structure","members":{"IndexAttachments":{"shape":"S21"},"NextToken":{}}},"ListOutgoingTypedLinks":{"type":"structure","members":{"TypedLinkSpecifiers":{"shape":"S2i"},"NextToken":{}}},"ListIncomingTypedLinks":{"type":"structure","members":{"LinkSpecifiers":{"shape":"S2i"},"NextToken":{}}},"GetLinkAttributes":{"type":"structure","members":{"Attributes":{"shape":"S5"}}},"ListObjectParents":{"type":"structure","members":{"ParentLinks":{"shape":"S2m"},"NextToken":{}}}}},"ExceptionResponse":{"type":"structure","members":{"Type":{},"Message":{}}}}}}}}},"BatchWrite":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/batchwrite","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","Operations"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"Operations":{"type":"list","member":{"type":"structure","members":{"CreateObject":{"type":"structure","required":["SchemaFacet","ObjectAttributeList"],"members":{"SchemaFacet":{"shape":"S1y"},"ObjectAttributeList":{"shape":"S5"},"ParentReference":{"shape":"Sf"},"LinkName":{},"BatchReferenceName":{}}},"AttachObject":{"type":"structure","required":["ParentReference","ChildReference","LinkName"],"members":{"ParentReference":{"shape":"Sf"},"ChildReference":{"shape":"Sf"},"LinkName":{}}},"DetachObject":{"type":"structure","required":["ParentReference","LinkName"],"members":{"ParentReference":{"shape":"Sf"},"LinkName":{},"BatchReferenceName":{}}},"UpdateObjectAttributes":{"type":"structure","required":["ObjectReference","AttributeUpdates"],"members":{"ObjectReference":{"shape":"Sf"},"AttributeUpdates":{"shape":"S2z"}}},"DeleteObject":{"type":"structure","required":["ObjectReference"],"members":{"ObjectReference":{"shape":"Sf"}}},"AddFacetToObject":{"type":"structure","required":["SchemaFacet","ObjectAttributeList","ObjectReference"],"members":{"SchemaFacet":{"shape":"S3"},"ObjectAttributeList":{"shape":"S5"},"ObjectReference":{"shape":"Sf"}}},"RemoveFacetFromObject":{"type":"structure","required":["SchemaFacet","ObjectReference"],"members":{"SchemaFacet":{"shape":"S3"},"ObjectReference":{"shape":"Sf"}}},"AttachPolicy":{"type":"structure","required":["PolicyReference","ObjectReference"],"members":{"PolicyReference":{"shape":"Sf"},"ObjectReference":{"shape":"Sf"}}},"DetachPolicy":{"type":"structure","required":["PolicyReference","ObjectReference"],"members":{"PolicyReference":{"shape":"Sf"},"ObjectReference":{"shape":"Sf"}}},"CreateIndex":{"type":"structure","required":["OrderedIndexedAttributeList","IsUnique"],"members":{"OrderedIndexedAttributeList":{"shape":"S39"},"IsUnique":{"type":"boolean"},"ParentReference":{"shape":"Sf"},"LinkName":{},"BatchReferenceName":{}}},"AttachToIndex":{"type":"structure","required":["IndexReference","TargetReference"],"members":{"IndexReference":{"shape":"Sf"},"TargetReference":{"shape":"Sf"}}},"DetachFromIndex":{"type":"structure","required":["IndexReference","TargetReference"],"members":{"IndexReference":{"shape":"Sf"},"TargetReference":{"shape":"Sf"}}},"AttachTypedLink":{"type":"structure","required":["SourceObjectReference","TargetObjectReference","TypedLinkFacet","Attributes"],"members":{"SourceObjectReference":{"shape":"Sf"},"TargetObjectReference":{"shape":"Sf"},"TypedLinkFacet":{"shape":"St"},"Attributes":{"shape":"Sv"}}},"DetachTypedLink":{"type":"structure","required":["TypedLinkSpecifier"],"members":{"TypedLinkSpecifier":{"shape":"Sy"}}},"UpdateLinkAttributes":{"type":"structure","required":["TypedLinkSpecifier","AttributeUpdates"],"members":{"TypedLinkSpecifier":{"shape":"Sy"},"AttributeUpdates":{"shape":"S3g"}}}}}}}},"output":{"type":"structure","members":{"Responses":{"type":"list","member":{"type":"structure","members":{"CreateObject":{"type":"structure","members":{"ObjectIdentifier":{}}},"AttachObject":{"type":"structure","members":{"attachedObjectIdentifier":{}}},"DetachObject":{"type":"structure","members":{"detachedObjectIdentifier":{}}},"UpdateObjectAttributes":{"type":"structure","members":{"ObjectIdentifier":{}}},"DeleteObject":{"type":"structure","members":{}},"AddFacetToObject":{"type":"structure","members":{}},"RemoveFacetFromObject":{"type":"structure","members":{}},"AttachPolicy":{"type":"structure","members":{}},"DetachPolicy":{"type":"structure","members":{}},"CreateIndex":{"type":"structure","members":{"ObjectIdentifier":{}}},"AttachToIndex":{"type":"structure","members":{"AttachedObjectIdentifier":{}}},"DetachFromIndex":{"type":"structure","members":{"DetachedObjectIdentifier":{}}},"AttachTypedLink":{"type":"structure","members":{"TypedLinkSpecifier":{"shape":"Sy"}}},"DetachTypedLink":{"type":"structure","members":{}},"UpdateLinkAttributes":{"type":"structure","members":{}}}}}}}},"CreateDirectory":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/directory/create","responseCode":200},"input":{"type":"structure","required":["Name","SchemaArn"],"members":{"Name":{},"SchemaArn":{"location":"header","locationName":"x-amz-data-partition"}}},"output":{"type":"structure","required":["DirectoryArn","Name","ObjectIdentifier","AppliedSchemaArn"],"members":{"DirectoryArn":{},"Name":{},"ObjectIdentifier":{},"AppliedSchemaArn":{}}}},"CreateFacet":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/facet/create","responseCode":200},"input":{"type":"structure","required":["SchemaArn","Name"],"members":{"SchemaArn":{"location":"header","locationName":"x-amz-data-partition"},"Name":{},"Attributes":{"shape":"S46"},"ObjectType":{},"FacetStyle":{}}},"output":{"type":"structure","members":{}}},"CreateIndex":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/index","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","OrderedIndexedAttributeList","IsUnique"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"OrderedIndexedAttributeList":{"shape":"S39"},"IsUnique":{"type":"boolean"},"ParentReference":{"shape":"Sf"},"LinkName":{}}},"output":{"type":"structure","members":{"ObjectIdentifier":{}}}},"CreateObject":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/object","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","SchemaFacets"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"SchemaFacets":{"shape":"S1y"},"ObjectAttributeList":{"shape":"S5"},"ParentReference":{"shape":"Sf"},"LinkName":{}}},"output":{"type":"structure","members":{"ObjectIdentifier":{}}}},"CreateSchema":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/schema/create","responseCode":200},"input":{"type":"structure","required":["Name"],"members":{"Name":{}}},"output":{"type":"structure","members":{"SchemaArn":{}}}},"CreateTypedLinkFacet":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/typedlink/facet/create","responseCode":200},"input":{"type":"structure","required":["SchemaArn","Facet"],"members":{"SchemaArn":{"location":"header","locationName":"x-amz-data-partition"},"Facet":{"type":"structure","required":["Name","Attributes","IdentityAttributeOrder"],"members":{"Name":{},"Attributes":{"shape":"S4v"},"IdentityAttributeOrder":{"shape":"S1a"}}}}},"output":{"type":"structure","members":{}}},"DeleteDirectory":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/directory","responseCode":200},"input":{"type":"structure","required":["DirectoryArn"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"}}},"output":{"type":"structure","required":["DirectoryArn"],"members":{"DirectoryArn":{}}}},"DeleteFacet":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/facet/delete","responseCode":200},"input":{"type":"structure","required":["SchemaArn","Name"],"members":{"SchemaArn":{"location":"header","locationName":"x-amz-data-partition"},"Name":{}}},"output":{"type":"structure","members":{}}},"DeleteObject":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/object/delete","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","ObjectReference"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"ObjectReference":{"shape":"Sf"}}},"output":{"type":"structure","members":{}}},"DeleteSchema":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/schema","responseCode":200},"input":{"type":"structure","required":["SchemaArn"],"members":{"SchemaArn":{"location":"header","locationName":"x-amz-data-partition"}}},"output":{"type":"structure","members":{"SchemaArn":{}}}},"DeleteTypedLinkFacet":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/typedlink/facet/delete","responseCode":200},"input":{"type":"structure","required":["SchemaArn","Name"],"members":{"SchemaArn":{"location":"header","locationName":"x-amz-data-partition"},"Name":{}}},"output":{"type":"structure","members":{}}},"DetachFromIndex":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/index/detach","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","IndexReference","TargetReference"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"IndexReference":{"shape":"Sf"},"TargetReference":{"shape":"Sf"}}},"output":{"type":"structure","members":{"DetachedObjectIdentifier":{}}}},"DetachObject":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/object/detach","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","ParentReference","LinkName"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"ParentReference":{"shape":"Sf"},"LinkName":{}}},"output":{"type":"structure","members":{"DetachedObjectIdentifier":{}}}},"DetachPolicy":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/policy/detach","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","PolicyReference","ObjectReference"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"PolicyReference":{"shape":"Sf"},"ObjectReference":{"shape":"Sf"}}},"output":{"type":"structure","members":{}}},"DetachTypedLink":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/typedlink/detach","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","TypedLinkSpecifier"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"TypedLinkSpecifier":{"shape":"Sy"}}}},"DisableDirectory":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/directory/disable","responseCode":200},"input":{"type":"structure","required":["DirectoryArn"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"}}},"output":{"type":"structure","required":["DirectoryArn"],"members":{"DirectoryArn":{}}}},"EnableDirectory":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/directory/enable","responseCode":200},"input":{"type":"structure","required":["DirectoryArn"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"}}},"output":{"type":"structure","required":["DirectoryArn"],"members":{"DirectoryArn":{}}}},"GetAppliedSchemaVersion":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/schema/getappliedschema","responseCode":200},"input":{"type":"structure","required":["SchemaArn"],"members":{"SchemaArn":{}}},"output":{"type":"structure","members":{"AppliedSchemaArn":{}}}},"GetDirectory":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/directory/get","responseCode":200},"input":{"type":"structure","required":["DirectoryArn"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"}}},"output":{"type":"structure","required":["Directory"],"members":{"Directory":{"shape":"S5n"}}}},"GetFacet":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/facet","responseCode":200},"input":{"type":"structure","required":["SchemaArn","Name"],"members":{"SchemaArn":{"location":"header","locationName":"x-amz-data-partition"},"Name":{}}},"output":{"type":"structure","members":{"Facet":{"type":"structure","members":{"Name":{},"ObjectType":{},"FacetStyle":{}}}}}},"GetLinkAttributes":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/typedlink/attributes/get","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","TypedLinkSpecifier","AttributeNames"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"TypedLinkSpecifier":{"shape":"Sy"},"AttributeNames":{"shape":"S1a"},"ConsistencyLevel":{}}},"output":{"type":"structure","members":{"Attributes":{"shape":"S5"}}}},"GetObjectAttributes":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/object/attributes/get","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","ObjectReference","SchemaFacet","AttributeNames"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"ObjectReference":{"shape":"Sf"},"ConsistencyLevel":{"location":"header","locationName":"x-amz-consistency-level"},"SchemaFacet":{"shape":"S3"},"AttributeNames":{"shape":"S1a"}}},"output":{"type":"structure","members":{"Attributes":{"shape":"S5"}}}},"GetObjectInformation":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/object/information","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","ObjectReference"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"ObjectReference":{"shape":"Sf"},"ConsistencyLevel":{"location":"header","locationName":"x-amz-consistency-level"}}},"output":{"type":"structure","members":{"SchemaFacets":{"shape":"S1y"},"ObjectIdentifier":{}}}},"GetSchemaAsJson":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/schema/json","responseCode":200},"input":{"type":"structure","required":["SchemaArn"],"members":{"SchemaArn":{"location":"header","locationName":"x-amz-data-partition"}}},"output":{"type":"structure","members":{"Name":{},"Document":{}}}},"GetTypedLinkFacetInformation":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/typedlink/facet/get","responseCode":200},"input":{"type":"structure","required":["SchemaArn","Name"],"members":{"SchemaArn":{"location":"header","locationName":"x-amz-data-partition"},"Name":{}}},"output":{"type":"structure","members":{"IdentityAttributeOrder":{"shape":"S1a"}}}},"ListAppliedSchemaArns":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/schema/applied","responseCode":200},"input":{"type":"structure","required":["DirectoryArn"],"members":{"DirectoryArn":{},"SchemaArn":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"SchemaArns":{"shape":"S66"},"NextToken":{}}}},"ListAttachedIndices":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/object/indices","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","TargetReference"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"TargetReference":{"shape":"Sf"},"NextToken":{},"MaxResults":{"type":"integer"},"ConsistencyLevel":{"location":"header","locationName":"x-amz-consistency-level"}}},"output":{"type":"structure","members":{"IndexAttachments":{"shape":"S21"},"NextToken":{}}}},"ListDevelopmentSchemaArns":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/schema/development","responseCode":200},"input":{"type":"structure","members":{"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"SchemaArns":{"shape":"S66"},"NextToken":{}}}},"ListDirectories":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/directory/list","responseCode":200},"input":{"type":"structure","members":{"NextToken":{},"MaxResults":{"type":"integer"},"state":{}}},"output":{"type":"structure","required":["Directories"],"members":{"Directories":{"type":"list","member":{"shape":"S5n"}},"NextToken":{}}}},"ListFacetAttributes":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/facet/attributes","responseCode":200},"input":{"type":"structure","required":["SchemaArn","Name"],"members":{"SchemaArn":{"location":"header","locationName":"x-amz-data-partition"},"Name":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"Attributes":{"shape":"S46"},"NextToken":{}}}},"ListFacetNames":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/facet/list","responseCode":200},"input":{"type":"structure","required":["SchemaArn"],"members":{"SchemaArn":{"location":"header","locationName":"x-amz-data-partition"},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"FacetNames":{"type":"list","member":{}},"NextToken":{}}}},"ListIncomingTypedLinks":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/typedlink/incoming","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","ObjectReference"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"ObjectReference":{"shape":"Sf"},"FilterAttributeRanges":{"shape":"S1l"},"FilterTypedLink":{"shape":"St"},"NextToken":{},"MaxResults":{"type":"integer"},"ConsistencyLevel":{}}},"output":{"type":"structure","members":{"LinkSpecifiers":{"shape":"S2i"},"NextToken":{}}}},"ListIndex":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/index/targets","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","IndexReference"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"RangesOnIndexedValues":{"shape":"S1g"},"IndexReference":{"shape":"Sf"},"MaxResults":{"type":"integer"},"NextToken":{},"ConsistencyLevel":{"location":"header","locationName":"x-amz-consistency-level"}}},"output":{"type":"structure","members":{"IndexAttachments":{"shape":"S21"},"NextToken":{}}}},"ListManagedSchemaArns":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/schema/managed","responseCode":200},"input":{"type":"structure","members":{"SchemaArn":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"SchemaArns":{"shape":"S66"},"NextToken":{}}}},"ListObjectAttributes":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/object/attributes","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","ObjectReference"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"ObjectReference":{"shape":"Sf"},"NextToken":{},"MaxResults":{"type":"integer"},"ConsistencyLevel":{"location":"header","locationName":"x-amz-consistency-level"},"FacetFilter":{"shape":"S3"}}},"output":{"type":"structure","members":{"Attributes":{"shape":"S5"},"NextToken":{}}}},"ListObjectChildren":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/object/children","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","ObjectReference"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"ObjectReference":{"shape":"Sf"},"NextToken":{},"MaxResults":{"type":"integer"},"ConsistencyLevel":{"location":"header","locationName":"x-amz-consistency-level"}}},"output":{"type":"structure","members":{"Children":{"shape":"S1w"},"NextToken":{}}}},"ListObjectParentPaths":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/object/parentpaths","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","ObjectReference"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"ObjectReference":{"shape":"Sf"},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"PathToObjectIdentifiersList":{"shape":"S24"},"NextToken":{}}}},"ListObjectParents":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/object/parent","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","ObjectReference"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"ObjectReference":{"shape":"Sf"},"NextToken":{},"MaxResults":{"type":"integer"},"ConsistencyLevel":{"location":"header","locationName":"x-amz-consistency-level"},"IncludeAllLinksToEachParent":{"type":"boolean"}}},"output":{"type":"structure","members":{"Parents":{"type":"map","key":{},"value":{}},"NextToken":{},"ParentLinks":{"shape":"S2m"}}}},"ListObjectPolicies":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/object/policy","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","ObjectReference"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"ObjectReference":{"shape":"Sf"},"NextToken":{},"MaxResults":{"type":"integer"},"ConsistencyLevel":{"location":"header","locationName":"x-amz-consistency-level"}}},"output":{"type":"structure","members":{"AttachedPolicyIds":{"shape":"S27"},"NextToken":{}}}},"ListOutgoingTypedLinks":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/typedlink/outgoing","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","ObjectReference"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"ObjectReference":{"shape":"Sf"},"FilterAttributeRanges":{"shape":"S1l"},"FilterTypedLink":{"shape":"St"},"NextToken":{},"MaxResults":{"type":"integer"},"ConsistencyLevel":{}}},"output":{"type":"structure","members":{"TypedLinkSpecifiers":{"shape":"S2i"},"NextToken":{}}}},"ListPolicyAttachments":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/policy/attachment","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","PolicyReference"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"PolicyReference":{"shape":"Sf"},"NextToken":{},"MaxResults":{"type":"integer"},"ConsistencyLevel":{"location":"header","locationName":"x-amz-consistency-level"}}},"output":{"type":"structure","members":{"ObjectIdentifiers":{"shape":"S27"},"NextToken":{}}}},"ListPublishedSchemaArns":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/schema/published","responseCode":200},"input":{"type":"structure","members":{"SchemaArn":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"SchemaArns":{"shape":"S66"},"NextToken":{}}}},"ListTagsForResource":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/tags","responseCode":200},"input":{"type":"structure","required":["ResourceArn"],"members":{"ResourceArn":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"Tags":{"shape":"S79"},"NextToken":{}}}},"ListTypedLinkFacetAttributes":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/typedlink/facet/attributes","responseCode":200},"input":{"type":"structure","required":["SchemaArn","Name"],"members":{"SchemaArn":{"location":"header","locationName":"x-amz-data-partition"},"Name":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"Attributes":{"shape":"S4v"},"NextToken":{}}}},"ListTypedLinkFacetNames":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/typedlink/facet/list","responseCode":200},"input":{"type":"structure","required":["SchemaArn"],"members":{"SchemaArn":{"location":"header","locationName":"x-amz-data-partition"},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"FacetNames":{"type":"list","member":{}},"NextToken":{}}}},"LookupPolicy":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/policy/lookup","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","ObjectReference"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"ObjectReference":{"shape":"Sf"},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"PolicyToPathList":{"shape":"S2b"},"NextToken":{}}}},"PublishSchema":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/schema/publish","responseCode":200},"input":{"type":"structure","required":["DevelopmentSchemaArn","Version"],"members":{"DevelopmentSchemaArn":{"location":"header","locationName":"x-amz-data-partition"},"Version":{},"MinorVersion":{},"Name":{}}},"output":{"type":"structure","members":{"PublishedSchemaArn":{}}}},"PutSchemaFromJson":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/schema/json","responseCode":200},"input":{"type":"structure","required":["SchemaArn","Document"],"members":{"SchemaArn":{"location":"header","locationName":"x-amz-data-partition"},"Document":{}}},"output":{"type":"structure","members":{"Arn":{}}}},"RemoveFacetFromObject":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/object/facets/delete","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","SchemaFacet","ObjectReference"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"SchemaFacet":{"shape":"S3"},"ObjectReference":{"shape":"Sf"}}},"output":{"type":"structure","members":{}}},"TagResource":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/tags/add","responseCode":200},"input":{"type":"structure","required":["ResourceArn","Tags"],"members":{"ResourceArn":{},"Tags":{"shape":"S79"}}},"output":{"type":"structure","members":{}}},"UntagResource":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/tags/remove","responseCode":200},"input":{"type":"structure","required":["ResourceArn","TagKeys"],"members":{"ResourceArn":{},"TagKeys":{"type":"list","member":{}}}},"output":{"type":"structure","members":{}}},"UpdateFacet":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/facet","responseCode":200},"input":{"type":"structure","required":["SchemaArn","Name"],"members":{"SchemaArn":{"location":"header","locationName":"x-amz-data-partition"},"Name":{},"AttributeUpdates":{"type":"list","member":{"type":"structure","members":{"Attribute":{"shape":"S47"},"Action":{}}}},"ObjectType":{}}},"output":{"type":"structure","members":{}}},"UpdateLinkAttributes":{"http":{"requestUri":"/amazonclouddirectory/2017-01-11/typedlink/attributes/update","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","TypedLinkSpecifier","AttributeUpdates"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"TypedLinkSpecifier":{"shape":"Sy"},"AttributeUpdates":{"shape":"S3g"}}},"output":{"type":"structure","members":{}}},"UpdateObjectAttributes":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/object/update","responseCode":200},"input":{"type":"structure","required":["DirectoryArn","ObjectReference","AttributeUpdates"],"members":{"DirectoryArn":{"location":"header","locationName":"x-amz-data-partition"},"ObjectReference":{"shape":"Sf"},"AttributeUpdates":{"shape":"S2z"}}},"output":{"type":"structure","members":{"ObjectIdentifier":{}}}},"UpdateSchema":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/schema/update","responseCode":200},"input":{"type":"structure","required":["SchemaArn","Name"],"members":{"SchemaArn":{"location":"header","locationName":"x-amz-data-partition"},"Name":{}}},"output":{"type":"structure","members":{"SchemaArn":{}}}},"UpdateTypedLinkFacet":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/typedlink/facet","responseCode":200},"input":{"type":"structure","required":["SchemaArn","Name","AttributeUpdates","IdentityAttributeOrder"],"members":{"SchemaArn":{"location":"header","locationName":"x-amz-data-partition"},"Name":{},"AttributeUpdates":{"type":"list","member":{"type":"structure","required":["Attribute","Action"],"members":{"Attribute":{"shape":"S4w"},"Action":{}}}},"IdentityAttributeOrder":{"shape":"S1a"}}},"output":{"type":"structure","members":{}}},"UpgradeAppliedSchema":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/schema/upgradeapplied","responseCode":200},"input":{"type":"structure","required":["PublishedSchemaArn","DirectoryArn"],"members":{"PublishedSchemaArn":{},"DirectoryArn":{},"DryRun":{"type":"boolean"}}},"output":{"type":"structure","members":{"UpgradedSchemaArn":{},"DirectoryArn":{}}}},"UpgradePublishedSchema":{"http":{"method":"PUT","requestUri":"/amazonclouddirectory/2017-01-11/schema/upgradepublished","responseCode":200},"input":{"type":"structure","required":["DevelopmentSchemaArn","PublishedSchemaArn","MinorVersion"],"members":{"DevelopmentSchemaArn":{},"PublishedSchemaArn":{},"MinorVersion":{},"DryRun":{"type":"boolean"}}},"output":{"type":"structure","members":{"UpgradedSchemaArn":{}}}}},"shapes":{"S3":{"type":"structure","members":{"SchemaArn":{},"FacetName":{}}},"S5":{"type":"list","member":{"type":"structure","required":["Key","Value"],"members":{"Key":{"shape":"S7"},"Value":{"shape":"S9"}}}},"S7":{"type":"structure","required":["SchemaArn","FacetName","Name"],"members":{"SchemaArn":{},"FacetName":{},"Name":{}}},"S9":{"type":"structure","members":{"StringValue":{},"BinaryValue":{"type":"blob"},"BooleanValue":{"type":"boolean"},"NumberValue":{},"DatetimeValue":{"type":"timestamp"}}},"Sf":{"type":"structure","members":{"Selector":{}}},"St":{"type":"structure","required":["SchemaArn","TypedLinkName"],"members":{"SchemaArn":{},"TypedLinkName":{}}},"Sv":{"type":"list","member":{"type":"structure","required":["AttributeName","Value"],"members":{"AttributeName":{},"Value":{"shape":"S9"}}}},"Sy":{"type":"structure","required":["TypedLinkFacet","SourceObjectReference","TargetObjectReference","IdentityAttributeValues"],"members":{"TypedLinkFacet":{"shape":"St"},"SourceObjectReference":{"shape":"Sf"},"TargetObjectReference":{"shape":"Sf"},"IdentityAttributeValues":{"shape":"Sv"}}},"S1a":{"type":"list","member":{}},"S1g":{"type":"list","member":{"type":"structure","members":{"AttributeKey":{"shape":"S7"},"Range":{"shape":"S1i"}}}},"S1i":{"type":"structure","required":["StartMode","EndMode"],"members":{"StartMode":{},"StartValue":{"shape":"S9"},"EndMode":{},"EndValue":{"shape":"S9"}}},"S1l":{"type":"list","member":{"type":"structure","required":["Range"],"members":{"AttributeName":{},"Range":{"shape":"S1i"}}}},"S1w":{"type":"map","key":{},"value":{}},"S1y":{"type":"list","member":{"shape":"S3"}},"S21":{"type":"list","member":{"type":"structure","members":{"IndexedAttributes":{"shape":"S5"},"ObjectIdentifier":{}}}},"S24":{"type":"list","member":{"type":"structure","members":{"Path":{},"ObjectIdentifiers":{"shape":"S27"}}}},"S27":{"type":"list","member":{}},"S2b":{"type":"list","member":{"type":"structure","members":{"Path":{},"Policies":{"type":"list","member":{"type":"structure","members":{"PolicyId":{},"ObjectIdentifier":{},"PolicyType":{}}}}}}},"S2i":{"type":"list","member":{"shape":"Sy"}},"S2m":{"type":"list","member":{"type":"structure","members":{"ObjectIdentifier":{},"LinkName":{}}}},"S2z":{"type":"list","member":{"type":"structure","members":{"ObjectAttributeKey":{"shape":"S7"},"ObjectAttributeAction":{"type":"structure","members":{"ObjectAttributeActionType":{},"ObjectAttributeUpdateValue":{"shape":"S9"}}}}}},"S39":{"type":"list","member":{"shape":"S7"}},"S3g":{"type":"list","member":{"type":"structure","members":{"AttributeKey":{"shape":"S7"},"AttributeAction":{"type":"structure","members":{"AttributeActionType":{},"AttributeUpdateValue":{"shape":"S9"}}}}}},"S46":{"type":"list","member":{"shape":"S47"}},"S47":{"type":"structure","required":["Name"],"members":{"Name":{},"AttributeDefinition":{"type":"structure","required":["Type"],"members":{"Type":{},"DefaultValue":{"shape":"S9"},"IsImmutable":{"type":"boolean"},"Rules":{"shape":"S4a"}}},"AttributeReference":{"type":"structure","required":["TargetFacetName","TargetAttributeName"],"members":{"TargetFacetName":{},"TargetAttributeName":{}}},"RequiredBehavior":{}}},"S4a":{"type":"map","key":{},"value":{"type":"structure","members":{"Type":{},"Parameters":{"type":"map","key":{},"value":{}}}}},"S4v":{"type":"list","member":{"shape":"S4w"}},"S4w":{"type":"structure","required":["Name","Type","RequiredBehavior"],"members":{"Name":{},"Type":{},"DefaultValue":{"shape":"S9"},"IsImmutable":{"type":"boolean"},"Rules":{"shape":"S4a"},"RequiredBehavior":{}}},"S5n":{"type":"structure","members":{"Name":{},"DirectoryArn":{},"State":{},"CreationDateTime":{"type":"timestamp"}}},"S66":{"type":"list","member":{}},"S79":{"type":"list","member":{"type":"structure","members":{"Key":{},"Value":{}}}}}}; +const DEFER_EVENT_LISTENER_TIME$1 = 3000; +const setSocketKeepAlive = (request, { keepAlive, keepAliveMsecs }, deferTimeMs = DEFER_EVENT_LISTENER_TIME$1) => { + if (keepAlive !== true) { + return -1; + } + const registerListener = () => { + if (request.socket) { + request.socket.setKeepAlive(keepAlive, keepAliveMsecs || 0); + } + else { + request.on("socket", (socket) => { + socket.setKeepAlive(keepAlive, keepAliveMsecs || 0); + }); + } + }; + if (deferTimeMs === 0) { + registerListener(); + return 0; + } + return timing.setTimeout(registerListener, deferTimeMs); +}; -/***/ }), +const DEFER_EVENT_LISTENER_TIME = 3000; +const setSocketTimeout = (request, reject, timeoutInMs = 0) => { + const registerTimeout = (offset) => { + const timeout = timeoutInMs - offset; + const onTimeout = () => { + request.destroy(); + reject(Object.assign(new Error(`@smithy/node-http-handler - the request socket timed out after ${timeoutInMs} ms of inactivity (configured by client requestHandler).`), { name: "TimeoutError" })); + }; + if (request.socket) { + request.socket.setTimeout(timeout, onTimeout); + request.on("close", () => request.socket?.removeListener("timeout", onTimeout)); + } + else { + request.setTimeout(timeout, onTimeout); + } + }; + if (0 < timeoutInMs && timeoutInMs < 6000) { + registerTimeout(0); + return 0; + } + return timing.setTimeout(registerTimeout.bind(null, timeoutInMs === 0 ? 0 : DEFER_EVENT_LISTENER_TIME), DEFER_EVENT_LISTENER_TIME); +}; -/***/ 2641: -/***/ (function(module, __unusedexports, __webpack_require__) { +const MIN_WAIT_TIME = 6_000; +async function writeRequestBody(httpRequest, request, maxContinueTimeoutMs = MIN_WAIT_TIME, externalAgent = false) { + const headers = request.headers ?? {}; + const expect = headers.Expect || headers.expect; + let timeoutId = -1; + let sendBody = true; + if (!externalAgent && expect === "100-continue") { + sendBody = await Promise.race([ + new Promise((resolve) => { + timeoutId = Number(timing.setTimeout(() => resolve(true), Math.max(MIN_WAIT_TIME, maxContinueTimeoutMs))); + }), + new Promise((resolve) => { + httpRequest.on("continue", () => { + timing.clearTimeout(timeoutId); + resolve(true); + }); + httpRequest.on("response", () => { + timing.clearTimeout(timeoutId); + resolve(false); + }); + httpRequest.on("error", () => { + timing.clearTimeout(timeoutId); + resolve(false); + }); + }), + ]); + } + if (sendBody) { + writeBody(httpRequest, request.body); + } +} +function writeBody(httpRequest, body) { + if (body instanceof stream.Readable) { + body.pipe(httpRequest); + return; + } + if (body) { + if (Buffer.isBuffer(body) || typeof body === "string") { + httpRequest.end(body); + return; + } + const uint8 = body; + if (typeof uint8 === "object" && + uint8.buffer && + typeof uint8.byteOffset === "number" && + typeof uint8.byteLength === "number") { + httpRequest.end(Buffer.from(uint8.buffer, uint8.byteOffset, uint8.byteLength)); + return; + } + httpRequest.end(Buffer.from(body)); + return; + } + httpRequest.end(); +} -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +const DEFAULT_REQUEST_TIMEOUT = 0; +class NodeHttpHandler { + config; + configProvider; + socketWarningTimestamp = 0; + externalAgent = false; + metadata = { handlerProtocol: "http/1.1" }; + static create(instanceOrOptions) { + if (typeof instanceOrOptions?.handle === "function") { + return instanceOrOptions; + } + return new NodeHttpHandler(instanceOrOptions); + } + static checkSocketUsage(agent, socketWarningTimestamp, logger = console) { + const { sockets, requests, maxSockets } = agent; + if (typeof maxSockets !== "number" || maxSockets === Infinity) { + return socketWarningTimestamp; + } + const interval = 15_000; + if (Date.now() - interval < socketWarningTimestamp) { + return socketWarningTimestamp; + } + if (sockets && requests) { + for (const origin in sockets) { + const socketsInUse = sockets[origin]?.length ?? 0; + const requestsEnqueued = requests[origin]?.length ?? 0; + if (socketsInUse >= maxSockets && requestsEnqueued >= 2 * maxSockets) { + logger?.warn?.(`@smithy/node-http-handler:WARN - socket usage at capacity=${socketsInUse} and ${requestsEnqueued} additional requests are enqueued. +See https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-configuring-maxsockets.html +or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler config.`); + return Date.now(); + } + } + } + return socketWarningTimestamp; + } + constructor(options) { + this.configProvider = new Promise((resolve, reject) => { + if (typeof options === "function") { + options() + .then((_options) => { + resolve(this.resolveDefaultConfig(_options)); + }) + .catch(reject); + } + else { + resolve(this.resolveDefaultConfig(options)); + } + }); + } + resolveDefaultConfig(options) { + const { requestTimeout, connectionTimeout, socketTimeout, socketAcquisitionWarningTimeout, httpAgent, httpsAgent, throwOnRequestTimeout, logger, } = options || {}; + const keepAlive = true; + const maxSockets = 50; + return { + connectionTimeout, + requestTimeout, + socketTimeout, + socketAcquisitionWarningTimeout, + throwOnRequestTimeout, + httpAgent: (() => { + if (httpAgent instanceof http.Agent || typeof httpAgent?.destroy === "function") { + this.externalAgent = true; + return httpAgent; + } + return new http.Agent({ keepAlive, maxSockets, ...httpAgent }); + })(), + httpsAgent: (() => { + if (httpsAgent instanceof https.Agent || typeof httpsAgent?.destroy === "function") { + this.externalAgent = true; + return httpsAgent; + } + return new https.Agent({ keepAlive, maxSockets, ...httpsAgent }); + })(), + logger, + }; + } + destroy() { + this.config?.httpAgent?.destroy(); + this.config?.httpsAgent?.destroy(); + } + async handle(request, { abortSignal, requestTimeout } = {}) { + if (!this.config) { + this.config = await this.configProvider; + } + return new Promise((_resolve, _reject) => { + const config = this.config; + let writeRequestBodyPromise = undefined; + const timeouts = []; + const resolve = async (arg) => { + await writeRequestBodyPromise; + timeouts.forEach(timing.clearTimeout); + _resolve(arg); + }; + const reject = async (arg) => { + await writeRequestBodyPromise; + timeouts.forEach(timing.clearTimeout); + _reject(arg); + }; + if (abortSignal?.aborted) { + const abortError = new Error("Request aborted"); + abortError.name = "AbortError"; + reject(abortError); + return; + } + const isSSL = request.protocol === "https:"; + const headers = request.headers ?? {}; + const expectContinue = (headers.Expect ?? headers.expect) === "100-continue"; + let agent = isSSL ? config.httpsAgent : config.httpAgent; + if (expectContinue && !this.externalAgent) { + agent = new (isSSL ? https.Agent : http.Agent)({ + keepAlive: false, + maxSockets: Infinity, + }); + } + timeouts.push(timing.setTimeout(() => { + this.socketWarningTimestamp = NodeHttpHandler.checkSocketUsage(agent, this.socketWarningTimestamp, config.logger); + }, config.socketAcquisitionWarningTimeout ?? (config.requestTimeout ?? 2000) + (config.connectionTimeout ?? 1000))); + const queryString = querystringBuilder.buildQueryString(request.query || {}); + let auth = undefined; + if (request.username != null || request.password != null) { + const username = request.username ?? ""; + const password = request.password ?? ""; + auth = `${username}:${password}`; + } + let path = request.path; + if (queryString) { + path += `?${queryString}`; + } + if (request.fragment) { + path += `#${request.fragment}`; + } + let hostname = request.hostname ?? ""; + if (hostname[0] === "[" && hostname.endsWith("]")) { + hostname = request.hostname.slice(1, -1); + } + else { + hostname = request.hostname; + } + const nodeHttpsOptions = { + headers: request.headers, + host: hostname, + method: request.method, + path, + port: request.port, + agent, + auth, + }; + const requestFunc = isSSL ? https.request : http.request; + const req = requestFunc(nodeHttpsOptions, (res) => { + const httpResponse = new protocolHttp.HttpResponse({ + statusCode: res.statusCode || -1, + reason: res.statusMessage, + headers: getTransformedHeaders(res.headers), + body: res, + }); + resolve({ response: httpResponse }); + }); + req.on("error", (err) => { + if (NODEJS_TIMEOUT_ERROR_CODES.includes(err.code)) { + reject(Object.assign(err, { name: "TimeoutError" })); + } + else { + reject(err); + } + }); + if (abortSignal) { + const onAbort = () => { + req.destroy(); + const abortError = new Error("Request aborted"); + abortError.name = "AbortError"; + reject(abortError); + }; + if (typeof abortSignal.addEventListener === "function") { + const signal = abortSignal; + signal.addEventListener("abort", onAbort, { once: true }); + req.once("close", () => signal.removeEventListener("abort", onAbort)); + } + else { + abortSignal.onabort = onAbort; + } + } + const effectiveRequestTimeout = requestTimeout ?? config.requestTimeout; + timeouts.push(setConnectionTimeout(req, reject, config.connectionTimeout)); + timeouts.push(setRequestTimeout(req, reject, effectiveRequestTimeout, config.throwOnRequestTimeout, config.logger ?? console)); + timeouts.push(setSocketTimeout(req, reject, config.socketTimeout)); + const httpAgent = nodeHttpsOptions.agent; + if (typeof httpAgent === "object" && "keepAlive" in httpAgent) { + timeouts.push(setSocketKeepAlive(req, { + keepAlive: httpAgent.keepAlive, + keepAliveMsecs: httpAgent.keepAliveMsecs, + })); + } + writeRequestBodyPromise = writeRequestBody(req, request, effectiveRequestTimeout, this.externalAgent).catch((e) => { + timeouts.forEach(timing.clearTimeout); + return _reject(e); + }); + }); + } + updateHttpClientConfig(key, value) { + this.config = undefined; + this.configProvider = this.configProvider.then((config) => { + return { + ...config, + [key]: value, + }; + }); + } + httpHandlerConfigs() { + return this.config ?? {}; + } +} -apiLoader.services['kinesisvideosignalingchannels'] = {}; -AWS.KinesisVideoSignalingChannels = Service.defineService('kinesisvideosignalingchannels', ['2019-12-04']); -Object.defineProperty(apiLoader.services['kinesisvideosignalingchannels'], '2019-12-04', { - get: function get() { - var model = __webpack_require__(1713); - model.paginators = __webpack_require__(1529).pagination; - return model; - }, - enumerable: true, - configurable: true -}); +class NodeHttp2ConnectionPool { + sessions = []; + constructor(sessions) { + this.sessions = sessions ?? []; + } + poll() { + if (this.sessions.length > 0) { + return this.sessions.shift(); + } + } + offerLast(session) { + this.sessions.push(session); + } + contains(session) { + return this.sessions.includes(session); + } + remove(session) { + this.sessions = this.sessions.filter((s) => s !== session); + } + [Symbol.iterator]() { + return this.sessions[Symbol.iterator](); + } + destroy(connection) { + for (const session of this.sessions) { + if (session === connection) { + if (!session.destroyed) { + session.destroy(); + } + } + } + } +} + +class NodeHttp2ConnectionManager { + constructor(config) { + this.config = config; + if (this.config.maxConcurrency && this.config.maxConcurrency <= 0) { + throw new RangeError("maxConcurrency must be greater than zero."); + } + } + config; + sessionCache = new Map(); + lease(requestContext, connectionConfiguration) { + const url = this.getUrlString(requestContext); + const existingPool = this.sessionCache.get(url); + if (existingPool) { + const existingSession = existingPool.poll(); + if (existingSession && !this.config.disableConcurrency) { + return existingSession; + } + } + const session = http2.connect(url); + if (this.config.maxConcurrency) { + session.settings({ maxConcurrentStreams: this.config.maxConcurrency }, (err) => { + if (err) { + throw new Error("Fail to set maxConcurrentStreams to " + + this.config.maxConcurrency + + "when creating new session for " + + requestContext.destination.toString()); + } + }); + } + session.unref(); + const destroySessionCb = () => { + session.destroy(); + this.deleteSession(url, session); + }; + session.on("goaway", destroySessionCb); + session.on("error", destroySessionCb); + session.on("frameError", destroySessionCb); + session.on("close", () => this.deleteSession(url, session)); + if (connectionConfiguration.requestTimeout) { + session.setTimeout(connectionConfiguration.requestTimeout, destroySessionCb); + } + const connectionPool = this.sessionCache.get(url) || new NodeHttp2ConnectionPool(); + connectionPool.offerLast(session); + this.sessionCache.set(url, connectionPool); + return session; + } + deleteSession(authority, session) { + const existingConnectionPool = this.sessionCache.get(authority); + if (!existingConnectionPool) { + return; + } + if (!existingConnectionPool.contains(session)) { + return; + } + existingConnectionPool.remove(session); + this.sessionCache.set(authority, existingConnectionPool); + } + release(requestContext, session) { + const cacheKey = this.getUrlString(requestContext); + this.sessionCache.get(cacheKey)?.offerLast(session); + } + destroy() { + for (const [key, connectionPool] of this.sessionCache) { + for (const session of connectionPool) { + if (!session.destroyed) { + session.destroy(); + } + connectionPool.remove(session); + } + this.sessionCache.delete(key); + } + } + setMaxConcurrentStreams(maxConcurrentStreams) { + if (maxConcurrentStreams && maxConcurrentStreams <= 0) { + throw new RangeError("maxConcurrentStreams must be greater than zero."); + } + this.config.maxConcurrency = maxConcurrentStreams; + } + setDisableConcurrentStreams(disableConcurrentStreams) { + this.config.disableConcurrency = disableConcurrentStreams; + } + getUrlString(request) { + return request.destination.toString(); + } +} -module.exports = AWS.KinesisVideoSignalingChannels; +class NodeHttp2Handler { + config; + configProvider; + metadata = { handlerProtocol: "h2" }; + connectionManager = new NodeHttp2ConnectionManager({}); + static create(instanceOrOptions) { + if (typeof instanceOrOptions?.handle === "function") { + return instanceOrOptions; + } + return new NodeHttp2Handler(instanceOrOptions); + } + constructor(options) { + this.configProvider = new Promise((resolve, reject) => { + if (typeof options === "function") { + options() + .then((opts) => { + resolve(opts || {}); + }) + .catch(reject); + } + else { + resolve(options || {}); + } + }); + } + destroy() { + this.connectionManager.destroy(); + } + async handle(request, { abortSignal, requestTimeout } = {}) { + if (!this.config) { + this.config = await this.configProvider; + this.connectionManager.setDisableConcurrentStreams(this.config.disableConcurrentStreams || false); + if (this.config.maxConcurrentStreams) { + this.connectionManager.setMaxConcurrentStreams(this.config.maxConcurrentStreams); + } + } + const { requestTimeout: configRequestTimeout, disableConcurrentStreams } = this.config; + const effectiveRequestTimeout = requestTimeout ?? configRequestTimeout; + return new Promise((_resolve, _reject) => { + let fulfilled = false; + let writeRequestBodyPromise = undefined; + const resolve = async (arg) => { + await writeRequestBodyPromise; + _resolve(arg); + }; + const reject = async (arg) => { + await writeRequestBodyPromise; + _reject(arg); + }; + if (abortSignal?.aborted) { + fulfilled = true; + const abortError = new Error("Request aborted"); + abortError.name = "AbortError"; + reject(abortError); + return; + } + const { hostname, method, port, protocol, query } = request; + let auth = ""; + if (request.username != null || request.password != null) { + const username = request.username ?? ""; + const password = request.password ?? ""; + auth = `${username}:${password}@`; + } + const authority = `${protocol}//${auth}${hostname}${port ? `:${port}` : ""}`; + const requestContext = { destination: new URL(authority) }; + const session = this.connectionManager.lease(requestContext, { + requestTimeout: this.config?.sessionTimeout, + disableConcurrentStreams: disableConcurrentStreams || false, + }); + const rejectWithDestroy = (err) => { + if (disableConcurrentStreams) { + this.destroySession(session); + } + fulfilled = true; + reject(err); + }; + const queryString = querystringBuilder.buildQueryString(query || {}); + let path = request.path; + if (queryString) { + path += `?${queryString}`; + } + if (request.fragment) { + path += `#${request.fragment}`; + } + const req = session.request({ + ...request.headers, + [http2.constants.HTTP2_HEADER_PATH]: path, + [http2.constants.HTTP2_HEADER_METHOD]: method, + }); + session.ref(); + req.on("response", (headers) => { + const httpResponse = new protocolHttp.HttpResponse({ + statusCode: headers[":status"] || -1, + headers: getTransformedHeaders(headers), + body: req, + }); + fulfilled = true; + resolve({ response: httpResponse }); + if (disableConcurrentStreams) { + session.close(); + this.connectionManager.deleteSession(authority, session); + } + }); + if (effectiveRequestTimeout) { + req.setTimeout(effectiveRequestTimeout, () => { + req.close(); + const timeoutError = new Error(`Stream timed out because of no activity for ${effectiveRequestTimeout} ms`); + timeoutError.name = "TimeoutError"; + rejectWithDestroy(timeoutError); + }); + } + if (abortSignal) { + const onAbort = () => { + req.close(); + const abortError = new Error("Request aborted"); + abortError.name = "AbortError"; + rejectWithDestroy(abortError); + }; + if (typeof abortSignal.addEventListener === "function") { + const signal = abortSignal; + signal.addEventListener("abort", onAbort, { once: true }); + req.once("close", () => signal.removeEventListener("abort", onAbort)); + } + else { + abortSignal.onabort = onAbort; + } + } + req.on("frameError", (type, code, id) => { + rejectWithDestroy(new Error(`Frame type id ${type} in stream id ${id} has failed with code ${code}.`)); + }); + req.on("error", rejectWithDestroy); + req.on("aborted", () => { + rejectWithDestroy(new Error(`HTTP/2 stream is abnormally aborted in mid-communication with result code ${req.rstCode}.`)); + }); + req.on("close", () => { + session.unref(); + if (disableConcurrentStreams) { + session.destroy(); + } + if (!fulfilled) { + rejectWithDestroy(new Error("Unexpected error: http2 request did not get a response")); + } + }); + writeRequestBodyPromise = writeRequestBody(req, request, effectiveRequestTimeout); + }); + } + updateHttpClientConfig(key, value) { + this.config = undefined; + this.configProvider = this.configProvider.then((config) => { + return { + ...config, + [key]: value, + }; + }); + } + httpHandlerConfigs() { + return this.config ?? {}; + } + destroySession(session) { + if (!session.destroyed) { + session.destroy(); + } + } +} +class Collector extends stream.Writable { + bufferedBytes = []; + _write(chunk, encoding, callback) { + this.bufferedBytes.push(chunk); + callback(); + } +} -/***/ }), +const streamCollector = (stream) => { + if (isReadableStreamInstance(stream)) { + return collectReadableStream(stream); + } + return new Promise((resolve, reject) => { + const collector = new Collector(); + stream.pipe(collector); + stream.on("error", (err) => { + collector.end(); + reject(err); + }); + collector.on("error", reject); + collector.on("finish", function () { + const bytes = new Uint8Array(Buffer.concat(this.bufferedBytes)); + resolve(bytes); + }); + }); +}; +const isReadableStreamInstance = (stream) => typeof ReadableStream === "function" && stream instanceof ReadableStream; +async function collectReadableStream(stream) { + const chunks = []; + const reader = stream.getReader(); + let isDone = false; + let length = 0; + while (!isDone) { + const { done, value } = await reader.read(); + if (value) { + chunks.push(value); + length += value.length; + } + isDone = done; + } + const collected = new Uint8Array(length); + let offset = 0; + for (const chunk of chunks) { + collected.set(chunk, offset); + offset += chunk.length; + } + return collected; +} -/***/ 2655: -/***/ (function(module) { +exports.DEFAULT_REQUEST_TIMEOUT = DEFAULT_REQUEST_TIMEOUT; +exports.NodeHttp2Handler = NodeHttp2Handler; +exports.NodeHttpHandler = NodeHttpHandler; +exports.streamCollector = streamCollector; -module.exports = {"version":"2.0","metadata":{"apiVersion":"2018-05-22","endpointPrefix":"personalize","jsonVersion":"1.1","protocol":"json","serviceFullName":"Amazon Personalize","serviceId":"Personalize","signatureVersion":"v4","signingName":"personalize","targetPrefix":"AmazonPersonalize","uid":"personalize-2018-05-22"},"operations":{"CreateBatchInferenceJob":{"input":{"type":"structure","required":["jobName","solutionVersionArn","jobInput","jobOutput","roleArn"],"members":{"jobName":{},"solutionVersionArn":{},"filterArn":{},"numResults":{"type":"integer"},"jobInput":{"shape":"S5"},"jobOutput":{"shape":"S9"},"roleArn":{}}},"output":{"type":"structure","members":{"batchInferenceJobArn":{}}}},"CreateCampaign":{"input":{"type":"structure","required":["name","solutionVersionArn","minProvisionedTPS"],"members":{"name":{},"solutionVersionArn":{},"minProvisionedTPS":{"type":"integer"}}},"output":{"type":"structure","members":{"campaignArn":{}}},"idempotent":true},"CreateDataset":{"input":{"type":"structure","required":["name","schemaArn","datasetGroupArn","datasetType"],"members":{"name":{},"schemaArn":{},"datasetGroupArn":{},"datasetType":{}}},"output":{"type":"structure","members":{"datasetArn":{}}},"idempotent":true},"CreateDatasetGroup":{"input":{"type":"structure","required":["name"],"members":{"name":{},"roleArn":{},"kmsKeyArn":{}}},"output":{"type":"structure","members":{"datasetGroupArn":{}}}},"CreateDatasetImportJob":{"input":{"type":"structure","required":["jobName","datasetArn","dataSource","roleArn"],"members":{"jobName":{},"datasetArn":{},"dataSource":{"shape":"Sl"},"roleArn":{}}},"output":{"type":"structure","members":{"datasetImportJobArn":{}}}},"CreateEventTracker":{"input":{"type":"structure","required":["name","datasetGroupArn"],"members":{"name":{},"datasetGroupArn":{}}},"output":{"type":"structure","members":{"eventTrackerArn":{},"trackingId":{}}},"idempotent":true},"CreateFilter":{"input":{"type":"structure","required":["name","datasetGroupArn","filterExpression"],"members":{"name":{},"datasetGroupArn":{},"filterExpression":{"shape":"Sr"}}},"output":{"type":"structure","members":{"filterArn":{}}}},"CreateSchema":{"input":{"type":"structure","required":["name","schema"],"members":{"name":{},"schema":{}}},"output":{"type":"structure","members":{"schemaArn":{}}},"idempotent":true},"CreateSolution":{"input":{"type":"structure","required":["name","datasetGroupArn"],"members":{"name":{},"performHPO":{"type":"boolean"},"performAutoML":{"type":"boolean"},"recipeArn":{},"datasetGroupArn":{},"eventType":{},"solutionConfig":{"shape":"S10"}}},"output":{"type":"structure","members":{"solutionArn":{}}}},"CreateSolutionVersion":{"input":{"type":"structure","required":["solutionArn"],"members":{"solutionArn":{},"trainingMode":{}}},"output":{"type":"structure","members":{"solutionVersionArn":{}}}},"DeleteCampaign":{"input":{"type":"structure","required":["campaignArn"],"members":{"campaignArn":{}}},"idempotent":true},"DeleteDataset":{"input":{"type":"structure","required":["datasetArn"],"members":{"datasetArn":{}}},"idempotent":true},"DeleteDatasetGroup":{"input":{"type":"structure","required":["datasetGroupArn"],"members":{"datasetGroupArn":{}}},"idempotent":true},"DeleteEventTracker":{"input":{"type":"structure","required":["eventTrackerArn"],"members":{"eventTrackerArn":{}}},"idempotent":true},"DeleteFilter":{"input":{"type":"structure","required":["filterArn"],"members":{"filterArn":{}}}},"DeleteSchema":{"input":{"type":"structure","required":["schemaArn"],"members":{"schemaArn":{}}},"idempotent":true},"DeleteSolution":{"input":{"type":"structure","required":["solutionArn"],"members":{"solutionArn":{}}},"idempotent":true},"DescribeAlgorithm":{"input":{"type":"structure","required":["algorithmArn"],"members":{"algorithmArn":{}}},"output":{"type":"structure","members":{"algorithm":{"type":"structure","members":{"name":{},"algorithmArn":{},"algorithmImage":{"type":"structure","required":["dockerURI"],"members":{"name":{},"dockerURI":{}}},"defaultHyperParameters":{"shape":"S1n"},"defaultHyperParameterRanges":{"type":"structure","members":{"integerHyperParameterRanges":{"type":"list","member":{"type":"structure","members":{"name":{},"minValue":{"type":"integer"},"maxValue":{"type":"integer"},"isTunable":{"type":"boolean"}}}},"continuousHyperParameterRanges":{"type":"list","member":{"type":"structure","members":{"name":{},"minValue":{"type":"double"},"maxValue":{"type":"double"},"isTunable":{"type":"boolean"}}}},"categoricalHyperParameterRanges":{"type":"list","member":{"type":"structure","members":{"name":{},"values":{"shape":"S1l"},"isTunable":{"type":"boolean"}}}}}},"defaultResourceConfig":{"type":"map","key":{},"value":{}},"trainingInputMode":{},"roleArn":{},"creationDateTime":{"type":"timestamp"},"lastUpdatedDateTime":{"type":"timestamp"}}}}},"idempotent":true},"DescribeBatchInferenceJob":{"input":{"type":"structure","required":["batchInferenceJobArn"],"members":{"batchInferenceJobArn":{}}},"output":{"type":"structure","members":{"batchInferenceJob":{"type":"structure","members":{"jobName":{},"batchInferenceJobArn":{},"filterArn":{},"failureReason":{},"solutionVersionArn":{},"numResults":{"type":"integer"},"jobInput":{"shape":"S5"},"jobOutput":{"shape":"S9"},"roleArn":{},"status":{},"creationDateTime":{"type":"timestamp"},"lastUpdatedDateTime":{"type":"timestamp"}}}}},"idempotent":true},"DescribeCampaign":{"input":{"type":"structure","required":["campaignArn"],"members":{"campaignArn":{}}},"output":{"type":"structure","members":{"campaign":{"type":"structure","members":{"name":{},"campaignArn":{},"solutionVersionArn":{},"minProvisionedTPS":{"type":"integer"},"status":{},"failureReason":{},"creationDateTime":{"type":"timestamp"},"lastUpdatedDateTime":{"type":"timestamp"},"latestCampaignUpdate":{"type":"structure","members":{"solutionVersionArn":{},"minProvisionedTPS":{"type":"integer"},"status":{},"failureReason":{},"creationDateTime":{"type":"timestamp"},"lastUpdatedDateTime":{"type":"timestamp"}}}}}}},"idempotent":true},"DescribeDataset":{"input":{"type":"structure","required":["datasetArn"],"members":{"datasetArn":{}}},"output":{"type":"structure","members":{"dataset":{"type":"structure","members":{"name":{},"datasetArn":{},"datasetGroupArn":{},"datasetType":{},"schemaArn":{},"status":{},"creationDateTime":{"type":"timestamp"},"lastUpdatedDateTime":{"type":"timestamp"}}}}},"idempotent":true},"DescribeDatasetGroup":{"input":{"type":"structure","required":["datasetGroupArn"],"members":{"datasetGroupArn":{}}},"output":{"type":"structure","members":{"datasetGroup":{"type":"structure","members":{"name":{},"datasetGroupArn":{},"status":{},"roleArn":{},"kmsKeyArn":{},"creationDateTime":{"type":"timestamp"},"lastUpdatedDateTime":{"type":"timestamp"},"failureReason":{}}}}},"idempotent":true},"DescribeDatasetImportJob":{"input":{"type":"structure","required":["datasetImportJobArn"],"members":{"datasetImportJobArn":{}}},"output":{"type":"structure","members":{"datasetImportJob":{"type":"structure","members":{"jobName":{},"datasetImportJobArn":{},"datasetArn":{},"dataSource":{"shape":"Sl"},"roleArn":{},"status":{},"creationDateTime":{"type":"timestamp"},"lastUpdatedDateTime":{"type":"timestamp"},"failureReason":{}}}}},"idempotent":true},"DescribeEventTracker":{"input":{"type":"structure","required":["eventTrackerArn"],"members":{"eventTrackerArn":{}}},"output":{"type":"structure","members":{"eventTracker":{"type":"structure","members":{"name":{},"eventTrackerArn":{},"accountId":{},"trackingId":{},"datasetGroupArn":{},"status":{},"creationDateTime":{"type":"timestamp"},"lastUpdatedDateTime":{"type":"timestamp"}}}}},"idempotent":true},"DescribeFeatureTransformation":{"input":{"type":"structure","required":["featureTransformationArn"],"members":{"featureTransformationArn":{}}},"output":{"type":"structure","members":{"featureTransformation":{"type":"structure","members":{"name":{},"featureTransformationArn":{},"defaultParameters":{"type":"map","key":{},"value":{}},"creationDateTime":{"type":"timestamp"},"lastUpdatedDateTime":{"type":"timestamp"},"status":{}}}}},"idempotent":true},"DescribeFilter":{"input":{"type":"structure","required":["filterArn"],"members":{"filterArn":{}}},"output":{"type":"structure","members":{"filter":{"type":"structure","members":{"name":{},"filterArn":{},"creationDateTime":{"type":"timestamp"},"lastUpdatedDateTime":{"type":"timestamp"},"datasetGroupArn":{},"failureReason":{},"filterExpression":{"shape":"Sr"},"status":{}}}}},"idempotent":true},"DescribeRecipe":{"input":{"type":"structure","required":["recipeArn"],"members":{"recipeArn":{}}},"output":{"type":"structure","members":{"recipe":{"type":"structure","members":{"name":{},"recipeArn":{},"algorithmArn":{},"featureTransformationArn":{},"status":{},"description":{},"creationDateTime":{"type":"timestamp"},"recipeType":{},"lastUpdatedDateTime":{"type":"timestamp"}}}}},"idempotent":true},"DescribeSchema":{"input":{"type":"structure","required":["schemaArn"],"members":{"schemaArn":{}}},"output":{"type":"structure","members":{"schema":{"type":"structure","members":{"name":{},"schemaArn":{},"schema":{},"creationDateTime":{"type":"timestamp"},"lastUpdatedDateTime":{"type":"timestamp"}}}}},"idempotent":true},"DescribeSolution":{"input":{"type":"structure","required":["solutionArn"],"members":{"solutionArn":{}}},"output":{"type":"structure","members":{"solution":{"type":"structure","members":{"name":{},"solutionArn":{},"performHPO":{"type":"boolean"},"performAutoML":{"type":"boolean"},"recipeArn":{},"datasetGroupArn":{},"eventType":{},"solutionConfig":{"shape":"S10"},"autoMLResult":{"type":"structure","members":{"bestRecipeArn":{}}},"status":{},"creationDateTime":{"type":"timestamp"},"lastUpdatedDateTime":{"type":"timestamp"},"latestSolutionVersion":{"shape":"S3p"}}}}},"idempotent":true},"DescribeSolutionVersion":{"input":{"type":"structure","required":["solutionVersionArn"],"members":{"solutionVersionArn":{}}},"output":{"type":"structure","members":{"solutionVersion":{"type":"structure","members":{"solutionVersionArn":{},"solutionArn":{},"performHPO":{"type":"boolean"},"performAutoML":{"type":"boolean"},"recipeArn":{},"eventType":{},"datasetGroupArn":{},"solutionConfig":{"shape":"S10"},"trainingHours":{"type":"double"},"trainingMode":{},"tunedHPOParams":{"type":"structure","members":{"algorithmHyperParameters":{"shape":"S1n"}}},"status":{},"failureReason":{},"creationDateTime":{"type":"timestamp"},"lastUpdatedDateTime":{"type":"timestamp"}}}}},"idempotent":true},"GetSolutionMetrics":{"input":{"type":"structure","required":["solutionVersionArn"],"members":{"solutionVersionArn":{}}},"output":{"type":"structure","members":{"solutionVersionArn":{},"metrics":{"type":"map","key":{},"value":{"type":"double"}}}}},"ListBatchInferenceJobs":{"input":{"type":"structure","members":{"solutionVersionArn":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"batchInferenceJobs":{"type":"list","member":{"type":"structure","members":{"batchInferenceJobArn":{},"jobName":{},"status":{},"creationDateTime":{"type":"timestamp"},"lastUpdatedDateTime":{"type":"timestamp"},"failureReason":{},"solutionVersionArn":{}}}},"nextToken":{}}},"idempotent":true},"ListCampaigns":{"input":{"type":"structure","members":{"solutionArn":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"campaigns":{"type":"list","member":{"type":"structure","members":{"name":{},"campaignArn":{},"status":{},"creationDateTime":{"type":"timestamp"},"lastUpdatedDateTime":{"type":"timestamp"},"failureReason":{}}}},"nextToken":{}}},"idempotent":true},"ListDatasetGroups":{"input":{"type":"structure","members":{"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"datasetGroups":{"type":"list","member":{"type":"structure","members":{"name":{},"datasetGroupArn":{},"status":{},"creationDateTime":{"type":"timestamp"},"lastUpdatedDateTime":{"type":"timestamp"},"failureReason":{}}}},"nextToken":{}}},"idempotent":true},"ListDatasetImportJobs":{"input":{"type":"structure","members":{"datasetArn":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"datasetImportJobs":{"type":"list","member":{"type":"structure","members":{"datasetImportJobArn":{},"jobName":{},"status":{},"creationDateTime":{"type":"timestamp"},"lastUpdatedDateTime":{"type":"timestamp"},"failureReason":{}}}},"nextToken":{}}},"idempotent":true},"ListDatasets":{"input":{"type":"structure","members":{"datasetGroupArn":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"datasets":{"type":"list","member":{"type":"structure","members":{"name":{},"datasetArn":{},"datasetType":{},"status":{},"creationDateTime":{"type":"timestamp"},"lastUpdatedDateTime":{"type":"timestamp"}}}},"nextToken":{}}},"idempotent":true},"ListEventTrackers":{"input":{"type":"structure","members":{"datasetGroupArn":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"eventTrackers":{"type":"list","member":{"type":"structure","members":{"name":{},"eventTrackerArn":{},"status":{},"creationDateTime":{"type":"timestamp"},"lastUpdatedDateTime":{"type":"timestamp"}}}},"nextToken":{}}},"idempotent":true},"ListFilters":{"input":{"type":"structure","members":{"datasetGroupArn":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"Filters":{"type":"list","member":{"type":"structure","members":{"name":{},"filterArn":{},"creationDateTime":{"type":"timestamp"},"lastUpdatedDateTime":{"type":"timestamp"},"datasetGroupArn":{},"failureReason":{},"status":{}}}},"nextToken":{}}},"idempotent":true},"ListRecipes":{"input":{"type":"structure","members":{"recipeProvider":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"recipes":{"type":"list","member":{"type":"structure","members":{"name":{},"recipeArn":{},"status":{},"creationDateTime":{"type":"timestamp"},"lastUpdatedDateTime":{"type":"timestamp"}}}},"nextToken":{}}},"idempotent":true},"ListSchemas":{"input":{"type":"structure","members":{"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"schemas":{"type":"list","member":{"type":"structure","members":{"name":{},"schemaArn":{},"creationDateTime":{"type":"timestamp"},"lastUpdatedDateTime":{"type":"timestamp"}}}},"nextToken":{}}},"idempotent":true},"ListSolutionVersions":{"input":{"type":"structure","members":{"solutionArn":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"solutionVersions":{"type":"list","member":{"shape":"S3p"}},"nextToken":{}}},"idempotent":true},"ListSolutions":{"input":{"type":"structure","members":{"datasetGroupArn":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"solutions":{"type":"list","member":{"type":"structure","members":{"name":{},"solutionArn":{},"status":{},"creationDateTime":{"type":"timestamp"},"lastUpdatedDateTime":{"type":"timestamp"}}}},"nextToken":{}}},"idempotent":true},"UpdateCampaign":{"input":{"type":"structure","required":["campaignArn"],"members":{"campaignArn":{},"solutionVersionArn":{},"minProvisionedTPS":{"type":"integer"}}},"output":{"type":"structure","members":{"campaignArn":{}}},"idempotent":true}},"shapes":{"S5":{"type":"structure","required":["s3DataSource"],"members":{"s3DataSource":{"shape":"S6"}}},"S6":{"type":"structure","required":["path"],"members":{"path":{},"kmsKeyArn":{}}},"S9":{"type":"structure","required":["s3DataDestination"],"members":{"s3DataDestination":{"shape":"S6"}}},"Sl":{"type":"structure","members":{"dataLocation":{}}},"Sr":{"type":"string","sensitive":true},"S10":{"type":"structure","members":{"eventValueThreshold":{},"hpoConfig":{"type":"structure","members":{"hpoObjective":{"type":"structure","members":{"type":{},"metricName":{},"metricRegex":{}}},"hpoResourceConfig":{"type":"structure","members":{"maxNumberOfTrainingJobs":{},"maxParallelTrainingJobs":{}}},"algorithmHyperParameterRanges":{"type":"structure","members":{"integerHyperParameterRanges":{"type":"list","member":{"type":"structure","members":{"name":{},"minValue":{"type":"integer"},"maxValue":{"type":"integer"}}}},"continuousHyperParameterRanges":{"type":"list","member":{"type":"structure","members":{"name":{},"minValue":{"type":"double"},"maxValue":{"type":"double"}}}},"categoricalHyperParameterRanges":{"type":"list","member":{"type":"structure","members":{"name":{},"values":{"shape":"S1l"}}}}}}}},"algorithmHyperParameters":{"shape":"S1n"},"featureTransformationParameters":{"type":"map","key":{},"value":{}},"autoMLConfig":{"type":"structure","members":{"metricName":{},"recipeList":{"type":"list","member":{}}}}}},"S1l":{"type":"list","member":{}},"S1n":{"type":"map","key":{},"value":{}},"S3p":{"type":"structure","members":{"solutionVersionArn":{},"status":{},"creationDateTime":{"type":"timestamp"},"lastUpdatedDateTime":{"type":"timestamp"},"failureReason":{}}}}}; /***/ }), -/***/ 2659: -/***/ (function(module) { +/***/ 146: +/***/ ((__unused_webpack_module, exports) => { -module.exports = {"version":"2.0","metadata":{"apiVersion":"2018-10-01","endpointPrefix":"appmesh","jsonVersion":"1.1","protocol":"rest-json","serviceFullName":"AWS App Mesh","serviceId":"App Mesh","signatureVersion":"v4","signingName":"appmesh","uid":"appmesh-2018-10-01"},"operations":{"CreateMesh":{"http":{"method":"PUT","requestUri":"/meshes","responseCode":200},"input":{"type":"structure","required":["meshName"],"members":{"clientToken":{"idempotencyToken":true},"meshName":{}}},"output":{"type":"structure","members":{"mesh":{"shape":"S5"}},"payload":"mesh"},"idempotent":true},"CreateRoute":{"http":{"method":"PUT","requestUri":"/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes","responseCode":200},"input":{"type":"structure","required":["meshName","routeName","spec","virtualRouterName"],"members":{"clientToken":{"idempotencyToken":true},"meshName":{"location":"uri","locationName":"meshName"},"routeName":{},"spec":{"shape":"Sd"},"virtualRouterName":{"location":"uri","locationName":"virtualRouterName"}}},"output":{"type":"structure","members":{"route":{"shape":"Sl"}},"payload":"route"},"idempotent":true},"CreateVirtualNode":{"http":{"method":"PUT","requestUri":"/meshes/{meshName}/virtualNodes","responseCode":200},"input":{"type":"structure","required":["meshName","spec","virtualNodeName"],"members":{"clientToken":{"idempotencyToken":true},"meshName":{"location":"uri","locationName":"meshName"},"spec":{"shape":"Sp"},"virtualNodeName":{}}},"output":{"type":"structure","members":{"virtualNode":{"shape":"S14"}},"payload":"virtualNode"},"idempotent":true},"CreateVirtualRouter":{"http":{"method":"PUT","requestUri":"/meshes/{meshName}/virtualRouters","responseCode":200},"input":{"type":"structure","required":["meshName","spec","virtualRouterName"],"members":{"clientToken":{"idempotencyToken":true},"meshName":{"location":"uri","locationName":"meshName"},"spec":{"shape":"S18"},"virtualRouterName":{}}},"output":{"type":"structure","members":{"virtualRouter":{"shape":"S1b"}},"payload":"virtualRouter"},"idempotent":true},"DeleteMesh":{"http":{"method":"DELETE","requestUri":"/meshes/{meshName}","responseCode":200},"input":{"type":"structure","required":["meshName"],"members":{"meshName":{"location":"uri","locationName":"meshName"}}},"output":{"type":"structure","members":{"mesh":{"shape":"S5"}},"payload":"mesh"},"idempotent":true},"DeleteRoute":{"http":{"method":"DELETE","requestUri":"/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes/{routeName}","responseCode":200},"input":{"type":"structure","required":["meshName","routeName","virtualRouterName"],"members":{"meshName":{"location":"uri","locationName":"meshName"},"routeName":{"location":"uri","locationName":"routeName"},"virtualRouterName":{"location":"uri","locationName":"virtualRouterName"}}},"output":{"type":"structure","members":{"route":{"shape":"Sl"}},"payload":"route"},"idempotent":true},"DeleteVirtualNode":{"http":{"method":"DELETE","requestUri":"/meshes/{meshName}/virtualNodes/{virtualNodeName}","responseCode":200},"input":{"type":"structure","required":["meshName","virtualNodeName"],"members":{"meshName":{"location":"uri","locationName":"meshName"},"virtualNodeName":{"location":"uri","locationName":"virtualNodeName"}}},"output":{"type":"structure","members":{"virtualNode":{"shape":"S14"}},"payload":"virtualNode"},"idempotent":true},"DeleteVirtualRouter":{"http":{"method":"DELETE","requestUri":"/meshes/{meshName}/virtualRouters/{virtualRouterName}","responseCode":200},"input":{"type":"structure","required":["meshName","virtualRouterName"],"members":{"meshName":{"location":"uri","locationName":"meshName"},"virtualRouterName":{"location":"uri","locationName":"virtualRouterName"}}},"output":{"type":"structure","members":{"virtualRouter":{"shape":"S1b"}},"payload":"virtualRouter"},"idempotent":true},"DescribeMesh":{"http":{"method":"GET","requestUri":"/meshes/{meshName}","responseCode":200},"input":{"type":"structure","required":["meshName"],"members":{"meshName":{"location":"uri","locationName":"meshName"}}},"output":{"type":"structure","members":{"mesh":{"shape":"S5"}},"payload":"mesh"}},"DescribeRoute":{"http":{"method":"GET","requestUri":"/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes/{routeName}","responseCode":200},"input":{"type":"structure","required":["meshName","routeName","virtualRouterName"],"members":{"meshName":{"location":"uri","locationName":"meshName"},"routeName":{"location":"uri","locationName":"routeName"},"virtualRouterName":{"location":"uri","locationName":"virtualRouterName"}}},"output":{"type":"structure","members":{"route":{"shape":"Sl"}},"payload":"route"}},"DescribeVirtualNode":{"http":{"method":"GET","requestUri":"/meshes/{meshName}/virtualNodes/{virtualNodeName}","responseCode":200},"input":{"type":"structure","required":["meshName","virtualNodeName"],"members":{"meshName":{"location":"uri","locationName":"meshName"},"virtualNodeName":{"location":"uri","locationName":"virtualNodeName"}}},"output":{"type":"structure","members":{"virtualNode":{"shape":"S14"}},"payload":"virtualNode"}},"DescribeVirtualRouter":{"http":{"method":"GET","requestUri":"/meshes/{meshName}/virtualRouters/{virtualRouterName}","responseCode":200},"input":{"type":"structure","required":["meshName","virtualRouterName"],"members":{"meshName":{"location":"uri","locationName":"meshName"},"virtualRouterName":{"location":"uri","locationName":"virtualRouterName"}}},"output":{"type":"structure","members":{"virtualRouter":{"shape":"S1b"}},"payload":"virtualRouter"}},"ListMeshes":{"http":{"method":"GET","requestUri":"/meshes","responseCode":200},"input":{"type":"structure","members":{"limit":{"location":"querystring","locationName":"limit","type":"integer"},"nextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","required":["meshes"],"members":{"meshes":{"type":"list","member":{"type":"structure","members":{"arn":{},"meshName":{}}}},"nextToken":{}}}},"ListRoutes":{"http":{"method":"GET","requestUri":"/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes","responseCode":200},"input":{"type":"structure","required":["meshName","virtualRouterName"],"members":{"limit":{"location":"querystring","locationName":"limit","type":"integer"},"meshName":{"location":"uri","locationName":"meshName"},"nextToken":{"location":"querystring","locationName":"nextToken"},"virtualRouterName":{"location":"uri","locationName":"virtualRouterName"}}},"output":{"type":"structure","required":["routes"],"members":{"nextToken":{},"routes":{"type":"list","member":{"type":"structure","members":{"arn":{},"meshName":{},"routeName":{},"virtualRouterName":{}}}}}}},"ListVirtualNodes":{"http":{"method":"GET","requestUri":"/meshes/{meshName}/virtualNodes","responseCode":200},"input":{"type":"structure","required":["meshName"],"members":{"limit":{"location":"querystring","locationName":"limit","type":"integer"},"meshName":{"location":"uri","locationName":"meshName"},"nextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","required":["virtualNodes"],"members":{"nextToken":{},"virtualNodes":{"type":"list","member":{"type":"structure","members":{"arn":{},"meshName":{},"virtualNodeName":{}}}}}}},"ListVirtualRouters":{"http":{"method":"GET","requestUri":"/meshes/{meshName}/virtualRouters","responseCode":200},"input":{"type":"structure","required":["meshName"],"members":{"limit":{"location":"querystring","locationName":"limit","type":"integer"},"meshName":{"location":"uri","locationName":"meshName"},"nextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","required":["virtualRouters"],"members":{"nextToken":{},"virtualRouters":{"type":"list","member":{"type":"structure","members":{"arn":{},"meshName":{},"virtualRouterName":{}}}}}}},"UpdateRoute":{"http":{"method":"PUT","requestUri":"/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes/{routeName}","responseCode":200},"input":{"type":"structure","required":["meshName","routeName","spec","virtualRouterName"],"members":{"clientToken":{"idempotencyToken":true},"meshName":{"location":"uri","locationName":"meshName"},"routeName":{"location":"uri","locationName":"routeName"},"spec":{"shape":"Sd"},"virtualRouterName":{"location":"uri","locationName":"virtualRouterName"}}},"output":{"type":"structure","members":{"route":{"shape":"Sl"}},"payload":"route"},"idempotent":true},"UpdateVirtualNode":{"http":{"method":"PUT","requestUri":"/meshes/{meshName}/virtualNodes/{virtualNodeName}","responseCode":200},"input":{"type":"structure","required":["meshName","spec","virtualNodeName"],"members":{"clientToken":{"idempotencyToken":true},"meshName":{"location":"uri","locationName":"meshName"},"spec":{"shape":"Sp"},"virtualNodeName":{"location":"uri","locationName":"virtualNodeName"}}},"output":{"type":"structure","members":{"virtualNode":{"shape":"S14"}},"payload":"virtualNode"},"idempotent":true},"UpdateVirtualRouter":{"http":{"method":"PUT","requestUri":"/meshes/{meshName}/virtualRouters/{virtualRouterName}","responseCode":200},"input":{"type":"structure","required":["meshName","spec","virtualRouterName"],"members":{"clientToken":{"idempotencyToken":true},"meshName":{"location":"uri","locationName":"meshName"},"spec":{"shape":"S18"},"virtualRouterName":{"location":"uri","locationName":"virtualRouterName"}}},"output":{"type":"structure","members":{"virtualRouter":{"shape":"S1b"}},"payload":"virtualRouter"},"idempotent":true}},"shapes":{"S5":{"type":"structure","required":["meshName","metadata"],"members":{"meshName":{},"metadata":{"shape":"S6"},"status":{"type":"structure","members":{"status":{}}}}},"S6":{"type":"structure","members":{"arn":{},"createdAt":{"type":"timestamp"},"lastUpdatedAt":{"type":"timestamp"},"uid":{},"version":{"type":"long"}}},"Sd":{"type":"structure","members":{"httpRoute":{"type":"structure","members":{"action":{"type":"structure","members":{"weightedTargets":{"type":"list","member":{"type":"structure","members":{"virtualNode":{},"weight":{"type":"integer"}}}}}},"match":{"type":"structure","members":{"prefix":{}}}}}}},"Sl":{"type":"structure","required":["meshName","routeName","virtualRouterName"],"members":{"meshName":{},"metadata":{"shape":"S6"},"routeName":{},"spec":{"shape":"Sd"},"status":{"type":"structure","members":{"status":{}}},"virtualRouterName":{}}},"Sp":{"type":"structure","members":{"backends":{"type":"list","member":{}},"listeners":{"type":"list","member":{"type":"structure","members":{"healthCheck":{"type":"structure","required":["healthyThreshold","intervalMillis","protocol","timeoutMillis","unhealthyThreshold"],"members":{"healthyThreshold":{"type":"integer"},"intervalMillis":{"type":"long"},"path":{},"port":{"type":"integer"},"protocol":{},"timeoutMillis":{"type":"long"},"unhealthyThreshold":{"type":"integer"}}},"portMapping":{"type":"structure","members":{"port":{"type":"integer"},"protocol":{}}}}}},"serviceDiscovery":{"type":"structure","members":{"dns":{"type":"structure","members":{"serviceName":{}}}}}}},"S14":{"type":"structure","required":["meshName","virtualNodeName"],"members":{"meshName":{},"metadata":{"shape":"S6"},"spec":{"shape":"Sp"},"status":{"type":"structure","members":{"status":{}}},"virtualNodeName":{}}},"S18":{"type":"structure","members":{"serviceNames":{"type":"list","member":{}}}},"S1b":{"type":"structure","required":["meshName","virtualRouterName"],"members":{"meshName":{},"metadata":{"shape":"S6"},"spec":{"shape":"S18"},"status":{"type":"structure","members":{"status":{}}},"virtualRouterName":{}}}}}; +"use strict"; -/***/ }), -/***/ 2662: -/***/ (function(module) { +const escapeUri = (uri) => encodeURIComponent(uri).replace(/[!'()*]/g, hexEncode); +const hexEncode = (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`; + +const escapeUriPath = (uri) => uri.split("/").map(escapeUri).join("/"); + +exports.escapeUri = escapeUri; +exports.escapeUriPath = escapeUriPath; -module.exports = {"version":"2.0","metadata":{"apiVersion":"2017-08-08","endpointPrefix":"connect","jsonVersion":"1.1","protocol":"rest-json","serviceAbbreviation":"Amazon Connect","serviceFullName":"Amazon Connect Service","serviceId":"Connect","signatureVersion":"v4","signingName":"connect","uid":"connect-2017-08-08"},"operations":{"CreateUser":{"http":{"method":"PUT","requestUri":"/users/{InstanceId}"},"input":{"type":"structure","required":["Username","PhoneConfig","SecurityProfileIds","RoutingProfileId","InstanceId"],"members":{"Username":{},"Password":{},"IdentityInfo":{"shape":"S4"},"PhoneConfig":{"shape":"S8"},"DirectoryUserId":{},"SecurityProfileIds":{"shape":"Se"},"RoutingProfileId":{},"HierarchyGroupId":{},"InstanceId":{"location":"uri","locationName":"InstanceId"},"Tags":{"shape":"Sj"}}},"output":{"type":"structure","members":{"UserId":{},"UserArn":{}}}},"DeleteUser":{"http":{"method":"DELETE","requestUri":"/users/{InstanceId}/{UserId}"},"input":{"type":"structure","required":["InstanceId","UserId"],"members":{"InstanceId":{"location":"uri","locationName":"InstanceId"},"UserId":{"location":"uri","locationName":"UserId"}}}},"DescribeUser":{"http":{"method":"GET","requestUri":"/users/{InstanceId}/{UserId}"},"input":{"type":"structure","required":["UserId","InstanceId"],"members":{"UserId":{"location":"uri","locationName":"UserId"},"InstanceId":{"location":"uri","locationName":"InstanceId"}}},"output":{"type":"structure","members":{"User":{"type":"structure","members":{"Id":{},"Arn":{},"Username":{},"IdentityInfo":{"shape":"S4"},"PhoneConfig":{"shape":"S8"},"DirectoryUserId":{},"SecurityProfileIds":{"shape":"Se"},"RoutingProfileId":{},"HierarchyGroupId":{},"Tags":{"shape":"Sj"}}}}}},"DescribeUserHierarchyGroup":{"http":{"method":"GET","requestUri":"/user-hierarchy-groups/{InstanceId}/{HierarchyGroupId}"},"input":{"type":"structure","required":["HierarchyGroupId","InstanceId"],"members":{"HierarchyGroupId":{"location":"uri","locationName":"HierarchyGroupId"},"InstanceId":{"location":"uri","locationName":"InstanceId"}}},"output":{"type":"structure","members":{"HierarchyGroup":{"type":"structure","members":{"Id":{},"Arn":{},"Name":{},"LevelId":{},"HierarchyPath":{"type":"structure","members":{"LevelOne":{"shape":"Sz"},"LevelTwo":{"shape":"Sz"},"LevelThree":{"shape":"Sz"},"LevelFour":{"shape":"Sz"},"LevelFive":{"shape":"Sz"}}}}}}}},"DescribeUserHierarchyStructure":{"http":{"method":"GET","requestUri":"/user-hierarchy-structure/{InstanceId}"},"input":{"type":"structure","required":["InstanceId"],"members":{"InstanceId":{"location":"uri","locationName":"InstanceId"}}},"output":{"type":"structure","members":{"HierarchyStructure":{"type":"structure","members":{"LevelOne":{"shape":"S13"},"LevelTwo":{"shape":"S13"},"LevelThree":{"shape":"S13"},"LevelFour":{"shape":"S13"},"LevelFive":{"shape":"S13"}}}}}},"GetContactAttributes":{"http":{"method":"GET","requestUri":"/contact/attributes/{InstanceId}/{InitialContactId}"},"input":{"type":"structure","required":["InstanceId","InitialContactId"],"members":{"InstanceId":{"location":"uri","locationName":"InstanceId"},"InitialContactId":{"location":"uri","locationName":"InitialContactId"}}},"output":{"type":"structure","members":{"Attributes":{"shape":"S18"}}}},"GetCurrentMetricData":{"http":{"requestUri":"/metrics/current/{InstanceId}"},"input":{"type":"structure","required":["InstanceId","Filters","CurrentMetrics"],"members":{"InstanceId":{"location":"uri","locationName":"InstanceId"},"Filters":{"shape":"S1c"},"Groupings":{"shape":"S1h"},"CurrentMetrics":{"type":"list","member":{"shape":"S1k"}},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"NextToken":{},"MetricResults":{"type":"list","member":{"type":"structure","members":{"Dimensions":{"shape":"S1s"},"Collections":{"type":"list","member":{"type":"structure","members":{"Metric":{"shape":"S1k"},"Value":{"type":"double"}}}}}}},"DataSnapshotTime":{"type":"timestamp"}}}},"GetFederationToken":{"http":{"method":"GET","requestUri":"/user/federate/{InstanceId}"},"input":{"type":"structure","required":["InstanceId"],"members":{"InstanceId":{"location":"uri","locationName":"InstanceId"}}},"output":{"type":"structure","members":{"Credentials":{"type":"structure","members":{"AccessToken":{"shape":"S21"},"AccessTokenExpiration":{"type":"timestamp"},"RefreshToken":{"shape":"S21"},"RefreshTokenExpiration":{"type":"timestamp"}}}}}},"GetMetricData":{"http":{"requestUri":"/metrics/historical/{InstanceId}"},"input":{"type":"structure","required":["InstanceId","StartTime","EndTime","Filters","HistoricalMetrics"],"members":{"InstanceId":{"location":"uri","locationName":"InstanceId"},"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"Filters":{"shape":"S1c"},"Groupings":{"shape":"S1h"},"HistoricalMetrics":{"type":"list","member":{"shape":"S24"}},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"NextToken":{},"MetricResults":{"type":"list","member":{"type":"structure","members":{"Dimensions":{"shape":"S1s"},"Collections":{"type":"list","member":{"type":"structure","members":{"Metric":{"shape":"S24"},"Value":{"type":"double"}}}}}}}}}},"ListContactFlows":{"http":{"method":"GET","requestUri":"/contact-flows-summary/{InstanceId}"},"input":{"type":"structure","required":["InstanceId"],"members":{"InstanceId":{"location":"uri","locationName":"InstanceId"},"ContactFlowTypes":{"location":"querystring","locationName":"contactFlowTypes","type":"list","member":{}},"NextToken":{"location":"querystring","locationName":"nextToken"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"ContactFlowSummaryList":{"type":"list","member":{"type":"structure","members":{"Id":{},"Arn":{},"Name":{},"ContactFlowType":{}}}},"NextToken":{}}}},"ListHoursOfOperations":{"http":{"method":"GET","requestUri":"/hours-of-operations-summary/{InstanceId}"},"input":{"type":"structure","required":["InstanceId"],"members":{"InstanceId":{"location":"uri","locationName":"InstanceId"},"NextToken":{"location":"querystring","locationName":"nextToken"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"HoursOfOperationSummaryList":{"type":"list","member":{"type":"structure","members":{"Id":{},"Arn":{},"Name":{}}}},"NextToken":{}}}},"ListPhoneNumbers":{"http":{"method":"GET","requestUri":"/phone-numbers-summary/{InstanceId}"},"input":{"type":"structure","required":["InstanceId"],"members":{"InstanceId":{"location":"uri","locationName":"InstanceId"},"PhoneNumberTypes":{"location":"querystring","locationName":"phoneNumberTypes","type":"list","member":{}},"PhoneNumberCountryCodes":{"location":"querystring","locationName":"phoneNumberCountryCodes","type":"list","member":{}},"NextToken":{"location":"querystring","locationName":"nextToken"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"PhoneNumberSummaryList":{"type":"list","member":{"type":"structure","members":{"Id":{},"Arn":{},"PhoneNumber":{},"PhoneNumberType":{},"PhoneNumberCountryCode":{}}}},"NextToken":{}}}},"ListQueues":{"http":{"method":"GET","requestUri":"/queues-summary/{InstanceId}"},"input":{"type":"structure","required":["InstanceId"],"members":{"InstanceId":{"location":"uri","locationName":"InstanceId"},"QueueTypes":{"location":"querystring","locationName":"queueTypes","type":"list","member":{}},"NextToken":{"location":"querystring","locationName":"nextToken"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"QueueSummaryList":{"type":"list","member":{"type":"structure","members":{"Id":{},"Arn":{},"Name":{},"QueueType":{}}}},"NextToken":{}}}},"ListRoutingProfiles":{"http":{"method":"GET","requestUri":"/routing-profiles-summary/{InstanceId}"},"input":{"type":"structure","required":["InstanceId"],"members":{"InstanceId":{"location":"uri","locationName":"InstanceId"},"NextToken":{"location":"querystring","locationName":"nextToken"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"RoutingProfileSummaryList":{"type":"list","member":{"type":"structure","members":{"Id":{},"Arn":{},"Name":{}}}},"NextToken":{}}}},"ListSecurityProfiles":{"http":{"method":"GET","requestUri":"/security-profiles-summary/{InstanceId}"},"input":{"type":"structure","required":["InstanceId"],"members":{"InstanceId":{"location":"uri","locationName":"InstanceId"},"NextToken":{"location":"querystring","locationName":"nextToken"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"SecurityProfileSummaryList":{"type":"list","member":{"type":"structure","members":{"Id":{},"Arn":{},"Name":{}}}},"NextToken":{}}}},"ListTagsForResource":{"http":{"method":"GET","requestUri":"/tags/{resourceArn}"},"input":{"type":"structure","required":["resourceArn"],"members":{"resourceArn":{"location":"uri","locationName":"resourceArn"}}},"output":{"type":"structure","members":{"tags":{"shape":"Sj"}}}},"ListUserHierarchyGroups":{"http":{"method":"GET","requestUri":"/user-hierarchy-groups-summary/{InstanceId}"},"input":{"type":"structure","required":["InstanceId"],"members":{"InstanceId":{"location":"uri","locationName":"InstanceId"},"NextToken":{"location":"querystring","locationName":"nextToken"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"UserHierarchyGroupSummaryList":{"type":"list","member":{"shape":"Sz"}},"NextToken":{}}}},"ListUsers":{"http":{"method":"GET","requestUri":"/users-summary/{InstanceId}"},"input":{"type":"structure","required":["InstanceId"],"members":{"InstanceId":{"location":"uri","locationName":"InstanceId"},"NextToken":{"location":"querystring","locationName":"nextToken"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"UserSummaryList":{"type":"list","member":{"type":"structure","members":{"Id":{},"Arn":{},"Username":{}}}},"NextToken":{}}}},"ResumeContactRecording":{"http":{"requestUri":"/contact/resume-recording"},"input":{"type":"structure","required":["InstanceId","ContactId","InitialContactId"],"members":{"InstanceId":{},"ContactId":{},"InitialContactId":{}}},"output":{"type":"structure","members":{}}},"StartChatContact":{"http":{"method":"PUT","requestUri":"/contact/chat"},"input":{"type":"structure","required":["InstanceId","ContactFlowId","ParticipantDetails"],"members":{"InstanceId":{},"ContactFlowId":{},"Attributes":{"shape":"S18"},"ParticipantDetails":{"type":"structure","required":["DisplayName"],"members":{"DisplayName":{}}},"InitialMessage":{"type":"structure","required":["ContentType","Content"],"members":{"ContentType":{},"Content":{}}},"ClientToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"ContactId":{},"ParticipantId":{},"ParticipantToken":{}}}},"StartContactRecording":{"http":{"requestUri":"/contact/start-recording"},"input":{"type":"structure","required":["InstanceId","ContactId","InitialContactId","VoiceRecordingConfiguration"],"members":{"InstanceId":{},"ContactId":{},"InitialContactId":{},"VoiceRecordingConfiguration":{"type":"structure","members":{"VoiceRecordingTrack":{}}}}},"output":{"type":"structure","members":{}}},"StartOutboundVoiceContact":{"http":{"method":"PUT","requestUri":"/contact/outbound-voice"},"input":{"type":"structure","required":["DestinationPhoneNumber","ContactFlowId","InstanceId"],"members":{"DestinationPhoneNumber":{},"ContactFlowId":{},"InstanceId":{},"ClientToken":{"idempotencyToken":true},"SourcePhoneNumber":{},"QueueId":{},"Attributes":{"shape":"S18"}}},"output":{"type":"structure","members":{"ContactId":{}}}},"StopContact":{"http":{"requestUri":"/contact/stop"},"input":{"type":"structure","required":["ContactId","InstanceId"],"members":{"ContactId":{},"InstanceId":{}}},"output":{"type":"structure","members":{}}},"StopContactRecording":{"http":{"requestUri":"/contact/stop-recording"},"input":{"type":"structure","required":["InstanceId","ContactId","InitialContactId"],"members":{"InstanceId":{},"ContactId":{},"InitialContactId":{}}},"output":{"type":"structure","members":{}}},"SuspendContactRecording":{"http":{"requestUri":"/contact/suspend-recording"},"input":{"type":"structure","required":["InstanceId","ContactId","InitialContactId"],"members":{"InstanceId":{},"ContactId":{},"InitialContactId":{}}},"output":{"type":"structure","members":{}}},"TagResource":{"http":{"requestUri":"/tags/{resourceArn}"},"input":{"type":"structure","required":["resourceArn","tags"],"members":{"resourceArn":{"location":"uri","locationName":"resourceArn"},"tags":{"shape":"Sj"}}}},"UntagResource":{"http":{"method":"DELETE","requestUri":"/tags/{resourceArn}"},"input":{"type":"structure","required":["resourceArn","tagKeys"],"members":{"resourceArn":{"location":"uri","locationName":"resourceArn"},"tagKeys":{"location":"querystring","locationName":"tagKeys","type":"list","member":{}}}}},"UpdateContactAttributes":{"http":{"requestUri":"/contact/attributes"},"input":{"type":"structure","required":["InitialContactId","InstanceId","Attributes"],"members":{"InitialContactId":{},"InstanceId":{},"Attributes":{"shape":"S18"}}},"output":{"type":"structure","members":{}}},"UpdateUserHierarchy":{"http":{"requestUri":"/users/{InstanceId}/{UserId}/hierarchy"},"input":{"type":"structure","required":["UserId","InstanceId"],"members":{"HierarchyGroupId":{},"UserId":{"location":"uri","locationName":"UserId"},"InstanceId":{"location":"uri","locationName":"InstanceId"}}}},"UpdateUserIdentityInfo":{"http":{"requestUri":"/users/{InstanceId}/{UserId}/identity-info"},"input":{"type":"structure","required":["IdentityInfo","UserId","InstanceId"],"members":{"IdentityInfo":{"shape":"S4"},"UserId":{"location":"uri","locationName":"UserId"},"InstanceId":{"location":"uri","locationName":"InstanceId"}}}},"UpdateUserPhoneConfig":{"http":{"requestUri":"/users/{InstanceId}/{UserId}/phone-config"},"input":{"type":"structure","required":["PhoneConfig","UserId","InstanceId"],"members":{"PhoneConfig":{"shape":"S8"},"UserId":{"location":"uri","locationName":"UserId"},"InstanceId":{"location":"uri","locationName":"InstanceId"}}}},"UpdateUserRoutingProfile":{"http":{"requestUri":"/users/{InstanceId}/{UserId}/routing-profile"},"input":{"type":"structure","required":["RoutingProfileId","UserId","InstanceId"],"members":{"RoutingProfileId":{},"UserId":{"location":"uri","locationName":"UserId"},"InstanceId":{"location":"uri","locationName":"InstanceId"}}}},"UpdateUserSecurityProfiles":{"http":{"requestUri":"/users/{InstanceId}/{UserId}/security-profiles"},"input":{"type":"structure","required":["SecurityProfileIds","UserId","InstanceId"],"members":{"SecurityProfileIds":{"shape":"Se"},"UserId":{"location":"uri","locationName":"UserId"},"InstanceId":{"location":"uri","locationName":"InstanceId"}}}}},"shapes":{"S4":{"type":"structure","members":{"FirstName":{},"LastName":{},"Email":{}}},"S8":{"type":"structure","required":["PhoneType"],"members":{"PhoneType":{},"AutoAccept":{"type":"boolean"},"AfterContactWorkTimeLimit":{"type":"integer"},"DeskPhoneNumber":{}}},"Se":{"type":"list","member":{}},"Sj":{"type":"map","key":{},"value":{}},"Sz":{"type":"structure","members":{"Id":{},"Arn":{},"Name":{}}},"S13":{"type":"structure","members":{"Id":{},"Arn":{},"Name":{}}},"S18":{"type":"map","key":{},"value":{}},"S1c":{"type":"structure","members":{"Queues":{"type":"list","member":{}},"Channels":{"type":"list","member":{}}}},"S1h":{"type":"list","member":{}},"S1k":{"type":"structure","members":{"Name":{},"Unit":{}}},"S1s":{"type":"structure","members":{"Queue":{"type":"structure","members":{"Id":{},"Arn":{}}},"Channel":{}}},"S21":{"type":"string","sensitive":true},"S24":{"type":"structure","members":{"Name":{},"Threshold":{"type":"structure","members":{"Comparison":{},"ThresholdValue":{"type":"double"}}},"Statistic":{},"Unit":{}}}}}; /***/ }), -/***/ 2667: -/***/ (function(module) { +/***/ 1577: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -module.exports = {"version":"2.0","metadata":{"apiVersion":"2012-06-01","endpointPrefix":"elasticloadbalancing","protocol":"query","serviceFullName":"Elastic Load Balancing","serviceId":"Elastic Load Balancing","signatureVersion":"v4","uid":"elasticloadbalancing-2012-06-01","xmlNamespace":"http://elasticloadbalancing.amazonaws.com/doc/2012-06-01/"},"operations":{"AddTags":{"input":{"type":"structure","required":["LoadBalancerNames","Tags"],"members":{"LoadBalancerNames":{"shape":"S2"},"Tags":{"shape":"S4"}}},"output":{"resultWrapper":"AddTagsResult","type":"structure","members":{}}},"ApplySecurityGroupsToLoadBalancer":{"input":{"type":"structure","required":["LoadBalancerName","SecurityGroups"],"members":{"LoadBalancerName":{},"SecurityGroups":{"shape":"Sa"}}},"output":{"resultWrapper":"ApplySecurityGroupsToLoadBalancerResult","type":"structure","members":{"SecurityGroups":{"shape":"Sa"}}}},"AttachLoadBalancerToSubnets":{"input":{"type":"structure","required":["LoadBalancerName","Subnets"],"members":{"LoadBalancerName":{},"Subnets":{"shape":"Se"}}},"output":{"resultWrapper":"AttachLoadBalancerToSubnetsResult","type":"structure","members":{"Subnets":{"shape":"Se"}}}},"ConfigureHealthCheck":{"input":{"type":"structure","required":["LoadBalancerName","HealthCheck"],"members":{"LoadBalancerName":{},"HealthCheck":{"shape":"Si"}}},"output":{"resultWrapper":"ConfigureHealthCheckResult","type":"structure","members":{"HealthCheck":{"shape":"Si"}}}},"CreateAppCookieStickinessPolicy":{"input":{"type":"structure","required":["LoadBalancerName","PolicyName","CookieName"],"members":{"LoadBalancerName":{},"PolicyName":{},"CookieName":{}}},"output":{"resultWrapper":"CreateAppCookieStickinessPolicyResult","type":"structure","members":{}}},"CreateLBCookieStickinessPolicy":{"input":{"type":"structure","required":["LoadBalancerName","PolicyName"],"members":{"LoadBalancerName":{},"PolicyName":{},"CookieExpirationPeriod":{"type":"long"}}},"output":{"resultWrapper":"CreateLBCookieStickinessPolicyResult","type":"structure","members":{}}},"CreateLoadBalancer":{"input":{"type":"structure","required":["LoadBalancerName","Listeners"],"members":{"LoadBalancerName":{},"Listeners":{"shape":"Sx"},"AvailabilityZones":{"shape":"S13"},"Subnets":{"shape":"Se"},"SecurityGroups":{"shape":"Sa"},"Scheme":{},"Tags":{"shape":"S4"}}},"output":{"resultWrapper":"CreateLoadBalancerResult","type":"structure","members":{"DNSName":{}}}},"CreateLoadBalancerListeners":{"input":{"type":"structure","required":["LoadBalancerName","Listeners"],"members":{"LoadBalancerName":{},"Listeners":{"shape":"Sx"}}},"output":{"resultWrapper":"CreateLoadBalancerListenersResult","type":"structure","members":{}}},"CreateLoadBalancerPolicy":{"input":{"type":"structure","required":["LoadBalancerName","PolicyName","PolicyTypeName"],"members":{"LoadBalancerName":{},"PolicyName":{},"PolicyTypeName":{},"PolicyAttributes":{"type":"list","member":{"type":"structure","members":{"AttributeName":{},"AttributeValue":{}}}}}},"output":{"resultWrapper":"CreateLoadBalancerPolicyResult","type":"structure","members":{}}},"DeleteLoadBalancer":{"input":{"type":"structure","required":["LoadBalancerName"],"members":{"LoadBalancerName":{}}},"output":{"resultWrapper":"DeleteLoadBalancerResult","type":"structure","members":{}}},"DeleteLoadBalancerListeners":{"input":{"type":"structure","required":["LoadBalancerName","LoadBalancerPorts"],"members":{"LoadBalancerName":{},"LoadBalancerPorts":{"type":"list","member":{"type":"integer"}}}},"output":{"resultWrapper":"DeleteLoadBalancerListenersResult","type":"structure","members":{}}},"DeleteLoadBalancerPolicy":{"input":{"type":"structure","required":["LoadBalancerName","PolicyName"],"members":{"LoadBalancerName":{},"PolicyName":{}}},"output":{"resultWrapper":"DeleteLoadBalancerPolicyResult","type":"structure","members":{}}},"DeregisterInstancesFromLoadBalancer":{"input":{"type":"structure","required":["LoadBalancerName","Instances"],"members":{"LoadBalancerName":{},"Instances":{"shape":"S1p"}}},"output":{"resultWrapper":"DeregisterInstancesFromLoadBalancerResult","type":"structure","members":{"Instances":{"shape":"S1p"}}}},"DescribeAccountLimits":{"input":{"type":"structure","members":{"Marker":{},"PageSize":{"type":"integer"}}},"output":{"resultWrapper":"DescribeAccountLimitsResult","type":"structure","members":{"Limits":{"type":"list","member":{"type":"structure","members":{"Name":{},"Max":{}}}},"NextMarker":{}}}},"DescribeInstanceHealth":{"input":{"type":"structure","required":["LoadBalancerName"],"members":{"LoadBalancerName":{},"Instances":{"shape":"S1p"}}},"output":{"resultWrapper":"DescribeInstanceHealthResult","type":"structure","members":{"InstanceStates":{"type":"list","member":{"type":"structure","members":{"InstanceId":{},"State":{},"ReasonCode":{},"Description":{}}}}}}},"DescribeLoadBalancerAttributes":{"input":{"type":"structure","required":["LoadBalancerName"],"members":{"LoadBalancerName":{}}},"output":{"resultWrapper":"DescribeLoadBalancerAttributesResult","type":"structure","members":{"LoadBalancerAttributes":{"shape":"S2a"}}}},"DescribeLoadBalancerPolicies":{"input":{"type":"structure","members":{"LoadBalancerName":{},"PolicyNames":{"shape":"S2s"}}},"output":{"resultWrapper":"DescribeLoadBalancerPoliciesResult","type":"structure","members":{"PolicyDescriptions":{"type":"list","member":{"type":"structure","members":{"PolicyName":{},"PolicyTypeName":{},"PolicyAttributeDescriptions":{"type":"list","member":{"type":"structure","members":{"AttributeName":{},"AttributeValue":{}}}}}}}}}},"DescribeLoadBalancerPolicyTypes":{"input":{"type":"structure","members":{"PolicyTypeNames":{"type":"list","member":{}}}},"output":{"resultWrapper":"DescribeLoadBalancerPolicyTypesResult","type":"structure","members":{"PolicyTypeDescriptions":{"type":"list","member":{"type":"structure","members":{"PolicyTypeName":{},"Description":{},"PolicyAttributeTypeDescriptions":{"type":"list","member":{"type":"structure","members":{"AttributeName":{},"AttributeType":{},"Description":{},"DefaultValue":{},"Cardinality":{}}}}}}}}}},"DescribeLoadBalancers":{"input":{"type":"structure","members":{"LoadBalancerNames":{"shape":"S2"},"Marker":{},"PageSize":{"type":"integer"}}},"output":{"resultWrapper":"DescribeLoadBalancersResult","type":"structure","members":{"LoadBalancerDescriptions":{"type":"list","member":{"type":"structure","members":{"LoadBalancerName":{},"DNSName":{},"CanonicalHostedZoneName":{},"CanonicalHostedZoneNameID":{},"ListenerDescriptions":{"type":"list","member":{"type":"structure","members":{"Listener":{"shape":"Sy"},"PolicyNames":{"shape":"S2s"}}}},"Policies":{"type":"structure","members":{"AppCookieStickinessPolicies":{"type":"list","member":{"type":"structure","members":{"PolicyName":{},"CookieName":{}}}},"LBCookieStickinessPolicies":{"type":"list","member":{"type":"structure","members":{"PolicyName":{},"CookieExpirationPeriod":{"type":"long"}}}},"OtherPolicies":{"shape":"S2s"}}},"BackendServerDescriptions":{"type":"list","member":{"type":"structure","members":{"InstancePort":{"type":"integer"},"PolicyNames":{"shape":"S2s"}}}},"AvailabilityZones":{"shape":"S13"},"Subnets":{"shape":"Se"},"VPCId":{},"Instances":{"shape":"S1p"},"HealthCheck":{"shape":"Si"},"SourceSecurityGroup":{"type":"structure","members":{"OwnerAlias":{},"GroupName":{}}},"SecurityGroups":{"shape":"Sa"},"CreatedTime":{"type":"timestamp"},"Scheme":{}}}},"NextMarker":{}}}},"DescribeTags":{"input":{"type":"structure","required":["LoadBalancerNames"],"members":{"LoadBalancerNames":{"type":"list","member":{}}}},"output":{"resultWrapper":"DescribeTagsResult","type":"structure","members":{"TagDescriptions":{"type":"list","member":{"type":"structure","members":{"LoadBalancerName":{},"Tags":{"shape":"S4"}}}}}}},"DetachLoadBalancerFromSubnets":{"input":{"type":"structure","required":["LoadBalancerName","Subnets"],"members":{"LoadBalancerName":{},"Subnets":{"shape":"Se"}}},"output":{"resultWrapper":"DetachLoadBalancerFromSubnetsResult","type":"structure","members":{"Subnets":{"shape":"Se"}}}},"DisableAvailabilityZonesForLoadBalancer":{"input":{"type":"structure","required":["LoadBalancerName","AvailabilityZones"],"members":{"LoadBalancerName":{},"AvailabilityZones":{"shape":"S13"}}},"output":{"resultWrapper":"DisableAvailabilityZonesForLoadBalancerResult","type":"structure","members":{"AvailabilityZones":{"shape":"S13"}}}},"EnableAvailabilityZonesForLoadBalancer":{"input":{"type":"structure","required":["LoadBalancerName","AvailabilityZones"],"members":{"LoadBalancerName":{},"AvailabilityZones":{"shape":"S13"}}},"output":{"resultWrapper":"EnableAvailabilityZonesForLoadBalancerResult","type":"structure","members":{"AvailabilityZones":{"shape":"S13"}}}},"ModifyLoadBalancerAttributes":{"input":{"type":"structure","required":["LoadBalancerName","LoadBalancerAttributes"],"members":{"LoadBalancerName":{},"LoadBalancerAttributes":{"shape":"S2a"}}},"output":{"resultWrapper":"ModifyLoadBalancerAttributesResult","type":"structure","members":{"LoadBalancerName":{},"LoadBalancerAttributes":{"shape":"S2a"}}}},"RegisterInstancesWithLoadBalancer":{"input":{"type":"structure","required":["LoadBalancerName","Instances"],"members":{"LoadBalancerName":{},"Instances":{"shape":"S1p"}}},"output":{"resultWrapper":"RegisterInstancesWithLoadBalancerResult","type":"structure","members":{"Instances":{"shape":"S1p"}}}},"RemoveTags":{"input":{"type":"structure","required":["LoadBalancerNames","Tags"],"members":{"LoadBalancerNames":{"shape":"S2"},"Tags":{"type":"list","member":{"type":"structure","members":{"Key":{}}}}}},"output":{"resultWrapper":"RemoveTagsResult","type":"structure","members":{}}},"SetLoadBalancerListenerSSLCertificate":{"input":{"type":"structure","required":["LoadBalancerName","LoadBalancerPort","SSLCertificateId"],"members":{"LoadBalancerName":{},"LoadBalancerPort":{"type":"integer"},"SSLCertificateId":{}}},"output":{"resultWrapper":"SetLoadBalancerListenerSSLCertificateResult","type":"structure","members":{}}},"SetLoadBalancerPoliciesForBackendServer":{"input":{"type":"structure","required":["LoadBalancerName","InstancePort","PolicyNames"],"members":{"LoadBalancerName":{},"InstancePort":{"type":"integer"},"PolicyNames":{"shape":"S2s"}}},"output":{"resultWrapper":"SetLoadBalancerPoliciesForBackendServerResult","type":"structure","members":{}}},"SetLoadBalancerPoliciesOfListener":{"input":{"type":"structure","required":["LoadBalancerName","LoadBalancerPort","PolicyNames"],"members":{"LoadBalancerName":{},"LoadBalancerPort":{"type":"integer"},"PolicyNames":{"shape":"S2s"}}},"output":{"resultWrapper":"SetLoadBalancerPoliciesOfListenerResult","type":"structure","members":{}}}},"shapes":{"S2":{"type":"list","member":{}},"S4":{"type":"list","member":{"type":"structure","required":["Key"],"members":{"Key":{},"Value":{}}}},"Sa":{"type":"list","member":{}},"Se":{"type":"list","member":{}},"Si":{"type":"structure","required":["Target","Interval","Timeout","UnhealthyThreshold","HealthyThreshold"],"members":{"Target":{},"Interval":{"type":"integer"},"Timeout":{"type":"integer"},"UnhealthyThreshold":{"type":"integer"},"HealthyThreshold":{"type":"integer"}}},"Sx":{"type":"list","member":{"shape":"Sy"}},"Sy":{"type":"structure","required":["Protocol","LoadBalancerPort","InstancePort"],"members":{"Protocol":{},"LoadBalancerPort":{"type":"integer"},"InstanceProtocol":{},"InstancePort":{"type":"integer"},"SSLCertificateId":{}}},"S13":{"type":"list","member":{}},"S1p":{"type":"list","member":{"type":"structure","members":{"InstanceId":{}}}},"S2a":{"type":"structure","members":{"CrossZoneLoadBalancing":{"type":"structure","required":["Enabled"],"members":{"Enabled":{"type":"boolean"}}},"AccessLog":{"type":"structure","required":["Enabled"],"members":{"Enabled":{"type":"boolean"},"S3BucketName":{},"EmitInterval":{"type":"integer"},"S3BucketPrefix":{}}},"ConnectionDraining":{"type":"structure","required":["Enabled"],"members":{"Enabled":{"type":"boolean"},"Timeout":{"type":"integer"}}},"ConnectionSettings":{"type":"structure","required":["IdleTimeout"],"members":{"IdleTimeout":{"type":"integer"}}},"AdditionalAttributes":{"type":"list","member":{"type":"structure","members":{"Key":{},"Value":{}}}}}},"S2s":{"type":"list","member":{}}}}; +"use strict"; -/***/ }), -/***/ 2673: -/***/ (function(module, __unusedexports, __webpack_require__) { +var utilBufferFrom = __nccwpck_require__(4151); -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +const fromUtf8 = (input) => { + const buf = utilBufferFrom.fromString(input, "utf8"); + return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength / Uint8Array.BYTES_PER_ELEMENT); +}; -apiLoader.services['servicecatalog'] = {}; -AWS.ServiceCatalog = Service.defineService('servicecatalog', ['2015-12-10']); -Object.defineProperty(apiLoader.services['servicecatalog'], '2015-12-10', { - get: function get() { - var model = __webpack_require__(4008); - model.paginators = __webpack_require__(1656).pagination; - return model; - }, - enumerable: true, - configurable: true -}); +const toUint8Array = (data) => { + if (typeof data === "string") { + return fromUtf8(data); + } + if (ArrayBuffer.isView(data)) { + return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT); + } + return new Uint8Array(data); +}; + +const toUtf8 = (input) => { + if (typeof input === "string") { + return input; + } + if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") { + throw new Error("@smithy/util-utf8: toUtf8 encoder function only accepts string | Uint8Array."); + } + return utilBufferFrom.fromArrayBuffer(input.buffer, input.byteOffset, input.byteLength).toString("utf8"); +}; -module.exports = AWS.ServiceCatalog; +exports.fromUtf8 = fromUtf8; +exports.toUint8Array = toUint8Array; +exports.toUtf8 = toUtf8; /***/ }), -/***/ 2678: -/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) { +/***/ 5290: +/***/ ((__unused_webpack_module, exports) => { -var AWS = __webpack_require__(395); +"use strict"; -AWS.util.hideProperties(AWS, ['SimpleWorkflow']); -/** - * @constant - * @readonly - * Backwards compatibility for access to the {AWS.SWF} service class. - */ -AWS.SimpleWorkflow = AWS.SWF; +const getCircularReplacer = () => { + const seen = new WeakSet(); + return (key, value) => { + if (typeof value === "object" && value !== null) { + if (seen.has(value)) { + return "[Circular]"; + } + seen.add(value); + } + return value; + }; +}; +const sleep = (seconds) => { + return new Promise((resolve) => setTimeout(resolve, seconds * 1000)); +}; -/***/ }), +const waiterServiceDefaults = { + minDelay: 2, + maxDelay: 120, +}; +exports.WaiterState = void 0; +(function (WaiterState) { + WaiterState["ABORTED"] = "ABORTED"; + WaiterState["FAILURE"] = "FAILURE"; + WaiterState["SUCCESS"] = "SUCCESS"; + WaiterState["RETRY"] = "RETRY"; + WaiterState["TIMEOUT"] = "TIMEOUT"; +})(exports.WaiterState || (exports.WaiterState = {})); +const checkExceptions = (result) => { + if (result.state === exports.WaiterState.ABORTED) { + const abortError = new Error(`${JSON.stringify({ + ...result, + reason: "Request was aborted", + }, getCircularReplacer())}`); + abortError.name = "AbortError"; + throw abortError; + } + else if (result.state === exports.WaiterState.TIMEOUT) { + const timeoutError = new Error(`${JSON.stringify({ + ...result, + reason: "Waiter has timed out", + }, getCircularReplacer())}`); + timeoutError.name = "TimeoutError"; + throw timeoutError; + } + else if (result.state !== exports.WaiterState.SUCCESS) { + throw new Error(`${JSON.stringify(result, getCircularReplacer())}`); + } + return result; +}; + +const exponentialBackoffWithJitter = (minDelay, maxDelay, attemptCeiling, attempt) => { + if (attempt > attemptCeiling) + return maxDelay; + const delay = minDelay * 2 ** (attempt - 1); + return randomInRange(minDelay, delay); +}; +const randomInRange = (min, max) => min + Math.random() * (max - min); +const runPolling = async ({ minDelay, maxDelay, maxWaitTime, abortController, client, abortSignal }, input, acceptorChecks) => { + const observedResponses = {}; + const { state, reason } = await acceptorChecks(client, input); + if (reason) { + const message = createMessageFromResponse(reason); + observedResponses[message] |= 0; + observedResponses[message] += 1; + } + if (state !== exports.WaiterState.RETRY) { + return { state, reason, observedResponses }; + } + let currentAttempt = 1; + const waitUntil = Date.now() + maxWaitTime * 1000; + const attemptCeiling = Math.log(maxDelay / minDelay) / Math.log(2) + 1; + while (true) { + if (abortController?.signal?.aborted || abortSignal?.aborted) { + const message = "AbortController signal aborted."; + observedResponses[message] |= 0; + observedResponses[message] += 1; + return { state: exports.WaiterState.ABORTED, observedResponses }; + } + const delay = exponentialBackoffWithJitter(minDelay, maxDelay, attemptCeiling, currentAttempt); + if (Date.now() + delay * 1000 > waitUntil) { + return { state: exports.WaiterState.TIMEOUT, observedResponses }; + } + await sleep(delay); + const { state, reason } = await acceptorChecks(client, input); + if (reason) { + const message = createMessageFromResponse(reason); + observedResponses[message] |= 0; + observedResponses[message] += 1; + } + if (state !== exports.WaiterState.RETRY) { + return { state, reason, observedResponses }; + } + currentAttempt += 1; + } +}; +const createMessageFromResponse = (reason) => { + if (reason?.$responseBodyText) { + return `Deserialization error for body: ${reason.$responseBodyText}`; + } + if (reason?.$metadata?.httpStatusCode) { + if (reason.$response || reason.message) { + return `${reason.$response.statusCode ?? reason.$metadata.httpStatusCode ?? "Unknown"}: ${reason.message}`; + } + return `${reason.$metadata.httpStatusCode}: OK`; + } + return String(reason?.message ?? JSON.stringify(reason, getCircularReplacer()) ?? "Unknown"); +}; + +const validateWaiterOptions = (options) => { + if (options.maxWaitTime <= 0) { + throw new Error(`WaiterConfiguration.maxWaitTime must be greater than 0`); + } + else if (options.minDelay <= 0) { + throw new Error(`WaiterConfiguration.minDelay must be greater than 0`); + } + else if (options.maxDelay <= 0) { + throw new Error(`WaiterConfiguration.maxDelay must be greater than 0`); + } + else if (options.maxWaitTime <= options.minDelay) { + throw new Error(`WaiterConfiguration.maxWaitTime [${options.maxWaitTime}] must be greater than WaiterConfiguration.minDelay [${options.minDelay}] for this waiter`); + } + else if (options.maxDelay < options.minDelay) { + throw new Error(`WaiterConfiguration.maxDelay [${options.maxDelay}] must be greater than WaiterConfiguration.minDelay [${options.minDelay}] for this waiter`); + } +}; + +const abortTimeout = (abortSignal) => { + let onAbort; + const promise = new Promise((resolve) => { + onAbort = () => resolve({ state: exports.WaiterState.ABORTED }); + if (typeof abortSignal.addEventListener === "function") { + abortSignal.addEventListener("abort", onAbort); + } + else { + abortSignal.onabort = onAbort; + } + }); + return { + clearListener() { + if (typeof abortSignal.removeEventListener === "function") { + abortSignal.removeEventListener("abort", onAbort); + } + }, + aborted: promise, + }; +}; +const createWaiter = async (options, input, acceptorChecks) => { + const params = { + ...waiterServiceDefaults, + ...options, + }; + validateWaiterOptions(params); + const exitConditions = [runPolling(params, input, acceptorChecks)]; + const finalize = []; + if (options.abortSignal) { + const { aborted, clearListener } = abortTimeout(options.abortSignal); + finalize.push(clearListener); + exitConditions.push(aborted); + } + if (options.abortController?.signal) { + const { aborted, clearListener } = abortTimeout(options.abortController.signal); + finalize.push(clearListener); + exitConditions.push(aborted); + } + return Promise.race(exitConditions).then((result) => { + for (const fn of finalize) { + fn(); + } + return result; + }); +}; -/***/ 2681: -/***/ (function(module) { +exports.checkExceptions = checkExceptions; +exports.createWaiter = createWaiter; +exports.waiterServiceDefaults = waiterServiceDefaults; -module.exports = {"pagination":{}}; /***/ }), -/***/ 2685: -/***/ (function(module, __unusedexports, __webpack_require__) { +/***/ 266: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { "use strict"; -/*eslint-disable no-use-before-define*/ +var randomUUID = __nccwpck_require__(8492); + +const decimalToHex = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0")); +const v4 = () => { + if (randomUUID.randomUUID) { + return randomUUID.randomUUID(); + } + const rnds = new Uint8Array(16); + crypto.getRandomValues(rnds); + rnds[6] = (rnds[6] & 0x0f) | 0x40; + rnds[8] = (rnds[8] & 0x3f) | 0x80; + return (decimalToHex[rnds[0]] + + decimalToHex[rnds[1]] + + decimalToHex[rnds[2]] + + decimalToHex[rnds[3]] + + "-" + + decimalToHex[rnds[4]] + + decimalToHex[rnds[5]] + + "-" + + decimalToHex[rnds[6]] + + decimalToHex[rnds[7]] + + "-" + + decimalToHex[rnds[8]] + + decimalToHex[rnds[9]] + + "-" + + decimalToHex[rnds[10]] + + decimalToHex[rnds[11]] + + decimalToHex[rnds[12]] + + decimalToHex[rnds[13]] + + decimalToHex[rnds[14]] + + decimalToHex[rnds[15]]); +}; -var common = __webpack_require__(2740); -var YAMLException = __webpack_require__(556); -var DEFAULT_FULL_SCHEMA = __webpack_require__(5910); -var DEFAULT_SAFE_SCHEMA = __webpack_require__(6830); +exports.v4 = v4; -var _toString = Object.prototype.toString; -var _hasOwnProperty = Object.prototype.hasOwnProperty; -var CHAR_TAB = 0x09; /* Tab */ -var CHAR_LINE_FEED = 0x0A; /* LF */ -var CHAR_CARRIAGE_RETURN = 0x0D; /* CR */ -var CHAR_SPACE = 0x20; /* Space */ -var CHAR_EXCLAMATION = 0x21; /* ! */ -var CHAR_DOUBLE_QUOTE = 0x22; /* " */ -var CHAR_SHARP = 0x23; /* # */ -var CHAR_PERCENT = 0x25; /* % */ -var CHAR_AMPERSAND = 0x26; /* & */ -var CHAR_SINGLE_QUOTE = 0x27; /* ' */ -var CHAR_ASTERISK = 0x2A; /* * */ -var CHAR_COMMA = 0x2C; /* , */ -var CHAR_MINUS = 0x2D; /* - */ -var CHAR_COLON = 0x3A; /* : */ -var CHAR_EQUALS = 0x3D; /* = */ -var CHAR_GREATER_THAN = 0x3E; /* > */ -var CHAR_QUESTION = 0x3F; /* ? */ -var CHAR_COMMERCIAL_AT = 0x40; /* @ */ -var CHAR_LEFT_SQUARE_BRACKET = 0x5B; /* [ */ -var CHAR_RIGHT_SQUARE_BRACKET = 0x5D; /* ] */ -var CHAR_GRAVE_ACCENT = 0x60; /* ` */ -var CHAR_LEFT_CURLY_BRACKET = 0x7B; /* { */ -var CHAR_VERTICAL_LINE = 0x7C; /* | */ -var CHAR_RIGHT_CURLY_BRACKET = 0x7D; /* } */ +/***/ }), -var ESCAPE_SEQUENCES = {}; +/***/ 8492: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -ESCAPE_SEQUENCES[0x00] = '\\0'; -ESCAPE_SEQUENCES[0x07] = '\\a'; -ESCAPE_SEQUENCES[0x08] = '\\b'; -ESCAPE_SEQUENCES[0x09] = '\\t'; -ESCAPE_SEQUENCES[0x0A] = '\\n'; -ESCAPE_SEQUENCES[0x0B] = '\\v'; -ESCAPE_SEQUENCES[0x0C] = '\\f'; -ESCAPE_SEQUENCES[0x0D] = '\\r'; -ESCAPE_SEQUENCES[0x1B] = '\\e'; -ESCAPE_SEQUENCES[0x22] = '\\"'; -ESCAPE_SEQUENCES[0x5C] = '\\\\'; -ESCAPE_SEQUENCES[0x85] = '\\N'; -ESCAPE_SEQUENCES[0xA0] = '\\_'; -ESCAPE_SEQUENCES[0x2028] = '\\L'; -ESCAPE_SEQUENCES[0x2029] = '\\P'; +"use strict"; -var DEPRECATED_BOOLEANS_SYNTAX = [ - 'y', 'Y', 'yes', 'Yes', 'YES', 'on', 'On', 'ON', - 'n', 'N', 'no', 'No', 'NO', 'off', 'Off', 'OFF' -]; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.randomUUID = void 0; +const tslib_1 = __nccwpck_require__(1860); +const crypto_1 = tslib_1.__importDefault(__nccwpck_require__(6982)); +exports.randomUUID = crypto_1.default.randomUUID.bind(crypto_1.default); -function compileStyleMap(schema, map) { - var result, keys, index, length, tag, style, type; - if (map === null) return {}; +/***/ }), - result = {}; - keys = Object.keys(map); +/***/ 5183: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - for (index = 0, length = keys.length; index < length; index += 1) { - tag = keys[index]; - style = String(map[tag]); +"use strict"; - if (tag.slice(0, 2) === '!!') { - tag = 'tag:yaml.org,2002:' + tag.slice(2); +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]; } }; } - type = schema.compiledTypeMap['fallback'][tag]; - - if (type && _hasOwnProperty.call(type.styleAliases, style)) { - style = type.styleAliases[style]; + 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 (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.req = exports.json = exports.toBuffer = void 0; +const http = __importStar(__nccwpck_require__(8611)); +const https = __importStar(__nccwpck_require__(5692)); +async function toBuffer(stream) { + let length = 0; + const chunks = []; + for await (const chunk of stream) { + length += chunk.length; + chunks.push(chunk); + } + return Buffer.concat(chunks, length); +} +exports.toBuffer = toBuffer; +// eslint-disable-next-line @typescript-eslint/no-explicit-any +async function json(stream) { + const buf = await toBuffer(stream); + const str = buf.toString('utf8'); + try { + return JSON.parse(str); + } + catch (_err) { + const err = _err; + err.message += ` (input: ${str})`; + throw err; } +} +exports.json = json; +function req(url, opts = {}) { + const href = typeof url === 'string' ? url : url.href; + const req = (href.startsWith('https:') ? https : http).request(url, opts); + const promise = new Promise((resolve, reject) => { + req + .once('response', resolve) + .once('error', reject) + .end(); + }); + req.then = promise.then.bind(promise); + return req; +} +exports.req = req; +//# sourceMappingURL=helpers.js.map - result[tag] = style; - } +/***/ }), - return result; +/***/ 8894: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"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 (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.Agent = void 0; +const net = __importStar(__nccwpck_require__(9278)); +const http = __importStar(__nccwpck_require__(8611)); +const https_1 = __nccwpck_require__(5692); +__exportStar(__nccwpck_require__(5183), exports); +const INTERNAL = Symbol('AgentBaseInternalState'); +class Agent extends http.Agent { + constructor(opts) { + super(opts); + this[INTERNAL] = {}; + } + /** + * Determine whether this is an `http` or `https` request. + */ + isSecureEndpoint(options) { + if (options) { + // First check the `secureEndpoint` property explicitly, since this + // means that a parent `Agent` is "passing through" to this instance. + // eslint-disable-next-line @typescript-eslint/no-explicit-any + if (typeof options.secureEndpoint === 'boolean') { + return options.secureEndpoint; + } + // If no explicit `secure` endpoint, check if `protocol` property is + // set. This will usually be the case since using a full string URL + // or `URL` instance should be the most common usage. + if (typeof options.protocol === 'string') { + return options.protocol === 'https:'; + } + } + // Finally, if no `protocol` property was set, then fall back to + // checking the stack trace of the current call stack, and try to + // detect the "https" module. + const { stack } = new Error(); + if (typeof stack !== 'string') + return false; + return stack + .split('\n') + .some((l) => l.indexOf('(https.js:') !== -1 || + l.indexOf('node:https:') !== -1); + } + // In order to support async signatures in `connect()` and Node's native + // connection pooling in `http.Agent`, the array of sockets for each origin + // has to be updated synchronously. This is so the length of the array is + // accurate when `addRequest()` is next called. We achieve this by creating a + // fake socket and adding it to `sockets[origin]` and incrementing + // `totalSocketCount`. + incrementSockets(name) { + // If `maxSockets` and `maxTotalSockets` are both Infinity then there is no + // need to create a fake socket because Node.js native connection pooling + // will never be invoked. + if (this.maxSockets === Infinity && this.maxTotalSockets === Infinity) { + return null; + } + // All instances of `sockets` are expected TypeScript errors. The + // alternative is to add it as a private property of this class but that + // will break TypeScript subclassing. + if (!this.sockets[name]) { + // @ts-expect-error `sockets` is readonly in `@types/node` + this.sockets[name] = []; + } + const fakeSocket = new net.Socket({ writable: false }); + this.sockets[name].push(fakeSocket); + // @ts-expect-error `totalSocketCount` isn't defined in `@types/node` + this.totalSocketCount++; + return fakeSocket; + } + decrementSockets(name, socket) { + if (!this.sockets[name] || socket === null) { + return; + } + const sockets = this.sockets[name]; + const index = sockets.indexOf(socket); + if (index !== -1) { + sockets.splice(index, 1); + // @ts-expect-error `totalSocketCount` isn't defined in `@types/node` + this.totalSocketCount--; + if (sockets.length === 0) { + // @ts-expect-error `sockets` is readonly in `@types/node` + delete this.sockets[name]; + } + } + } + // In order to properly update the socket pool, we need to call `getName()` on + // the core `https.Agent` if it is a secureEndpoint. + getName(options) { + const secureEndpoint = this.isSecureEndpoint(options); + if (secureEndpoint) { + // @ts-expect-error `getName()` isn't defined in `@types/node` + return https_1.Agent.prototype.getName.call(this, options); + } + // @ts-expect-error `getName()` isn't defined in `@types/node` + return super.getName(options); + } + createSocket(req, options, cb) { + const connectOpts = { + ...options, + secureEndpoint: this.isSecureEndpoint(options), + }; + const name = this.getName(connectOpts); + const fakeSocket = this.incrementSockets(name); + Promise.resolve() + .then(() => this.connect(req, connectOpts)) + .then((socket) => { + this.decrementSockets(name, fakeSocket); + if (socket instanceof http.Agent) { + try { + // @ts-expect-error `addRequest()` isn't defined in `@types/node` + return socket.addRequest(req, connectOpts); + } + catch (err) { + return cb(err); + } + } + this[INTERNAL].currentSocket = socket; + // @ts-expect-error `createSocket()` isn't defined in `@types/node` + super.createSocket(req, options, cb); + }, (err) => { + this.decrementSockets(name, fakeSocket); + cb(err); + }); + } + createConnection() { + const socket = this[INTERNAL].currentSocket; + this[INTERNAL].currentSocket = undefined; + if (!socket) { + throw new Error('No socket was returned in the `connect()` function'); + } + return socket; + } + get defaultPort() { + return (this[INTERNAL].defaultPort ?? + (this.protocol === 'https:' ? 443 : 80)); + } + set defaultPort(v) { + if (this[INTERNAL]) { + this[INTERNAL].defaultPort = v; + } + } + get protocol() { + return (this[INTERNAL].protocol ?? + (this.isSecureEndpoint() ? 'https:' : 'http:')); + } + set protocol(v) { + if (this[INTERNAL]) { + this[INTERNAL].protocol = v; + } + } } +exports.Agent = Agent; +//# sourceMappingURL=index.js.map -function encodeHex(character) { - var string, handle, length; +/***/ }), - string = character.toString(16).toUpperCase(); +/***/ 6110: +/***/ ((module, exports, __nccwpck_require__) => { - if (character <= 0xFF) { - handle = 'x'; - length = 2; - } else if (character <= 0xFFFF) { - handle = 'u'; - length = 4; - } else if (character <= 0xFFFFFFFF) { - handle = 'U'; - length = 8; - } else { - throw new YAMLException('code point within a string may not be greater than 0xFFFFFFFF'); - } +/* eslint-env browser */ - return '\\' + handle + common.repeat('0', length - string.length) + string; -} +/** + * This is the web browser implementation of `debug()`. + */ -function State(options) { - this.schema = options['schema'] || DEFAULT_FULL_SCHEMA; - this.indent = Math.max(1, (options['indent'] || 2)); - this.noArrayIndent = options['noArrayIndent'] || false; - this.skipInvalid = options['skipInvalid'] || false; - this.flowLevel = (common.isNothing(options['flowLevel']) ? -1 : options['flowLevel']); - this.styleMap = compileStyleMap(this.schema, options['styles'] || null); - this.sortKeys = options['sortKeys'] || false; - this.lineWidth = options['lineWidth'] || 80; - this.noRefs = options['noRefs'] || false; - this.noCompatMode = options['noCompatMode'] || false; - this.condenseFlow = options['condenseFlow'] || false; +exports.formatArgs = formatArgs; +exports.save = save; +exports.load = load; +exports.useColors = useColors; +exports.storage = localstorage(); +exports.destroy = (() => { + let warned = false; + + return () => { + if (!warned) { + warned = true; + console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.'); + } + }; +})(); - this.implicitTypes = this.schema.compiledImplicit; - this.explicitTypes = this.schema.compiledExplicit; +/** + * Colors. + */ - this.tag = null; - this.result = ''; +exports.colors = [ + '#0000CC', + '#0000FF', + '#0033CC', + '#0033FF', + '#0066CC', + '#0066FF', + '#0099CC', + '#0099FF', + '#00CC00', + '#00CC33', + '#00CC66', + '#00CC99', + '#00CCCC', + '#00CCFF', + '#3300CC', + '#3300FF', + '#3333CC', + '#3333FF', + '#3366CC', + '#3366FF', + '#3399CC', + '#3399FF', + '#33CC00', + '#33CC33', + '#33CC66', + '#33CC99', + '#33CCCC', + '#33CCFF', + '#6600CC', + '#6600FF', + '#6633CC', + '#6633FF', + '#66CC00', + '#66CC33', + '#9900CC', + '#9900FF', + '#9933CC', + '#9933FF', + '#99CC00', + '#99CC33', + '#CC0000', + '#CC0033', + '#CC0066', + '#CC0099', + '#CC00CC', + '#CC00FF', + '#CC3300', + '#CC3333', + '#CC3366', + '#CC3399', + '#CC33CC', + '#CC33FF', + '#CC6600', + '#CC6633', + '#CC9900', + '#CC9933', + '#CCCC00', + '#CCCC33', + '#FF0000', + '#FF0033', + '#FF0066', + '#FF0099', + '#FF00CC', + '#FF00FF', + '#FF3300', + '#FF3333', + '#FF3366', + '#FF3399', + '#FF33CC', + '#FF33FF', + '#FF6600', + '#FF6633', + '#FF9900', + '#FF9933', + '#FFCC00', + '#FFCC33' +]; - this.duplicates = []; - this.usedDuplicates = null; +/** + * Currently only WebKit-based Web Inspectors, Firefox >= v31, + * and the Firebug extension (any Firefox version) are known + * to support "%c" CSS customizations. + * + * TODO: add a `localStorage` variable to explicitly enable/disable colors + */ + +// eslint-disable-next-line complexity +function useColors() { + // NB: In an Electron preload script, document will be defined but not fully + // initialized. Since we know we're in Chrome, we'll just detect this case + // explicitly + if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) { + return true; + } + + // Internet Explorer and Edge do not support colors. + if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) { + return false; + } + + let m; + + // Is webkit? http://stackoverflow.com/a/16459606/376773 + // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632 + // eslint-disable-next-line no-return-assign + return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) || + // Is firebug? http://stackoverflow.com/a/398120/376773 + (typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) || + // Is firefox >= v31? + // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages + (typeof navigator !== 'undefined' && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31) || + // Double check webkit in userAgent just in case we are in a worker + (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/)); } -// Indents every line in a string. Empty lines (\n only) are not indented. -function indentString(string, spaces) { - var ind = common.repeat(' ', spaces), - position = 0, - next = -1, - result = '', - line, - length = string.length; +/** + * Colorize log arguments if enabled. + * + * @api public + */ - while (position < length) { - next = string.indexOf('\n', position); - if (next === -1) { - line = string.slice(position); - position = length; - } else { - line = string.slice(position, next + 1); - position = next + 1; - } +function formatArgs(args) { + args[0] = (this.useColors ? '%c' : '') + + this.namespace + + (this.useColors ? ' %c' : ' ') + + args[0] + + (this.useColors ? '%c ' : ' ') + + '+' + module.exports.humanize(this.diff); + + if (!this.useColors) { + return; + } + + const c = 'color: ' + this.color; + args.splice(1, 0, c, 'color: inherit'); + + // The final "%c" is somewhat tricky, because there could be other + // arguments passed either before or after the %c, so we need to + // figure out the correct index to insert the CSS into + let index = 0; + let lastC = 0; + args[0].replace(/%[a-zA-Z%]/g, match => { + if (match === '%%') { + return; + } + index++; + if (match === '%c') { + // We only are interested in the *last* %c + // (the user may have provided their own) + lastC = index; + } + }); + + args.splice(lastC, 0, c); +} - if (line.length && line !== '\n') result += ind; +/** + * Invokes `console.debug()` when available. + * No-op when `console.debug` is not a "function". + * If `console.debug` is not available, falls back + * to `console.log`. + * + * @api public + */ +exports.log = console.debug || console.log || (() => {}); - result += line; - } +/** + * Save `namespaces`. + * + * @param {String} namespaces + * @api private + */ +function save(namespaces) { + try { + if (namespaces) { + exports.storage.setItem('debug', namespaces); + } else { + exports.storage.removeItem('debug'); + } + } catch (error) { + // Swallow + // XXX (@Qix-) should we be logging these? + } +} - return result; +/** + * Load `namespaces`. + * + * @return {String} returns the previously persisted debug modes + * @api private + */ +function load() { + let r; + try { + r = exports.storage.getItem('debug') || exports.storage.getItem('DEBUG') ; + } catch (error) { + // Swallow + // XXX (@Qix-) should we be logging these? + } + + // If debug isn't set in LS, and we're in Electron, try to load $DEBUG + if (!r && typeof process !== 'undefined' && 'env' in process) { + r = process.env.DEBUG; + } + + return r; } -function generateNextLine(state, level) { - return '\n' + common.repeat(' ', state.indent * level); +/** + * Localstorage attempts to return the localstorage. + * + * This is necessary because safari throws + * when a user disables cookies/localstorage + * and you attempt to access it. + * + * @return {LocalStorage} + * @api private + */ + +function localstorage() { + try { + // TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context + // The Browser also has localStorage in the global context. + return localStorage; + } catch (error) { + // Swallow + // XXX (@Qix-) should we be logging these? + } } -function testImplicitResolving(state, str) { - var index, length, type; +module.exports = __nccwpck_require__(897)(exports); - for (index = 0, length = state.implicitTypes.length; index < length; index += 1) { - type = state.implicitTypes[index]; +const {formatters} = module.exports; - if (type.resolve(str)) { - return true; - } - } +/** + * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default. + */ - return false; -} +formatters.j = function (v) { + try { + return JSON.stringify(v); + } catch (error) { + return '[UnexpectedJSONParseError]: ' + error.message; + } +}; -// [33] s-white ::= s-space | s-tab -function isWhitespace(c) { - return c === CHAR_SPACE || c === CHAR_TAB; -} -// Returns true if the character can be printed without escaping. -// From YAML 1.2: "any allowed characters known to be non-printable -// should also be escaped. [However,] This isn’t mandatory" -// Derived from nb-char - \t - #x85 - #xA0 - #x2028 - #x2029. -function isPrintable(c) { - return (0x00020 <= c && c <= 0x00007E) - || ((0x000A1 <= c && c <= 0x00D7FF) && c !== 0x2028 && c !== 0x2029) - || ((0x0E000 <= c && c <= 0x00FFFD) && c !== 0xFEFF /* BOM */) - || (0x10000 <= c && c <= 0x10FFFF); -} +/***/ }), -// [34] ns-char ::= nb-char - s-white -// [27] nb-char ::= c-printable - b-char - c-byte-order-mark -// [26] b-char ::= b-line-feed | b-carriage-return -// [24] b-line-feed ::= #xA /* LF */ -// [25] b-carriage-return ::= #xD /* CR */ -// [3] c-byte-order-mark ::= #xFEFF -function isNsChar(c) { - return isPrintable(c) && !isWhitespace(c) - // byte-order-mark - && c !== 0xFEFF - // b-char - && c !== CHAR_CARRIAGE_RETURN - && c !== CHAR_LINE_FEED; +/***/ 897: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + + +/** + * This is the common logic for both the Node.js and web browser + * implementations of `debug()`. + */ + +function setup(env) { + createDebug.debug = createDebug; + createDebug.default = createDebug; + createDebug.coerce = coerce; + createDebug.disable = disable; + createDebug.enable = enable; + createDebug.enabled = enabled; + createDebug.humanize = __nccwpck_require__(744); + createDebug.destroy = destroy; + + Object.keys(env).forEach(key => { + createDebug[key] = env[key]; + }); + + /** + * The currently active debug mode names, and names to skip. + */ + + createDebug.names = []; + createDebug.skips = []; + + /** + * Map of special "%n" handling functions, for the debug "format" argument. + * + * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N". + */ + createDebug.formatters = {}; + + /** + * Selects a color for a debug namespace + * @param {String} namespace The namespace string for the debug instance to be colored + * @return {Number|String} An ANSI color code for the given namespace + * @api private + */ + function selectColor(namespace) { + let hash = 0; + + for (let i = 0; i < namespace.length; i++) { + hash = ((hash << 5) - hash) + namespace.charCodeAt(i); + hash |= 0; // Convert to 32bit integer + } + + return createDebug.colors[Math.abs(hash) % createDebug.colors.length]; + } + createDebug.selectColor = selectColor; + + /** + * Create a debugger with the given `namespace`. + * + * @param {String} namespace + * @return {Function} + * @api public + */ + function createDebug(namespace) { + let prevTime; + let enableOverride = null; + let namespacesCache; + let enabledCache; + + function debug(...args) { + // Disabled? + if (!debug.enabled) { + return; + } + + const self = debug; + + // Set `diff` timestamp + const curr = Number(new Date()); + const ms = curr - (prevTime || curr); + self.diff = ms; + self.prev = prevTime; + self.curr = curr; + prevTime = curr; + + args[0] = createDebug.coerce(args[0]); + + if (typeof args[0] !== 'string') { + // Anything else let's inspect with %O + args.unshift('%O'); + } + + // Apply any `formatters` transformations + let index = 0; + args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => { + // If we encounter an escaped % then don't increase the array index + if (match === '%%') { + return '%'; + } + index++; + const formatter = createDebug.formatters[format]; + if (typeof formatter === 'function') { + const val = args[index]; + match = formatter.call(self, val); + + // Now we need to remove `args[index]` since it's inlined in the `format` + args.splice(index, 1); + index--; + } + return match; + }); + + // Apply env-specific formatting (colors, etc.) + createDebug.formatArgs.call(self, args); + + const logFn = self.log || createDebug.log; + logFn.apply(self, args); + } + + debug.namespace = namespace; + debug.useColors = createDebug.useColors(); + debug.color = createDebug.selectColor(namespace); + debug.extend = extend; + debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release. + + Object.defineProperty(debug, 'enabled', { + enumerable: true, + configurable: false, + get: () => { + if (enableOverride !== null) { + return enableOverride; + } + if (namespacesCache !== createDebug.namespaces) { + namespacesCache = createDebug.namespaces; + enabledCache = createDebug.enabled(namespace); + } + + return enabledCache; + }, + set: v => { + enableOverride = v; + } + }); + + // Env-specific initialization logic for debug instances + if (typeof createDebug.init === 'function') { + createDebug.init(debug); + } + + return debug; + } + + function extend(namespace, delimiter) { + const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace); + newDebug.log = this.log; + return newDebug; + } + + /** + * Enables a debug mode by namespaces. This can include modes + * separated by a colon and wildcards. + * + * @param {String} namespaces + * @api public + */ + function enable(namespaces) { + createDebug.save(namespaces); + createDebug.namespaces = namespaces; + + createDebug.names = []; + createDebug.skips = []; + + const split = (typeof namespaces === 'string' ? namespaces : '') + .trim() + .replace(/\s+/g, ',') + .split(',') + .filter(Boolean); + + for (const ns of split) { + if (ns[0] === '-') { + createDebug.skips.push(ns.slice(1)); + } else { + createDebug.names.push(ns); + } + } + } + + /** + * Checks if the given string matches a namespace template, honoring + * asterisks as wildcards. + * + * @param {String} search + * @param {String} template + * @return {Boolean} + */ + function matchesTemplate(search, template) { + let searchIndex = 0; + let templateIndex = 0; + let starIndex = -1; + let matchIndex = 0; + + while (searchIndex < search.length) { + if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === '*')) { + // Match character or proceed with wildcard + if (template[templateIndex] === '*') { + starIndex = templateIndex; + matchIndex = searchIndex; + templateIndex++; // Skip the '*' + } else { + searchIndex++; + templateIndex++; + } + } else if (starIndex !== -1) { // eslint-disable-line no-negated-condition + // Backtrack to the last '*' and try to match more characters + templateIndex = starIndex + 1; + matchIndex++; + searchIndex = matchIndex; + } else { + return false; // No match + } + } + + // Handle trailing '*' in template + while (templateIndex < template.length && template[templateIndex] === '*') { + templateIndex++; + } + + return templateIndex === template.length; + } + + /** + * Disable debug output. + * + * @return {String} namespaces + * @api public + */ + function disable() { + const namespaces = [ + ...createDebug.names, + ...createDebug.skips.map(namespace => '-' + namespace) + ].join(','); + createDebug.enable(''); + return namespaces; + } + + /** + * Returns true if the given mode name is enabled, false otherwise. + * + * @param {String} name + * @return {Boolean} + * @api public + */ + function enabled(name) { + for (const skip of createDebug.skips) { + if (matchesTemplate(name, skip)) { + return false; + } + } + + for (const ns of createDebug.names) { + if (matchesTemplate(name, ns)) { + return true; + } + } + + return false; + } + + /** + * Coerce `val`. + * + * @param {Mixed} val + * @return {Mixed} + * @api private + */ + function coerce(val) { + if (val instanceof Error) { + return val.stack || val.message; + } + return val; + } + + /** + * XXX DO NOT USE. This is a temporary stub function. + * XXX It WILL be removed in the next major release. + */ + function destroy() { + console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.'); + } + + createDebug.enable(createDebug.load()); + + return createDebug; } -// Simplified test for values allowed after the first character in plain style. -function isPlainSafe(c, prev) { - // Uses a subset of nb-char - c-flow-indicator - ":" - "#" - // where nb-char ::= c-printable - b-char - c-byte-order-mark. - return isPrintable(c) && c !== 0xFEFF - // - c-flow-indicator - && c !== CHAR_COMMA - && c !== CHAR_LEFT_SQUARE_BRACKET - && c !== CHAR_RIGHT_SQUARE_BRACKET - && c !== CHAR_LEFT_CURLY_BRACKET - && c !== CHAR_RIGHT_CURLY_BRACKET - // - ":" - "#" - // /* An ns-char preceding */ "#" - && c !== CHAR_COLON - && ((c !== CHAR_SHARP) || (prev && isNsChar(prev))); +module.exports = setup; + + +/***/ }), + +/***/ 2830: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +/** + * Detect Electron renderer / nwjs process, which is node, but we should + * treat as a browser. + */ + +if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) { + module.exports = __nccwpck_require__(6110); +} else { + module.exports = __nccwpck_require__(5108); } -// Simplified test for values allowed as the first character in plain style. -function isPlainSafeFirst(c) { - // Uses a subset of ns-char - c-indicator - // where ns-char = nb-char - s-white. - return isPrintable(c) && c !== 0xFEFF - && !isWhitespace(c) // - s-white - // - (c-indicator ::= - // “-” | “?” | “:” | “,” | “[” | “]” | “{” | “}” - && c !== CHAR_MINUS - && c !== CHAR_QUESTION - && c !== CHAR_COLON - && c !== CHAR_COMMA - && c !== CHAR_LEFT_SQUARE_BRACKET - && c !== CHAR_RIGHT_SQUARE_BRACKET - && c !== CHAR_LEFT_CURLY_BRACKET - && c !== CHAR_RIGHT_CURLY_BRACKET - // | “#” | “&” | “*” | “!” | “|” | “=” | “>” | “'” | “"” - && c !== CHAR_SHARP - && c !== CHAR_AMPERSAND - && c !== CHAR_ASTERISK - && c !== CHAR_EXCLAMATION - && c !== CHAR_VERTICAL_LINE - && c !== CHAR_EQUALS - && c !== CHAR_GREATER_THAN - && c !== CHAR_SINGLE_QUOTE - && c !== CHAR_DOUBLE_QUOTE - // | “%” | “@” | “`”) - && c !== CHAR_PERCENT - && c !== CHAR_COMMERCIAL_AT - && c !== CHAR_GRAVE_ACCENT; -} -// Determines whether block indentation indicator is required. -function needIndentIndicator(string) { - var leadingSpaceRe = /^\n* /; - return leadingSpaceRe.test(string); -} +/***/ }), -var STYLE_PLAIN = 1, - STYLE_SINGLE = 2, - STYLE_LITERAL = 3, - STYLE_FOLDED = 4, - STYLE_DOUBLE = 5; +/***/ 5108: +/***/ ((module, exports, __nccwpck_require__) => { -// Determines which scalar styles are possible and returns the preferred style. -// lineWidth = -1 => no limit. -// Pre-conditions: str.length > 0. -// Post-conditions: -// STYLE_PLAIN or STYLE_SINGLE => no \n are in the string. -// STYLE_LITERAL => no lines are suitable for folding (or lineWidth is -1). -// STYLE_FOLDED => a line > lineWidth and can be folded (and lineWidth != -1). -function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType) { - var i; - var char, prev_char; - var hasLineBreak = false; - var hasFoldableLine = false; // only checked if shouldTrackWidth - var shouldTrackWidth = lineWidth !== -1; - var previousLineBreak = -1; // count the first line correctly - var plain = isPlainSafeFirst(string.charCodeAt(0)) - && !isWhitespace(string.charCodeAt(string.length - 1)); +/** + * Module dependencies. + */ - if (singleLineOnly) { - // Case: no block styles. - // Check for disallowed characters to rule out plain and single. - for (i = 0; i < string.length; i++) { - char = string.charCodeAt(i); - if (!isPrintable(char)) { - return STYLE_DOUBLE; - } - prev_char = i > 0 ? string.charCodeAt(i - 1) : null; - plain = plain && isPlainSafe(char, prev_char); - } - } else { - // Case: block styles permitted. - for (i = 0; i < string.length; i++) { - char = string.charCodeAt(i); - if (char === CHAR_LINE_FEED) { - hasLineBreak = true; - // Check if any line can be folded. - if (shouldTrackWidth) { - hasFoldableLine = hasFoldableLine || - // Foldable line = too long, and not more-indented. - (i - previousLineBreak - 1 > lineWidth && - string[previousLineBreak + 1] !== ' '); - previousLineBreak = i; - } - } else if (!isPrintable(char)) { - return STYLE_DOUBLE; - } - prev_char = i > 0 ? string.charCodeAt(i - 1) : null; - plain = plain && isPlainSafe(char, prev_char); - } - // in case the end is missing a \n - hasFoldableLine = hasFoldableLine || (shouldTrackWidth && - (i - previousLineBreak - 1 > lineWidth && - string[previousLineBreak + 1] !== ' ')); - } - // Although every style can represent \n without escaping, prefer block styles - // for multiline, since they're more readable and they don't add empty lines. - // Also prefer folding a super-long line. - if (!hasLineBreak && !hasFoldableLine) { - // Strings interpretable as another type have to be quoted; - // e.g. the string 'true' vs. the boolean true. - return plain && !testAmbiguousType(string) - ? STYLE_PLAIN : STYLE_SINGLE; - } - // Edge case: block indentation indicator can only have one digit. - if (indentPerLevel > 9 && needIndentIndicator(string)) { - return STYLE_DOUBLE; - } - // At this point we know block styles are valid. - // Prefer literal style unless we want to fold. - return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL; -} +const tty = __nccwpck_require__(2018); +const util = __nccwpck_require__(9023); -// Note: line breaking/folding is implemented for only the folded style. -// NB. We drop the last trailing newline (if any) of a returned block scalar -// since the dumper adds its own newline. This always works: -// • No ending newline => unaffected; already using strip "-" chomping. -// • Ending newline => removed then restored. -// Importantly, this keeps the "+" chomp indicator from gaining an extra line. -function writeScalar(state, string, level, iskey) { - state.dump = (function () { - if (string.length === 0) { - return "''"; - } - if (!state.noCompatMode && - DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1) { - return "'" + string + "'"; - } +/** + * This is the Node.js implementation of `debug()`. + */ - var indent = state.indent * Math.max(1, level); // no 0-indent scalars - // As indentation gets deeper, let the width decrease monotonically - // to the lower bound min(state.lineWidth, 40). - // Note that this implies - // state.lineWidth ≤ 40 + state.indent: width is fixed at the lower bound. - // state.lineWidth > 40 + state.indent: width decreases until the lower bound. - // This behaves better than a constant minimum width which disallows narrower options, - // or an indent threshold which causes the width to suddenly increase. - var lineWidth = state.lineWidth === -1 - ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent); +exports.init = init; +exports.log = log; +exports.formatArgs = formatArgs; +exports.save = save; +exports.load = load; +exports.useColors = useColors; +exports.destroy = util.deprecate( + () => {}, + 'Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.' +); - // Without knowing if keys are implicit/explicit, assume implicit for safety. - var singleLineOnly = iskey - // No block styles in flow mode. - || (state.flowLevel > -1 && level >= state.flowLevel); - function testAmbiguity(string) { - return testImplicitResolving(state, string); - } +/** + * Colors. + */ - switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth, testAmbiguity)) { - case STYLE_PLAIN: - return string; - case STYLE_SINGLE: - return "'" + string.replace(/'/g, "''") + "'"; - case STYLE_LITERAL: - return '|' + blockHeader(string, state.indent) - + dropEndingNewline(indentString(string, indent)); - case STYLE_FOLDED: - return '>' + blockHeader(string, state.indent) - + dropEndingNewline(indentString(foldString(string, lineWidth), indent)); - case STYLE_DOUBLE: - return '"' + escapeString(string, lineWidth) + '"'; - default: - throw new YAMLException('impossible error: invalid scalar style'); - } - }()); +exports.colors = [6, 2, 3, 4, 5, 1]; + +try { + // Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json) + // eslint-disable-next-line import/no-extraneous-dependencies + const supportsColor = __nccwpck_require__(1450); + + if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) { + exports.colors = [ + 20, + 21, + 26, + 27, + 32, + 33, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 56, + 57, + 62, + 63, + 68, + 69, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 92, + 93, + 98, + 99, + 112, + 113, + 128, + 129, + 134, + 135, + 148, + 149, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 178, + 179, + 184, + 185, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 214, + 215, + 220, + 221 + ]; + } +} catch (error) { + // Swallow - we only care if `supports-color` is available; it doesn't have to be. } -// Pre-conditions: string is valid for a block scalar, 1 <= indentPerLevel <= 9. -function blockHeader(string, indentPerLevel) { - var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : ''; +/** + * Build up the default `inspectOpts` object from the environment variables. + * + * $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js + */ - // note the special case: the string '\n' counts as a "trailing" empty line. - var clip = string[string.length - 1] === '\n'; - var keep = clip && (string[string.length - 2] === '\n' || string === '\n'); - var chomp = keep ? '+' : (clip ? '' : '-'); +exports.inspectOpts = Object.keys(process.env).filter(key => { + return /^debug_/i.test(key); +}).reduce((obj, key) => { + // Camel-case + const prop = key + .substring(6) + .toLowerCase() + .replace(/_([a-z])/g, (_, k) => { + return k.toUpperCase(); + }); + + // Coerce string value into JS value + let val = process.env[key]; + if (/^(yes|on|true|enabled)$/i.test(val)) { + val = true; + } else if (/^(no|off|false|disabled)$/i.test(val)) { + val = false; + } else if (val === 'null') { + val = null; + } else { + val = Number(val); + } + + obj[prop] = val; + return obj; +}, {}); - return indentIndicator + chomp + '\n'; -} +/** + * Is stdout a TTY? Colored output is enabled when `true`. + */ -// (See the note for writeScalar.) -function dropEndingNewline(string) { - return string[string.length - 1] === '\n' ? string.slice(0, -1) : string; +function useColors() { + return 'colors' in exports.inspectOpts ? + Boolean(exports.inspectOpts.colors) : + tty.isatty(process.stderr.fd); } -// Note: a long line without a suitable break point will exceed the width limit. -// Pre-conditions: every char in str isPrintable, str.length > 0, width > 0. -function foldString(string, width) { - // In folded style, $k$ consecutive newlines output as $k+1$ newlines— - // unless they're before or after a more-indented line, or at the very - // beginning or end, in which case $k$ maps to $k$. - // Therefore, parse each chunk as newline(s) followed by a content line. - var lineRe = /(\n+)([^\n]*)/g; +/** + * Adds ANSI color escape codes if enabled. + * + * @api public + */ - // first line (possibly an empty line) - var result = (function () { - var nextLF = string.indexOf('\n'); - nextLF = nextLF !== -1 ? nextLF : string.length; - lineRe.lastIndex = nextLF; - return foldLine(string.slice(0, nextLF), width); - }()); - // If we haven't reached the first content line yet, don't add an extra \n. - var prevMoreIndented = string[0] === '\n' || string[0] === ' '; - var moreIndented; +function formatArgs(args) { + const {namespace: name, useColors} = this; - // rest of the lines - var match; - while ((match = lineRe.exec(string))) { - var prefix = match[1], line = match[2]; - moreIndented = (line[0] === ' '); - result += prefix - + (!prevMoreIndented && !moreIndented && line !== '' - ? '\n' : '') - + foldLine(line, width); - prevMoreIndented = moreIndented; - } + if (useColors) { + const c = this.color; + const colorCode = '\u001B[3' + (c < 8 ? c : '8;5;' + c); + const prefix = ` ${colorCode};1m${name} \u001B[0m`; - return result; + args[0] = prefix + args[0].split('\n').join('\n' + prefix); + args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + '\u001B[0m'); + } else { + args[0] = getDate() + name + ' ' + args[0]; + } } -// Greedy line breaking. -// Picks the longest line under the limit each time, -// otherwise settles for the shortest line over the limit. -// NB. More-indented lines *cannot* be folded, as that would add an extra \n. -function foldLine(line, width) { - if (line === '' || line[0] === ' ') return line; +function getDate() { + if (exports.inspectOpts.hideDate) { + return ''; + } + return new Date().toISOString() + ' '; +} - // Since a more-indented line adds a \n, breaks can't be followed by a space. - var breakRe = / [^ ]/g; // note: the match index will always be <= length-2. - var match; - // start is an inclusive index. end, curr, and next are exclusive. - var start = 0, end, curr = 0, next = 0; - var result = ''; +/** + * Invokes `util.formatWithOptions()` with the specified arguments and writes to stderr. + */ - // Invariants: 0 <= start <= length-1. - // 0 <= curr <= next <= max(0, length-2). curr - start <= width. - // Inside the loop: - // A match implies length >= 2, so curr and next are <= length-2. - while ((match = breakRe.exec(line))) { - next = match.index; - // maintain invariant: curr - start <= width - if (next - start > width) { - end = (curr > start) ? curr : next; // derive end <= length-2 - result += '\n' + line.slice(start, end); - // skip the space that was output as \n - start = end + 1; // derive start <= length-1 - } - curr = next; - } +function log(...args) { + return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + '\n'); +} - // By the invariants, start <= length-1, so there is something left over. - // It is either the whole string or a part starting from non-whitespace. - result += '\n'; - // Insert a break if the remainder is too long and there is a break available. - if (line.length - start > width && curr > start) { - result += line.slice(start, curr) + '\n' + line.slice(curr + 1); - } else { - result += line.slice(start); - } +/** + * Save `namespaces`. + * + * @param {String} namespaces + * @api private + */ +function save(namespaces) { + if (namespaces) { + process.env.DEBUG = namespaces; + } else { + // If you set a process.env field to null or undefined, it gets cast to the + // string 'null' or 'undefined'. Just delete instead. + delete process.env.DEBUG; + } +} - return result.slice(1); // drop extra \n joiner +/** + * Load `namespaces`. + * + * @return {String} returns the previously persisted debug modes + * @api private + */ + +function load() { + return process.env.DEBUG; } -// Escapes a double-quoted string. -function escapeString(string) { - var result = ''; - var char, nextChar; - var escapeSeq; +/** + * Init logic for `debug` instances. + * + * Create a new `inspectOpts` object in case `useColors` is set + * differently for a particular `debug` instance. + */ - for (var i = 0; i < string.length; i++) { - char = string.charCodeAt(i); - // Check for surrogate pairs (reference Unicode 3.0 section "3.7 Surrogates"). - if (char >= 0xD800 && char <= 0xDBFF/* high surrogate */) { - nextChar = string.charCodeAt(i + 1); - if (nextChar >= 0xDC00 && nextChar <= 0xDFFF/* low surrogate */) { - // Combine the surrogate pair and store it escaped. - result += encodeHex((char - 0xD800) * 0x400 + nextChar - 0xDC00 + 0x10000); - // Advance index one extra since we already used that char here. - i++; continue; - } - } - escapeSeq = ESCAPE_SEQUENCES[char]; - result += !escapeSeq && isPrintable(char) - ? string[i] - : escapeSeq || encodeHex(char); - } +function init(debug) { + debug.inspectOpts = {}; - return result; + const keys = Object.keys(exports.inspectOpts); + for (let i = 0; i < keys.length; i++) { + debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]]; + } } -function writeFlowSequence(state, level, object) { - var _result = '', - _tag = state.tag, - index, - length; +module.exports = __nccwpck_require__(897)(exports); - for (index = 0, length = object.length; index < length; index += 1) { - // Write only valid elements. - if (writeNode(state, level, object[index], false, false)) { - if (index !== 0) _result += ',' + (!state.condenseFlow ? ' ' : ''); - _result += state.dump; - } - } +const {formatters} = module.exports; - state.tag = _tag; - state.dump = '[' + _result + ']'; -} +/** + * Map %o to `util.inspect()`, all on a single line. + */ -function writeBlockSequence(state, level, object, compact) { - var _result = '', - _tag = state.tag, - index, - length; +formatters.o = function (v) { + this.inspectOpts.colors = this.useColors; + return util.inspect(v, this.inspectOpts) + .split('\n') + .map(str => str.trim()) + .join(' '); +}; - for (index = 0, length = object.length; index < length; index += 1) { - // Write only valid elements. - if (writeNode(state, level + 1, object[index], true, true)) { - if (!compact || index !== 0) { - _result += generateNextLine(state, level); - } +/** + * Map %O to `util.inspect()`, allowing multiple lines if needed. + */ - if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { - _result += '-'; - } else { - _result += '- '; - } +formatters.O = function (v) { + this.inspectOpts.colors = this.useColors; + return util.inspect(v, this.inspectOpts); +}; - _result += state.dump; - } - } - state.tag = _tag; - state.dump = _result || '[]'; // Empty sequence if no valid values. -} +/***/ }), -function writeFlowMapping(state, level, object) { - var _result = '', - _tag = state.tag, - objectKeyList = Object.keys(object), - index, - length, - objectKey, - objectValue, - pairBuffer; +/***/ 3813: +/***/ ((module) => { - for (index = 0, length = objectKeyList.length; index < length; index += 1) { +"use strict"; - pairBuffer = ''; - if (index !== 0) pairBuffer += ', '; - if (state.condenseFlow) pairBuffer += '"'; +module.exports = (flag, argv = process.argv) => { + const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--'); + const position = argv.indexOf(prefix + flag); + const terminatorPosition = argv.indexOf('--'); + return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition); +}; - objectKey = objectKeyList[index]; - objectValue = object[objectKey]; - if (!writeNode(state, level, objectKey, false, false)) { - continue; // Skip this pair because of invalid key; - } +/***/ }), - if (state.dump.length > 1024) pairBuffer += '? '; +/***/ 3669: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - pairBuffer += state.dump + (state.condenseFlow ? '"' : '') + ':' + (state.condenseFlow ? '' : ' '); +"use strict"; - if (!writeNode(state, level, objectValue, false, false)) { - continue; // Skip this pair because of invalid value. +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 (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.HttpsProxyAgent = void 0; +const net = __importStar(__nccwpck_require__(9278)); +const tls = __importStar(__nccwpck_require__(4756)); +const assert_1 = __importDefault(__nccwpck_require__(2613)); +const debug_1 = __importDefault(__nccwpck_require__(2830)); +const agent_base_1 = __nccwpck_require__(8894); +const url_1 = __nccwpck_require__(7016); +const parse_proxy_response_1 = __nccwpck_require__(7943); +const debug = (0, debug_1.default)('https-proxy-agent'); +const setServernameFromNonIpHost = (options) => { + if (options.servername === undefined && + options.host && + !net.isIP(options.host)) { + return { + ...options, + servername: options.host, + }; + } + return options; +}; +/** + * The `HttpsProxyAgent` implements an HTTP Agent subclass that connects to + * the specified "HTTP(s) proxy server" in order to proxy HTTPS requests. + * + * Outgoing HTTP requests are first tunneled through the proxy server using the + * `CONNECT` HTTP request method to establish a connection to the proxy server, + * and then the proxy server connects to the destination target and issues the + * HTTP request from the proxy server. + * + * `https:` requests have their socket connection upgraded to TLS once + * the connection to the proxy server has been established. + */ +class HttpsProxyAgent extends agent_base_1.Agent { + constructor(proxy, opts) { + super(opts); + this.options = { path: undefined }; + this.proxy = typeof proxy === 'string' ? new url_1.URL(proxy) : proxy; + this.proxyHeaders = opts?.headers ?? {}; + debug('Creating new HttpsProxyAgent instance: %o', this.proxy.href); + // Trim off the brackets from IPv6 addresses + const host = (this.proxy.hostname || this.proxy.host).replace(/^\[|\]$/g, ''); + const port = this.proxy.port + ? parseInt(this.proxy.port, 10) + : this.proxy.protocol === 'https:' + ? 443 + : 80; + this.connectOpts = { + // Attempt to negotiate http/1.1 for proxy servers that support http/2 + ALPNProtocols: ['http/1.1'], + ...(opts ? omit(opts, 'headers') : null), + host, + port, + }; + } + /** + * Called when the node-core HTTP client library is creating a + * new HTTP request. + */ + async connect(req, opts) { + const { proxy } = this; + if (!opts.host) { + throw new TypeError('No "host" provided'); + } + // Create a socket connection to the proxy server. + let socket; + if (proxy.protocol === 'https:') { + debug('Creating `tls.Socket`: %o', this.connectOpts); + socket = tls.connect(setServernameFromNonIpHost(this.connectOpts)); + } + else { + debug('Creating `net.Socket`: %o', this.connectOpts); + socket = net.connect(this.connectOpts); + } + const headers = typeof this.proxyHeaders === 'function' + ? this.proxyHeaders() + : { ...this.proxyHeaders }; + const host = net.isIPv6(opts.host) ? `[${opts.host}]` : opts.host; + let payload = `CONNECT ${host}:${opts.port} HTTP/1.1\r\n`; + // Inject the `Proxy-Authorization` header if necessary. + if (proxy.username || proxy.password) { + const auth = `${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`; + headers['Proxy-Authorization'] = `Basic ${Buffer.from(auth).toString('base64')}`; + } + headers.Host = `${host}:${opts.port}`; + if (!headers['Proxy-Connection']) { + headers['Proxy-Connection'] = this.keepAlive + ? 'Keep-Alive' + : 'close'; + } + for (const name of Object.keys(headers)) { + payload += `${name}: ${headers[name]}\r\n`; + } + const proxyResponsePromise = (0, parse_proxy_response_1.parseProxyResponse)(socket); + socket.write(`${payload}\r\n`); + const { connect, buffered } = await proxyResponsePromise; + req.emit('proxyConnect', connect); + this.emit('proxyConnect', connect, req); + if (connect.statusCode === 200) { + req.once('socket', resume); + if (opts.secureEndpoint) { + // The proxy is connecting to a TLS server, so upgrade + // this socket connection to a TLS connection. + debug('Upgrading socket connection to TLS'); + return tls.connect({ + ...omit(setServernameFromNonIpHost(opts), 'host', 'path', 'port'), + socket, + }); + } + return socket; + } + // Some other status code that's not 200... need to re-play the HTTP + // header "data" events onto the socket once the HTTP machinery is + // attached so that the node core `http` can parse and handle the + // error status code. + // Close the original socket, and a new "fake" socket is returned + // instead, so that the proxy doesn't get the HTTP request + // written to it (which may contain `Authorization` headers or other + // sensitive data). + // + // See: https://hackerone.com/reports/541502 + socket.destroy(); + const fakeSocket = new net.Socket({ writable: false }); + fakeSocket.readable = true; + // Need to wait for the "socket" event to re-play the "data" events. + req.once('socket', (s) => { + debug('Replaying proxy buffer for failed request'); + (0, assert_1.default)(s.listenerCount('data') > 0); + // Replay the "buffered" Buffer onto the fake `socket`, since at + // this point the HTTP module machinery has been hooked up for + // the user. + s.push(buffered); + s.push(null); + }); + return fakeSocket; } +} +HttpsProxyAgent.protocols = ['http', 'https']; +exports.HttpsProxyAgent = HttpsProxyAgent; +function resume(socket) { + socket.resume(); +} +function omit(obj, ...keys) { + const ret = {}; + let key; + for (key in obj) { + if (!keys.includes(key)) { + ret[key] = obj[key]; + } + } + return ret; +} +//# sourceMappingURL=index.js.map - pairBuffer += state.dump; +/***/ }), - // Both key and value are valid. - _result += pairBuffer; - } +/***/ 7943: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { - state.tag = _tag; - state.dump = '{' + _result + '}'; +"use strict"; + +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.parseProxyResponse = void 0; +const debug_1 = __importDefault(__nccwpck_require__(2830)); +const debug = (0, debug_1.default)('https-proxy-agent:parse-proxy-response'); +function parseProxyResponse(socket) { + return new Promise((resolve, reject) => { + // we need to buffer any HTTP traffic that happens with the proxy before we get + // the CONNECT response, so that if the response is anything other than an "200" + // response code, then we can re-play the "data" events on the socket once the + // HTTP parser is hooked up... + let buffersLength = 0; + const buffers = []; + function read() { + const b = socket.read(); + if (b) + ondata(b); + else + socket.once('readable', read); + } + function cleanup() { + socket.removeListener('end', onend); + socket.removeListener('error', onerror); + socket.removeListener('readable', read); + } + function onend() { + cleanup(); + debug('onend'); + reject(new Error('Proxy connection ended before receiving CONNECT response')); + } + function onerror(err) { + cleanup(); + debug('onerror %o', err); + reject(err); + } + function ondata(b) { + buffers.push(b); + buffersLength += b.length; + const buffered = Buffer.concat(buffers, buffersLength); + const endOfHeaders = buffered.indexOf('\r\n\r\n'); + if (endOfHeaders === -1) { + // keep buffering + debug('have not received end of HTTP headers yet...'); + read(); + return; + } + const headerParts = buffered + .slice(0, endOfHeaders) + .toString('ascii') + .split('\r\n'); + const firstLine = headerParts.shift(); + if (!firstLine) { + socket.destroy(); + return reject(new Error('No header received from proxy CONNECT response')); + } + const firstLineParts = firstLine.split(' '); + const statusCode = +firstLineParts[1]; + const statusText = firstLineParts.slice(2).join(' '); + const headers = {}; + for (const header of headerParts) { + if (!header) + continue; + const firstColon = header.indexOf(':'); + if (firstColon === -1) { + socket.destroy(); + return reject(new Error(`Invalid header from proxy CONNECT response: "${header}"`)); + } + const key = header.slice(0, firstColon).toLowerCase(); + const value = header.slice(firstColon + 1).trimStart(); + const current = headers[key]; + if (typeof current === 'string') { + headers[key] = [current, value]; + } + else if (Array.isArray(current)) { + current.push(value); + } + else { + headers[key] = value; + } + } + debug('got proxy server response: %o %o', firstLine, headers); + cleanup(); + resolve({ + connect: { + statusCode, + statusText, + headers, + }, + buffered, + }); + } + socket.on('error', onerror); + socket.on('end', onend); + read(); + }); } +exports.parseProxyResponse = parseProxyResponse; +//# sourceMappingURL=parse-proxy-response.js.map -function writeBlockMapping(state, level, object, compact) { - var _result = '', - _tag = state.tag, - objectKeyList = Object.keys(object), - index, - length, - objectKey, - objectValue, - explicitPair, - pairBuffer; +/***/ }), - // Allow sorting keys so that the output file is deterministic - if (state.sortKeys === true) { - // Default sorting - objectKeyList.sort(); - } else if (typeof state.sortKeys === 'function') { - // Custom sort function - objectKeyList.sort(state.sortKeys); - } else if (state.sortKeys) { - // Something is wrong - throw new YAMLException('sortKeys must be a boolean or a function'); - } +/***/ 4281: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - for (index = 0, length = objectKeyList.length; index < length; index += 1) { - pairBuffer = ''; +"use strict"; - if (!compact || index !== 0) { - pairBuffer += generateNextLine(state, level); - } - objectKey = objectKeyList[index]; - objectValue = object[objectKey]; - if (!writeNode(state, level + 1, objectKey, true, true, true)) { - continue; // Skip this pair because of invalid key. - } +var loader = __nccwpck_require__(1950); +var dumper = __nccwpck_require__(9980); - explicitPair = (state.tag !== null && state.tag !== '?') || - (state.dump && state.dump.length > 1024); - if (explicitPair) { - if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { - pairBuffer += '?'; - } else { - pairBuffer += '? '; - } - } +function renamed(from, to) { + return function () { + throw new Error('Function yaml.' + from + ' is removed in js-yaml 4. ' + + 'Use yaml.' + to + ' instead, which is now safe by default.'); + }; +} - pairBuffer += state.dump; - if (explicitPair) { - pairBuffer += generateNextLine(state, level); - } +module.exports.Type = __nccwpck_require__(9557); +module.exports.Schema = __nccwpck_require__(2046); +module.exports.FAILSAFE_SCHEMA = __nccwpck_require__(9832); +module.exports.JSON_SCHEMA = __nccwpck_require__(8927); +module.exports.CORE_SCHEMA = __nccwpck_require__(5746); +module.exports.DEFAULT_SCHEMA = __nccwpck_require__(7336); +module.exports.load = loader.load; +module.exports.loadAll = loader.loadAll; +module.exports.dump = dumper.dump; +module.exports.YAMLException = __nccwpck_require__(1248); + +// Re-export all types in case user wants to create custom schema +module.exports.types = { + binary: __nccwpck_require__(8149), + float: __nccwpck_require__(7584), + map: __nccwpck_require__(7316), + null: __nccwpck_require__(4333), + pairs: __nccwpck_require__(6267), + set: __nccwpck_require__(8758), + timestamp: __nccwpck_require__(8966), + bool: __nccwpck_require__(7296), + int: __nccwpck_require__(2271), + merge: __nccwpck_require__(6854), + omap: __nccwpck_require__(8649), + seq: __nccwpck_require__(7161), + str: __nccwpck_require__(3929) +}; - if (!writeNode(state, level + 1, objectValue, true, explicitPair)) { - continue; // Skip this pair because of invalid value. - } +// Removed functions from JS-YAML 3.0.x +module.exports.safeLoad = renamed('safeLoad', 'load'); +module.exports.safeLoadAll = renamed('safeLoadAll', 'loadAll'); +module.exports.safeDump = renamed('safeDump', 'dump'); - if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { - pairBuffer += ':'; - } else { - pairBuffer += ': '; - } - pairBuffer += state.dump; +/***/ }), - // Both key and value are valid. - _result += pairBuffer; - } +/***/ 9816: +/***/ ((module) => { - state.tag = _tag; - state.dump = _result || '{}'; // Empty mapping if no valid pairs. +"use strict"; + + + +function isNothing(subject) { + return (typeof subject === 'undefined') || (subject === null); } -function detectType(state, object, explicit) { - var _result, typeList, index, length, type, style; - typeList = explicit ? state.explicitTypes : state.implicitTypes; +function isObject(subject) { + return (typeof subject === 'object') && (subject !== null); +} - for (index = 0, length = typeList.length; index < length; index += 1) { - type = typeList[index]; - if ((type.instanceOf || type.predicate) && - (!type.instanceOf || ((typeof object === 'object') && (object instanceof type.instanceOf))) && - (!type.predicate || type.predicate(object))) { +function toArray(sequence) { + if (Array.isArray(sequence)) return sequence; + else if (isNothing(sequence)) return []; - state.tag = explicit ? type.tag : '?'; + return [ sequence ]; +} - if (type.represent) { - style = state.styleMap[type.tag] || type.defaultStyle; - if (_toString.call(type.represent) === '[object Function]') { - _result = type.represent(object, style); - } else if (_hasOwnProperty.call(type.represent, style)) { - _result = type.represent[style](object, style); - } else { - throw new YAMLException('!<' + type.tag + '> tag resolver accepts not "' + style + '" style'); - } +function extend(target, source) { + var index, length, key, sourceKeys; - state.dump = _result; - } + if (source) { + sourceKeys = Object.keys(source); - return true; + for (index = 0, length = sourceKeys.length; index < length; index += 1) { + key = sourceKeys[index]; + target[key] = source[key]; } } - return false; + return target; } -// Serializes `object` and writes it to global `result`. -// Returns true on success, or false on invalid object. -// -function writeNode(state, level, object, block, compact, iskey) { - state.tag = null; - state.dump = object; - if (!detectType(state, object, false)) { - detectType(state, object, true); - } +function repeat(string, count) { + var result = '', cycle; - var type = _toString.call(state.dump); - - if (block) { - block = (state.flowLevel < 0 || state.flowLevel > level); - } - - var objectOrArray = type === '[object Object]' || type === '[object Array]', - duplicateIndex, - duplicate; - - if (objectOrArray) { - duplicateIndex = state.duplicates.indexOf(object); - duplicate = duplicateIndex !== -1; - } - - if ((state.tag !== null && state.tag !== '?') || duplicate || (state.indent !== 2 && level > 0)) { - compact = false; + for (cycle = 0; cycle < count; cycle += 1) { + result += string; } - if (duplicate && state.usedDuplicates[duplicateIndex]) { - state.dump = '*ref_' + duplicateIndex; - } else { - if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) { - state.usedDuplicates[duplicateIndex] = true; - } - if (type === '[object Object]') { - if (block && (Object.keys(state.dump).length !== 0)) { - writeBlockMapping(state, level, state.dump, compact); - if (duplicate) { - state.dump = '&ref_' + duplicateIndex + state.dump; - } - } else { - writeFlowMapping(state, level, state.dump); - if (duplicate) { - state.dump = '&ref_' + duplicateIndex + ' ' + state.dump; - } - } - } else if (type === '[object Array]') { - var arrayLevel = (state.noArrayIndent && (level > 0)) ? level - 1 : level; - if (block && (state.dump.length !== 0)) { - writeBlockSequence(state, arrayLevel, state.dump, compact); - if (duplicate) { - state.dump = '&ref_' + duplicateIndex + state.dump; - } - } else { - writeFlowSequence(state, arrayLevel, state.dump); - if (duplicate) { - state.dump = '&ref_' + duplicateIndex + ' ' + state.dump; - } - } - } else if (type === '[object String]') { - if (state.tag !== '?') { - writeScalar(state, state.dump, level, iskey); - } - } else { - if (state.skipInvalid) return false; - throw new YAMLException('unacceptable kind of an object to dump ' + type); - } + return result; +} - if (state.tag !== null && state.tag !== '?') { - state.dump = '!<' + state.tag + '> ' + state.dump; - } - } - return true; +function isNegativeZero(number) { + return (number === 0) && (Number.NEGATIVE_INFINITY === 1 / number); } -function getDuplicateReferences(object, state) { - var objects = [], - duplicatesIndexes = [], - index, - length; - - inspectNode(object, objects, duplicatesIndexes); - for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) { - state.duplicates.push(objects[duplicatesIndexes[index]]); - } - state.usedDuplicates = new Array(length); -} +module.exports.isNothing = isNothing; +module.exports.isObject = isObject; +module.exports.toArray = toArray; +module.exports.repeat = repeat; +module.exports.isNegativeZero = isNegativeZero; +module.exports.extend = extend; -function inspectNode(object, objects, duplicatesIndexes) { - var objectKeyList, - index, - length; - if (object !== null && typeof object === 'object') { - index = objects.indexOf(object); - if (index !== -1) { - if (duplicatesIndexes.indexOf(index) === -1) { - duplicatesIndexes.push(index); - } - } else { - objects.push(object); +/***/ }), - if (Array.isArray(object)) { - for (index = 0, length = object.length; index < length; index += 1) { - inspectNode(object[index], objects, duplicatesIndexes); - } - } else { - objectKeyList = Object.keys(object); +/***/ 9980: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - for (index = 0, length = objectKeyList.length; index < length; index += 1) { - inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes); - } - } - } - } -} +"use strict"; -function dump(input, options) { - options = options || {}; - var state = new State(options); +/*eslint-disable no-use-before-define*/ - if (!state.noRefs) getDuplicateReferences(input, state); +var common = __nccwpck_require__(9816); +var YAMLException = __nccwpck_require__(1248); +var DEFAULT_SCHEMA = __nccwpck_require__(7336); - if (writeNode(state, 0, input, true, true)) return state.dump + '\n'; +var _toString = Object.prototype.toString; +var _hasOwnProperty = Object.prototype.hasOwnProperty; - return ''; -} +var CHAR_BOM = 0xFEFF; +var CHAR_TAB = 0x09; /* Tab */ +var CHAR_LINE_FEED = 0x0A; /* LF */ +var CHAR_CARRIAGE_RETURN = 0x0D; /* CR */ +var CHAR_SPACE = 0x20; /* Space */ +var CHAR_EXCLAMATION = 0x21; /* ! */ +var CHAR_DOUBLE_QUOTE = 0x22; /* " */ +var CHAR_SHARP = 0x23; /* # */ +var CHAR_PERCENT = 0x25; /* % */ +var CHAR_AMPERSAND = 0x26; /* & */ +var CHAR_SINGLE_QUOTE = 0x27; /* ' */ +var CHAR_ASTERISK = 0x2A; /* * */ +var CHAR_COMMA = 0x2C; /* , */ +var CHAR_MINUS = 0x2D; /* - */ +var CHAR_COLON = 0x3A; /* : */ +var CHAR_EQUALS = 0x3D; /* = */ +var CHAR_GREATER_THAN = 0x3E; /* > */ +var CHAR_QUESTION = 0x3F; /* ? */ +var CHAR_COMMERCIAL_AT = 0x40; /* @ */ +var CHAR_LEFT_SQUARE_BRACKET = 0x5B; /* [ */ +var CHAR_RIGHT_SQUARE_BRACKET = 0x5D; /* ] */ +var CHAR_GRAVE_ACCENT = 0x60; /* ` */ +var CHAR_LEFT_CURLY_BRACKET = 0x7B; /* { */ +var CHAR_VERTICAL_LINE = 0x7C; /* | */ +var CHAR_RIGHT_CURLY_BRACKET = 0x7D; /* } */ -function safeDump(input, options) { - return dump(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options)); -} +var ESCAPE_SEQUENCES = {}; -module.exports.dump = dump; -module.exports.safeDump = safeDump; +ESCAPE_SEQUENCES[0x00] = '\\0'; +ESCAPE_SEQUENCES[0x07] = '\\a'; +ESCAPE_SEQUENCES[0x08] = '\\b'; +ESCAPE_SEQUENCES[0x09] = '\\t'; +ESCAPE_SEQUENCES[0x0A] = '\\n'; +ESCAPE_SEQUENCES[0x0B] = '\\v'; +ESCAPE_SEQUENCES[0x0C] = '\\f'; +ESCAPE_SEQUENCES[0x0D] = '\\r'; +ESCAPE_SEQUENCES[0x1B] = '\\e'; +ESCAPE_SEQUENCES[0x22] = '\\"'; +ESCAPE_SEQUENCES[0x5C] = '\\\\'; +ESCAPE_SEQUENCES[0x85] = '\\N'; +ESCAPE_SEQUENCES[0xA0] = '\\_'; +ESCAPE_SEQUENCES[0x2028] = '\\L'; +ESCAPE_SEQUENCES[0x2029] = '\\P'; +var DEPRECATED_BOOLEANS_SYNTAX = [ + 'y', 'Y', 'yes', 'Yes', 'YES', 'on', 'On', 'ON', + 'n', 'N', 'no', 'No', 'NO', 'off', 'Off', 'OFF' +]; -/***/ }), +var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/; -/***/ 2699: -/***/ (function(module) { +function compileStyleMap(schema, map) { + var result, keys, index, length, tag, style, type; -module.exports = {"version":"2.0","metadata":{"apiVersion":"2015-04-16","endpointPrefix":"ds","jsonVersion":"1.1","protocol":"json","serviceAbbreviation":"Directory Service","serviceFullName":"AWS Directory Service","serviceId":"Directory Service","signatureVersion":"v4","targetPrefix":"DirectoryService_20150416","uid":"ds-2015-04-16"},"operations":{"AcceptSharedDirectory":{"input":{"type":"structure","required":["SharedDirectoryId"],"members":{"SharedDirectoryId":{}}},"output":{"type":"structure","members":{"SharedDirectory":{"shape":"S4"}}}},"AddIpRoutes":{"input":{"type":"structure","required":["DirectoryId","IpRoutes"],"members":{"DirectoryId":{},"IpRoutes":{"type":"list","member":{"type":"structure","members":{"CidrIp":{},"Description":{}}}},"UpdateSecurityGroupForDirectoryControllers":{"type":"boolean"}}},"output":{"type":"structure","members":{}}},"AddTagsToResource":{"input":{"type":"structure","required":["ResourceId","Tags"],"members":{"ResourceId":{},"Tags":{"shape":"Sk"}}},"output":{"type":"structure","members":{}}},"CancelSchemaExtension":{"input":{"type":"structure","required":["DirectoryId","SchemaExtensionId"],"members":{"DirectoryId":{},"SchemaExtensionId":{}}},"output":{"type":"structure","members":{}}},"ConnectDirectory":{"input":{"type":"structure","required":["Name","Password","Size","ConnectSettings"],"members":{"Name":{},"ShortName":{},"Password":{"shape":"Sv"},"Description":{},"Size":{},"ConnectSettings":{"type":"structure","required":["VpcId","SubnetIds","CustomerDnsIps","CustomerUserName"],"members":{"VpcId":{},"SubnetIds":{"shape":"Sz"},"CustomerDnsIps":{"shape":"S11"},"CustomerUserName":{}}},"Tags":{"shape":"Sk"}}},"output":{"type":"structure","members":{"DirectoryId":{}}}},"CreateAlias":{"input":{"type":"structure","required":["DirectoryId","Alias"],"members":{"DirectoryId":{},"Alias":{}}},"output":{"type":"structure","members":{"DirectoryId":{},"Alias":{}}}},"CreateComputer":{"input":{"type":"structure","required":["DirectoryId","ComputerName","Password"],"members":{"DirectoryId":{},"ComputerName":{},"Password":{"type":"string","sensitive":true},"OrganizationalUnitDistinguishedName":{},"ComputerAttributes":{"shape":"S1c"}}},"output":{"type":"structure","members":{"Computer":{"type":"structure","members":{"ComputerId":{},"ComputerName":{},"ComputerAttributes":{"shape":"S1c"}}}}}},"CreateConditionalForwarder":{"input":{"type":"structure","required":["DirectoryId","RemoteDomainName","DnsIpAddrs"],"members":{"DirectoryId":{},"RemoteDomainName":{},"DnsIpAddrs":{"shape":"S11"}}},"output":{"type":"structure","members":{}}},"CreateDirectory":{"input":{"type":"structure","required":["Name","Password","Size"],"members":{"Name":{},"ShortName":{},"Password":{"shape":"S1n"},"Description":{},"Size":{},"VpcSettings":{"shape":"S1o"},"Tags":{"shape":"Sk"}}},"output":{"type":"structure","members":{"DirectoryId":{}}}},"CreateLogSubscription":{"input":{"type":"structure","required":["DirectoryId","LogGroupName"],"members":{"DirectoryId":{},"LogGroupName":{}}},"output":{"type":"structure","members":{}}},"CreateMicrosoftAD":{"input":{"type":"structure","required":["Name","Password","VpcSettings"],"members":{"Name":{},"ShortName":{},"Password":{"shape":"S1n"},"Description":{},"VpcSettings":{"shape":"S1o"},"Edition":{},"Tags":{"shape":"Sk"}}},"output":{"type":"structure","members":{"DirectoryId":{}}}},"CreateSnapshot":{"input":{"type":"structure","required":["DirectoryId"],"members":{"DirectoryId":{},"Name":{}}},"output":{"type":"structure","members":{"SnapshotId":{}}}},"CreateTrust":{"input":{"type":"structure","required":["DirectoryId","RemoteDomainName","TrustPassword","TrustDirection"],"members":{"DirectoryId":{},"RemoteDomainName":{},"TrustPassword":{"type":"string","sensitive":true},"TrustDirection":{},"TrustType":{},"ConditionalForwarderIpAddrs":{"shape":"S11"},"SelectiveAuth":{}}},"output":{"type":"structure","members":{"TrustId":{}}}},"DeleteConditionalForwarder":{"input":{"type":"structure","required":["DirectoryId","RemoteDomainName"],"members":{"DirectoryId":{},"RemoteDomainName":{}}},"output":{"type":"structure","members":{}}},"DeleteDirectory":{"input":{"type":"structure","required":["DirectoryId"],"members":{"DirectoryId":{}}},"output":{"type":"structure","members":{"DirectoryId":{}}}},"DeleteLogSubscription":{"input":{"type":"structure","required":["DirectoryId"],"members":{"DirectoryId":{}}},"output":{"type":"structure","members":{}}},"DeleteSnapshot":{"input":{"type":"structure","required":["SnapshotId"],"members":{"SnapshotId":{}}},"output":{"type":"structure","members":{"SnapshotId":{}}}},"DeleteTrust":{"input":{"type":"structure","required":["TrustId"],"members":{"TrustId":{},"DeleteAssociatedConditionalForwarder":{"type":"boolean"}}},"output":{"type":"structure","members":{"TrustId":{}}}},"DeregisterCertificate":{"input":{"type":"structure","required":["DirectoryId","CertificateId"],"members":{"DirectoryId":{},"CertificateId":{}}},"output":{"type":"structure","members":{}}},"DeregisterEventTopic":{"input":{"type":"structure","required":["DirectoryId","TopicName"],"members":{"DirectoryId":{},"TopicName":{}}},"output":{"type":"structure","members":{}}},"DescribeCertificate":{"input":{"type":"structure","required":["DirectoryId","CertificateId"],"members":{"DirectoryId":{},"CertificateId":{}}},"output":{"type":"structure","members":{"Certificate":{"type":"structure","members":{"CertificateId":{},"State":{},"StateReason":{},"CommonName":{},"RegisteredDateTime":{"type":"timestamp"},"ExpiryDateTime":{"type":"timestamp"}}}}}},"DescribeConditionalForwarders":{"input":{"type":"structure","required":["DirectoryId"],"members":{"DirectoryId":{},"RemoteDomainNames":{"type":"list","member":{}}}},"output":{"type":"structure","members":{"ConditionalForwarders":{"type":"list","member":{"type":"structure","members":{"RemoteDomainName":{},"DnsIpAddrs":{"shape":"S11"},"ReplicationScope":{}}}}}}},"DescribeDirectories":{"input":{"type":"structure","members":{"DirectoryIds":{"shape":"S33"},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"DirectoryDescriptions":{"type":"list","member":{"type":"structure","members":{"DirectoryId":{},"Name":{},"ShortName":{},"Size":{},"Edition":{},"Alias":{},"AccessUrl":{},"Description":{},"DnsIpAddrs":{"shape":"S11"},"Stage":{},"ShareStatus":{},"ShareMethod":{},"ShareNotes":{"shape":"S8"},"LaunchTime":{"type":"timestamp"},"StageLastUpdatedDateTime":{"type":"timestamp"},"Type":{},"VpcSettings":{"shape":"S3d"},"ConnectSettings":{"type":"structure","members":{"VpcId":{},"SubnetIds":{"shape":"Sz"},"CustomerUserName":{},"SecurityGroupId":{},"AvailabilityZones":{"shape":"S3f"},"ConnectIps":{"type":"list","member":{}}}},"RadiusSettings":{"shape":"S3j"},"RadiusStatus":{},"StageReason":{},"SsoEnabled":{"type":"boolean"},"DesiredNumberOfDomainControllers":{"type":"integer"},"OwnerDirectoryDescription":{"type":"structure","members":{"DirectoryId":{},"AccountId":{},"DnsIpAddrs":{"shape":"S11"},"VpcSettings":{"shape":"S3d"},"RadiusSettings":{"shape":"S3j"},"RadiusStatus":{}}}}}},"NextToken":{}}}},"DescribeDomainControllers":{"input":{"type":"structure","required":["DirectoryId"],"members":{"DirectoryId":{},"DomainControllerIds":{"type":"list","member":{}},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"DomainControllers":{"type":"list","member":{"type":"structure","members":{"DirectoryId":{},"DomainControllerId":{},"DnsIpAddr":{},"VpcId":{},"SubnetId":{},"AvailabilityZone":{},"Status":{},"StatusReason":{},"LaunchTime":{"type":"timestamp"},"StatusLastUpdatedDateTime":{"type":"timestamp"}}}},"NextToken":{}}}},"DescribeEventTopics":{"input":{"type":"structure","members":{"DirectoryId":{},"TopicNames":{"type":"list","member":{}}}},"output":{"type":"structure","members":{"EventTopics":{"type":"list","member":{"type":"structure","members":{"DirectoryId":{},"TopicName":{},"TopicArn":{},"CreatedDateTime":{"type":"timestamp"},"Status":{}}}}}}},"DescribeLDAPSSettings":{"input":{"type":"structure","required":["DirectoryId"],"members":{"DirectoryId":{},"Type":{},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"LDAPSSettingsInfo":{"type":"list","member":{"type":"structure","members":{"LDAPSStatus":{},"LDAPSStatusReason":{},"LastUpdatedDateTime":{"type":"timestamp"}}}},"NextToken":{}}}},"DescribeSharedDirectories":{"input":{"type":"structure","required":["OwnerDirectoryId"],"members":{"OwnerDirectoryId":{},"SharedDirectoryIds":{"shape":"S33"},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"SharedDirectories":{"type":"list","member":{"shape":"S4"}},"NextToken":{}}}},"DescribeSnapshots":{"input":{"type":"structure","members":{"DirectoryId":{},"SnapshotIds":{"type":"list","member":{}},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"Snapshots":{"type":"list","member":{"type":"structure","members":{"DirectoryId":{},"SnapshotId":{},"Type":{},"Name":{},"Status":{},"StartTime":{"type":"timestamp"}}}},"NextToken":{}}}},"DescribeTrusts":{"input":{"type":"structure","members":{"DirectoryId":{},"TrustIds":{"type":"list","member":{}},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"Trusts":{"type":"list","member":{"type":"structure","members":{"DirectoryId":{},"TrustId":{},"RemoteDomainName":{},"TrustType":{},"TrustDirection":{},"TrustState":{},"CreatedDateTime":{"type":"timestamp"},"LastUpdatedDateTime":{"type":"timestamp"},"StateLastUpdatedDateTime":{"type":"timestamp"},"TrustStateReason":{},"SelectiveAuth":{}}}},"NextToken":{}}}},"DisableLDAPS":{"input":{"type":"structure","required":["DirectoryId","Type"],"members":{"DirectoryId":{},"Type":{}}},"output":{"type":"structure","members":{}}},"DisableRadius":{"input":{"type":"structure","required":["DirectoryId"],"members":{"DirectoryId":{}}},"output":{"type":"structure","members":{}}},"DisableSso":{"input":{"type":"structure","required":["DirectoryId"],"members":{"DirectoryId":{},"UserName":{},"Password":{"shape":"Sv"}}},"output":{"type":"structure","members":{}}},"EnableLDAPS":{"input":{"type":"structure","required":["DirectoryId","Type"],"members":{"DirectoryId":{},"Type":{}}},"output":{"type":"structure","members":{}}},"EnableRadius":{"input":{"type":"structure","required":["DirectoryId","RadiusSettings"],"members":{"DirectoryId":{},"RadiusSettings":{"shape":"S3j"}}},"output":{"type":"structure","members":{}}},"EnableSso":{"input":{"type":"structure","required":["DirectoryId"],"members":{"DirectoryId":{},"UserName":{},"Password":{"shape":"Sv"}}},"output":{"type":"structure","members":{}}},"GetDirectoryLimits":{"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"DirectoryLimits":{"type":"structure","members":{"CloudOnlyDirectoriesLimit":{"type":"integer"},"CloudOnlyDirectoriesCurrentCount":{"type":"integer"},"CloudOnlyDirectoriesLimitReached":{"type":"boolean"},"CloudOnlyMicrosoftADLimit":{"type":"integer"},"CloudOnlyMicrosoftADCurrentCount":{"type":"integer"},"CloudOnlyMicrosoftADLimitReached":{"type":"boolean"},"ConnectedDirectoriesLimit":{"type":"integer"},"ConnectedDirectoriesCurrentCount":{"type":"integer"},"ConnectedDirectoriesLimitReached":{"type":"boolean"}}}}}},"GetSnapshotLimits":{"input":{"type":"structure","required":["DirectoryId"],"members":{"DirectoryId":{}}},"output":{"type":"structure","members":{"SnapshotLimits":{"type":"structure","members":{"ManualSnapshotsLimit":{"type":"integer"},"ManualSnapshotsCurrentCount":{"type":"integer"},"ManualSnapshotsLimitReached":{"type":"boolean"}}}}}},"ListCertificates":{"input":{"type":"structure","required":["DirectoryId"],"members":{"DirectoryId":{},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"NextToken":{},"CertificatesInfo":{"type":"list","member":{"type":"structure","members":{"CertificateId":{},"CommonName":{},"State":{},"ExpiryDateTime":{"type":"timestamp"}}}}}}},"ListIpRoutes":{"input":{"type":"structure","required":["DirectoryId"],"members":{"DirectoryId":{},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"IpRoutesInfo":{"type":"list","member":{"type":"structure","members":{"DirectoryId":{},"CidrIp":{},"IpRouteStatusMsg":{},"AddedDateTime":{"type":"timestamp"},"IpRouteStatusReason":{},"Description":{}}}},"NextToken":{}}}},"ListLogSubscriptions":{"input":{"type":"structure","members":{"DirectoryId":{},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"LogSubscriptions":{"type":"list","member":{"type":"structure","members":{"DirectoryId":{},"LogGroupName":{},"SubscriptionCreatedDateTime":{"type":"timestamp"}}}},"NextToken":{}}}},"ListSchemaExtensions":{"input":{"type":"structure","required":["DirectoryId"],"members":{"DirectoryId":{},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"SchemaExtensionsInfo":{"type":"list","member":{"type":"structure","members":{"DirectoryId":{},"SchemaExtensionId":{},"Description":{},"SchemaExtensionStatus":{},"SchemaExtensionStatusReason":{},"StartDateTime":{"type":"timestamp"},"EndDateTime":{"type":"timestamp"}}}},"NextToken":{}}}},"ListTagsForResource":{"input":{"type":"structure","required":["ResourceId"],"members":{"ResourceId":{},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"Tags":{"shape":"Sk"},"NextToken":{}}}},"RegisterCertificate":{"input":{"type":"structure","required":["DirectoryId","CertificateData"],"members":{"DirectoryId":{},"CertificateData":{}}},"output":{"type":"structure","members":{"CertificateId":{}}}},"RegisterEventTopic":{"input":{"type":"structure","required":["DirectoryId","TopicName"],"members":{"DirectoryId":{},"TopicName":{}}},"output":{"type":"structure","members":{}}},"RejectSharedDirectory":{"input":{"type":"structure","required":["SharedDirectoryId"],"members":{"SharedDirectoryId":{}}},"output":{"type":"structure","members":{"SharedDirectoryId":{}}}},"RemoveIpRoutes":{"input":{"type":"structure","required":["DirectoryId","CidrIps"],"members":{"DirectoryId":{},"CidrIps":{"type":"list","member":{}}}},"output":{"type":"structure","members":{}}},"RemoveTagsFromResource":{"input":{"type":"structure","required":["ResourceId","TagKeys"],"members":{"ResourceId":{},"TagKeys":{"type":"list","member":{}}}},"output":{"type":"structure","members":{}}},"ResetUserPassword":{"input":{"type":"structure","required":["DirectoryId","UserName","NewPassword"],"members":{"DirectoryId":{},"UserName":{},"NewPassword":{"type":"string","sensitive":true}}},"output":{"type":"structure","members":{}}},"RestoreFromSnapshot":{"input":{"type":"structure","required":["SnapshotId"],"members":{"SnapshotId":{}}},"output":{"type":"structure","members":{}}},"ShareDirectory":{"input":{"type":"structure","required":["DirectoryId","ShareTarget","ShareMethod"],"members":{"DirectoryId":{},"ShareNotes":{"shape":"S8"},"ShareTarget":{"type":"structure","required":["Id","Type"],"members":{"Id":{},"Type":{}}},"ShareMethod":{}}},"output":{"type":"structure","members":{"SharedDirectoryId":{}}}},"StartSchemaExtension":{"input":{"type":"structure","required":["DirectoryId","CreateSnapshotBeforeSchemaExtension","LdifContent","Description"],"members":{"DirectoryId":{},"CreateSnapshotBeforeSchemaExtension":{"type":"boolean"},"LdifContent":{},"Description":{}}},"output":{"type":"structure","members":{"SchemaExtensionId":{}}}},"UnshareDirectory":{"input":{"type":"structure","required":["DirectoryId","UnshareTarget"],"members":{"DirectoryId":{},"UnshareTarget":{"type":"structure","required":["Id","Type"],"members":{"Id":{},"Type":{}}}}},"output":{"type":"structure","members":{"SharedDirectoryId":{}}}},"UpdateConditionalForwarder":{"input":{"type":"structure","required":["DirectoryId","RemoteDomainName","DnsIpAddrs"],"members":{"DirectoryId":{},"RemoteDomainName":{},"DnsIpAddrs":{"shape":"S11"}}},"output":{"type":"structure","members":{}}},"UpdateNumberOfDomainControllers":{"input":{"type":"structure","required":["DirectoryId","DesiredNumber"],"members":{"DirectoryId":{},"DesiredNumber":{"type":"integer"}}},"output":{"type":"structure","members":{}}},"UpdateRadius":{"input":{"type":"structure","required":["DirectoryId","RadiusSettings"],"members":{"DirectoryId":{},"RadiusSettings":{"shape":"S3j"}}},"output":{"type":"structure","members":{}}},"UpdateTrust":{"input":{"type":"structure","required":["TrustId"],"members":{"TrustId":{},"SelectiveAuth":{}}},"output":{"type":"structure","members":{"RequestId":{},"TrustId":{}}}},"VerifyTrust":{"input":{"type":"structure","required":["TrustId"],"members":{"TrustId":{}}},"output":{"type":"structure","members":{"TrustId":{}}}}},"shapes":{"S4":{"type":"structure","members":{"OwnerAccountId":{},"OwnerDirectoryId":{},"ShareMethod":{},"SharedAccountId":{},"SharedDirectoryId":{},"ShareStatus":{},"ShareNotes":{"shape":"S8"},"CreatedDateTime":{"type":"timestamp"},"LastUpdatedDateTime":{"type":"timestamp"}}},"S8":{"type":"string","sensitive":true},"Sk":{"type":"list","member":{"type":"structure","required":["Key","Value"],"members":{"Key":{},"Value":{}}}},"Sv":{"type":"string","sensitive":true},"Sz":{"type":"list","member":{}},"S11":{"type":"list","member":{}},"S1c":{"type":"list","member":{"type":"structure","members":{"Name":{},"Value":{}}}},"S1n":{"type":"string","sensitive":true},"S1o":{"type":"structure","required":["VpcId","SubnetIds"],"members":{"VpcId":{},"SubnetIds":{"shape":"Sz"}}},"S33":{"type":"list","member":{}},"S3d":{"type":"structure","members":{"VpcId":{},"SubnetIds":{"shape":"Sz"},"SecurityGroupId":{},"AvailabilityZones":{"shape":"S3f"}}},"S3f":{"type":"list","member":{}},"S3j":{"type":"structure","members":{"RadiusServers":{"type":"list","member":{}},"RadiusPort":{"type":"integer"},"RadiusTimeout":{"type":"integer"},"RadiusRetries":{"type":"integer"},"SharedSecret":{"type":"string","sensitive":true},"AuthenticationProtocol":{},"DisplayLabel":{},"UseSameUsername":{"type":"boolean"}}}}}; + if (map === null) return {}; -/***/ }), + result = {}; + keys = Object.keys(map); -/***/ 2709: -/***/ (function(module, __unusedexports, __webpack_require__) { + for (index = 0, length = keys.length; index < length; index += 1) { + tag = keys[index]; + style = String(map[tag]); -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; + if (tag.slice(0, 2) === '!!') { + tag = 'tag:yaml.org,2002:' + tag.slice(2); + } + type = schema.compiledTypeMap['fallback'][tag]; -apiLoader.services['wafregional'] = {}; -AWS.WAFRegional = Service.defineService('wafregional', ['2016-11-28']); -Object.defineProperty(apiLoader.services['wafregional'], '2016-11-28', { - get: function get() { - var model = __webpack_require__(8296); - model.paginators = __webpack_require__(3396).pagination; - return model; - }, - enumerable: true, - configurable: true -}); + if (type && _hasOwnProperty.call(type.styleAliases, style)) { + style = type.styleAliases[style]; + } -module.exports = AWS.WAFRegional; + result[tag] = style; + } + return result; +} -/***/ }), +function encodeHex(character) { + var string, handle, length; -/***/ 2719: -/***/ (function(module) { + string = character.toString(16).toUpperCase(); -module.exports = {"pagination":{}}; + if (character <= 0xFF) { + handle = 'x'; + length = 2; + } else if (character <= 0xFFFF) { + handle = 'u'; + length = 4; + } else if (character <= 0xFFFFFFFF) { + handle = 'U'; + length = 8; + } else { + throw new YAMLException('code point within a string may not be greater than 0xFFFFFFFF'); + } -/***/ }), + return '\\' + handle + common.repeat('0', length - string.length) + string; +} -/***/ 2726: -/***/ (function(module) { -module.exports = {"version":"2.0","metadata":{"apiVersion":"2016-06-02","endpointPrefix":"shield","jsonVersion":"1.1","protocol":"json","serviceAbbreviation":"AWS Shield","serviceFullName":"AWS Shield","serviceId":"Shield","signatureVersion":"v4","targetPrefix":"AWSShield_20160616","uid":"shield-2016-06-02"},"operations":{"AssociateDRTLogBucket":{"input":{"type":"structure","required":["LogBucket"],"members":{"LogBucket":{}}},"output":{"type":"structure","members":{}}},"AssociateDRTRole":{"input":{"type":"structure","required":["RoleArn"],"members":{"RoleArn":{}}},"output":{"type":"structure","members":{}}},"AssociateHealthCheck":{"input":{"type":"structure","required":["ProtectionId","HealthCheckArn"],"members":{"ProtectionId":{},"HealthCheckArn":{}}},"output":{"type":"structure","members":{}}},"AssociateProactiveEngagementDetails":{"input":{"type":"structure","required":["EmergencyContactList"],"members":{"EmergencyContactList":{"shape":"Sc"}}},"output":{"type":"structure","members":{}}},"CreateProtection":{"input":{"type":"structure","required":["Name","ResourceArn"],"members":{"Name":{},"ResourceArn":{}}},"output":{"type":"structure","members":{"ProtectionId":{}}}},"CreateSubscription":{"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{}}},"DeleteProtection":{"input":{"type":"structure","required":["ProtectionId"],"members":{"ProtectionId":{}}},"output":{"type":"structure","members":{}}},"DeleteSubscription":{"input":{"type":"structure","members":{},"deprecated":true},"output":{"type":"structure","members":{},"deprecated":true},"deprecated":true},"DescribeAttack":{"input":{"type":"structure","required":["AttackId"],"members":{"AttackId":{}}},"output":{"type":"structure","members":{"Attack":{"type":"structure","members":{"AttackId":{},"ResourceArn":{},"SubResources":{"type":"list","member":{"type":"structure","members":{"Type":{},"Id":{},"AttackVectors":{"type":"list","member":{"type":"structure","required":["VectorType"],"members":{"VectorType":{},"VectorCounters":{"shape":"S12"}}}},"Counters":{"shape":"S12"}}}},"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"AttackCounters":{"shape":"S12"},"AttackProperties":{"type":"list","member":{"type":"structure","members":{"AttackLayer":{},"AttackPropertyIdentifier":{},"TopContributors":{"type":"list","member":{"type":"structure","members":{"Name":{},"Value":{"type":"long"}}}},"Unit":{},"Total":{"type":"long"}}}},"Mitigations":{"type":"list","member":{"type":"structure","members":{"MitigationName":{}}}}}}}}},"DescribeDRTAccess":{"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"RoleArn":{},"LogBucketList":{"type":"list","member":{}}}}},"DescribeEmergencyContactSettings":{"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"EmergencyContactList":{"shape":"Sc"}}}},"DescribeProtection":{"input":{"type":"structure","members":{"ProtectionId":{},"ResourceArn":{}}},"output":{"type":"structure","members":{"Protection":{"shape":"S1o"}}}},"DescribeSubscription":{"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"Subscription":{"type":"structure","members":{"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"TimeCommitmentInSeconds":{"type":"long"},"AutoRenew":{},"Limits":{"type":"list","member":{"type":"structure","members":{"Type":{},"Max":{"type":"long"}}}},"ProactiveEngagementStatus":{}}}}}},"DisableProactiveEngagement":{"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{}}},"DisassociateDRTLogBucket":{"input":{"type":"structure","required":["LogBucket"],"members":{"LogBucket":{}}},"output":{"type":"structure","members":{}}},"DisassociateDRTRole":{"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{}}},"DisassociateHealthCheck":{"input":{"type":"structure","required":["ProtectionId","HealthCheckArn"],"members":{"ProtectionId":{},"HealthCheckArn":{}}},"output":{"type":"structure","members":{}}},"EnableProactiveEngagement":{"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{}}},"GetSubscriptionState":{"input":{"type":"structure","members":{}},"output":{"type":"structure","required":["SubscriptionState"],"members":{"SubscriptionState":{}}}},"ListAttacks":{"input":{"type":"structure","members":{"ResourceArns":{"type":"list","member":{}},"StartTime":{"shape":"S2f"},"EndTime":{"shape":"S2f"},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"AttackSummaries":{"type":"list","member":{"type":"structure","members":{"AttackId":{},"ResourceArn":{},"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"AttackVectors":{"type":"list","member":{"type":"structure","required":["VectorType"],"members":{"VectorType":{}}}}}}},"NextToken":{}}}},"ListProtections":{"input":{"type":"structure","members":{"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"Protections":{"type":"list","member":{"shape":"S1o"}},"NextToken":{}}}},"UpdateEmergencyContactSettings":{"input":{"type":"structure","members":{"EmergencyContactList":{"shape":"Sc"}}},"output":{"type":"structure","members":{}}},"UpdateSubscription":{"input":{"type":"structure","members":{"AutoRenew":{}}},"output":{"type":"structure","members":{}}}},"shapes":{"Sc":{"type":"list","member":{"type":"structure","required":["EmailAddress"],"members":{"EmailAddress":{},"PhoneNumber":{},"ContactNotes":{}}}},"S12":{"type":"list","member":{"type":"structure","members":{"Name":{},"Max":{"type":"double"},"Average":{"type":"double"},"Sum":{"type":"double"},"N":{"type":"integer"},"Unit":{}}}},"S1o":{"type":"structure","members":{"Id":{},"Name":{},"ResourceArn":{},"HealthCheckIds":{"type":"list","member":{}}}},"S2f":{"type":"structure","members":{"FromInclusive":{"type":"timestamp"},"ToExclusive":{"type":"timestamp"}}}}}; +var QUOTING_TYPE_SINGLE = 1, + QUOTING_TYPE_DOUBLE = 2; -/***/ }), +function State(options) { + this.schema = options['schema'] || DEFAULT_SCHEMA; + this.indent = Math.max(1, (options['indent'] || 2)); + this.noArrayIndent = options['noArrayIndent'] || false; + this.skipInvalid = options['skipInvalid'] || false; + this.flowLevel = (common.isNothing(options['flowLevel']) ? -1 : options['flowLevel']); + this.styleMap = compileStyleMap(this.schema, options['styles'] || null); + this.sortKeys = options['sortKeys'] || false; + this.lineWidth = options['lineWidth'] || 80; + this.noRefs = options['noRefs'] || false; + this.noCompatMode = options['noCompatMode'] || false; + this.condenseFlow = options['condenseFlow'] || false; + this.quotingType = options['quotingType'] === '"' ? QUOTING_TYPE_DOUBLE : QUOTING_TYPE_SINGLE; + this.forceQuotes = options['forceQuotes'] || false; + this.replacer = typeof options['replacer'] === 'function' ? options['replacer'] : null; -/***/ 2732: -/***/ (function(module) { + this.implicitTypes = this.schema.compiledImplicit; + this.explicitTypes = this.schema.compiledExplicit; -module.exports = {"version":"2.0","metadata":{"apiVersion":"2015-10-07","endpointPrefix":"events","jsonVersion":"1.1","protocol":"json","serviceFullName":"Amazon CloudWatch Events","serviceId":"CloudWatch Events","signatureVersion":"v4","targetPrefix":"AWSEvents","uid":"events-2015-10-07"},"operations":{"ActivateEventSource":{"input":{"type":"structure","required":["Name"],"members":{"Name":{}}}},"CreateEventBus":{"input":{"type":"structure","required":["Name"],"members":{"Name":{},"EventSourceName":{},"Tags":{"shape":"S5"}}},"output":{"type":"structure","members":{"EventBusArn":{}}}},"CreatePartnerEventSource":{"input":{"type":"structure","required":["Name","Account"],"members":{"Name":{},"Account":{}}},"output":{"type":"structure","members":{"EventSourceArn":{}}}},"DeactivateEventSource":{"input":{"type":"structure","required":["Name"],"members":{"Name":{}}}},"DeleteEventBus":{"input":{"type":"structure","required":["Name"],"members":{"Name":{}}}},"DeletePartnerEventSource":{"input":{"type":"structure","required":["Name","Account"],"members":{"Name":{},"Account":{}}}},"DeleteRule":{"input":{"type":"structure","required":["Name"],"members":{"Name":{},"EventBusName":{},"Force":{"type":"boolean"}}}},"DescribeEventBus":{"input":{"type":"structure","members":{"Name":{}}},"output":{"type":"structure","members":{"Name":{},"Arn":{},"Policy":{}}}},"DescribeEventSource":{"input":{"type":"structure","required":["Name"],"members":{"Name":{}}},"output":{"type":"structure","members":{"Arn":{},"CreatedBy":{},"CreationTime":{"type":"timestamp"},"ExpirationTime":{"type":"timestamp"},"Name":{},"State":{}}}},"DescribePartnerEventSource":{"input":{"type":"structure","required":["Name"],"members":{"Name":{}}},"output":{"type":"structure","members":{"Arn":{},"Name":{}}}},"DescribeRule":{"input":{"type":"structure","required":["Name"],"members":{"Name":{},"EventBusName":{}}},"output":{"type":"structure","members":{"Name":{},"Arn":{},"EventPattern":{},"ScheduleExpression":{},"State":{},"Description":{},"RoleArn":{},"ManagedBy":{},"EventBusName":{}}}},"DisableRule":{"input":{"type":"structure","required":["Name"],"members":{"Name":{},"EventBusName":{}}}},"EnableRule":{"input":{"type":"structure","required":["Name"],"members":{"Name":{},"EventBusName":{}}}},"ListEventBuses":{"input":{"type":"structure","members":{"NamePrefix":{},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"EventBuses":{"type":"list","member":{"type":"structure","members":{"Name":{},"Arn":{},"Policy":{}}}},"NextToken":{}}}},"ListEventSources":{"input":{"type":"structure","members":{"NamePrefix":{},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"EventSources":{"type":"list","member":{"type":"structure","members":{"Arn":{},"CreatedBy":{},"CreationTime":{"type":"timestamp"},"ExpirationTime":{"type":"timestamp"},"Name":{},"State":{}}}},"NextToken":{}}}},"ListPartnerEventSourceAccounts":{"input":{"type":"structure","required":["EventSourceName"],"members":{"EventSourceName":{},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"PartnerEventSourceAccounts":{"type":"list","member":{"type":"structure","members":{"Account":{},"CreationTime":{"type":"timestamp"},"ExpirationTime":{"type":"timestamp"},"State":{}}}},"NextToken":{}}}},"ListPartnerEventSources":{"input":{"type":"structure","required":["NamePrefix"],"members":{"NamePrefix":{},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"PartnerEventSources":{"type":"list","member":{"type":"structure","members":{"Arn":{},"Name":{}}}},"NextToken":{}}}},"ListRuleNamesByTarget":{"input":{"type":"structure","required":["TargetArn"],"members":{"TargetArn":{},"EventBusName":{},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"RuleNames":{"type":"list","member":{}},"NextToken":{}}}},"ListRules":{"input":{"type":"structure","members":{"NamePrefix":{},"EventBusName":{},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"Rules":{"type":"list","member":{"type":"structure","members":{"Name":{},"Arn":{},"EventPattern":{},"State":{},"Description":{},"ScheduleExpression":{},"RoleArn":{},"ManagedBy":{},"EventBusName":{}}}},"NextToken":{}}}},"ListTagsForResource":{"input":{"type":"structure","required":["ResourceARN"],"members":{"ResourceARN":{}}},"output":{"type":"structure","members":{"Tags":{"shape":"S5"}}}},"ListTargetsByRule":{"input":{"type":"structure","required":["Rule"],"members":{"Rule":{},"EventBusName":{},"NextToken":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"Targets":{"shape":"S20"},"NextToken":{}}}},"PutEvents":{"input":{"type":"structure","required":["Entries"],"members":{"Entries":{"type":"list","member":{"type":"structure","members":{"Time":{"type":"timestamp"},"Source":{},"Resources":{"shape":"S37"},"DetailType":{},"Detail":{},"EventBusName":{}}}}}},"output":{"type":"structure","members":{"FailedEntryCount":{"type":"integer"},"Entries":{"type":"list","member":{"type":"structure","members":{"EventId":{},"ErrorCode":{},"ErrorMessage":{}}}}}}},"PutPartnerEvents":{"input":{"type":"structure","required":["Entries"],"members":{"Entries":{"type":"list","member":{"type":"structure","members":{"Time":{"type":"timestamp"},"Source":{},"Resources":{"shape":"S37"},"DetailType":{},"Detail":{}}}}}},"output":{"type":"structure","members":{"FailedEntryCount":{"type":"integer"},"Entries":{"type":"list","member":{"type":"structure","members":{"EventId":{},"ErrorCode":{},"ErrorMessage":{}}}}}}},"PutPermission":{"input":{"type":"structure","required":["Action","Principal","StatementId"],"members":{"EventBusName":{},"Action":{},"Principal":{},"StatementId":{},"Condition":{"type":"structure","required":["Type","Key","Value"],"members":{"Type":{},"Key":{},"Value":{}}}}}},"PutRule":{"input":{"type":"structure","required":["Name"],"members":{"Name":{},"ScheduleExpression":{},"EventPattern":{},"State":{},"Description":{},"RoleArn":{},"Tags":{"shape":"S5"},"EventBusName":{}}},"output":{"type":"structure","members":{"RuleArn":{}}}},"PutTargets":{"input":{"type":"structure","required":["Rule","Targets"],"members":{"Rule":{},"EventBusName":{},"Targets":{"shape":"S20"}}},"output":{"type":"structure","members":{"FailedEntryCount":{"type":"integer"},"FailedEntries":{"type":"list","member":{"type":"structure","members":{"TargetId":{},"ErrorCode":{},"ErrorMessage":{}}}}}}},"RemovePermission":{"input":{"type":"structure","required":["StatementId"],"members":{"StatementId":{},"EventBusName":{}}}},"RemoveTargets":{"input":{"type":"structure","required":["Rule","Ids"],"members":{"Rule":{},"EventBusName":{},"Ids":{"type":"list","member":{}},"Force":{"type":"boolean"}}},"output":{"type":"structure","members":{"FailedEntryCount":{"type":"integer"},"FailedEntries":{"type":"list","member":{"type":"structure","members":{"TargetId":{},"ErrorCode":{},"ErrorMessage":{}}}}}}},"TagResource":{"input":{"type":"structure","required":["ResourceARN","Tags"],"members":{"ResourceARN":{},"Tags":{"shape":"S5"}}},"output":{"type":"structure","members":{}}},"TestEventPattern":{"input":{"type":"structure","required":["EventPattern","Event"],"members":{"EventPattern":{},"Event":{}}},"output":{"type":"structure","members":{"Result":{"type":"boolean"}}}},"UntagResource":{"input":{"type":"structure","required":["ResourceARN","TagKeys"],"members":{"ResourceARN":{},"TagKeys":{"type":"list","member":{}}}},"output":{"type":"structure","members":{}}}},"shapes":{"S5":{"type":"list","member":{"type":"structure","required":["Key","Value"],"members":{"Key":{},"Value":{}}}},"S20":{"type":"list","member":{"type":"structure","required":["Id","Arn"],"members":{"Id":{},"Arn":{},"RoleArn":{},"Input":{},"InputPath":{},"InputTransformer":{"type":"structure","required":["InputTemplate"],"members":{"InputPathsMap":{"type":"map","key":{},"value":{}},"InputTemplate":{}}},"KinesisParameters":{"type":"structure","required":["PartitionKeyPath"],"members":{"PartitionKeyPath":{}}},"RunCommandParameters":{"type":"structure","required":["RunCommandTargets"],"members":{"RunCommandTargets":{"type":"list","member":{"type":"structure","required":["Key","Values"],"members":{"Key":{},"Values":{"type":"list","member":{}}}}}}},"EcsParameters":{"type":"structure","required":["TaskDefinitionArn"],"members":{"TaskDefinitionArn":{},"TaskCount":{"type":"integer"},"LaunchType":{},"NetworkConfiguration":{"type":"structure","members":{"awsvpcConfiguration":{"type":"structure","required":["Subnets"],"members":{"Subnets":{"shape":"S2m"},"SecurityGroups":{"shape":"S2m"},"AssignPublicIp":{}}}}},"PlatformVersion":{},"Group":{}}},"BatchParameters":{"type":"structure","required":["JobDefinition","JobName"],"members":{"JobDefinition":{},"JobName":{},"ArrayProperties":{"type":"structure","members":{"Size":{"type":"integer"}}},"RetryStrategy":{"type":"structure","members":{"Attempts":{"type":"integer"}}}}},"SqsParameters":{"type":"structure","members":{"MessageGroupId":{}}},"HttpParameters":{"type":"structure","members":{"PathParameterValues":{"type":"list","member":{}},"HeaderParameters":{"type":"map","key":{},"value":{}},"QueryStringParameters":{"type":"map","key":{},"value":{}}}}}}},"S2m":{"type":"list","member":{}},"S37":{"type":"list","member":{}}}}; + this.tag = null; + this.result = ''; -/***/ }), + this.duplicates = []; + this.usedDuplicates = null; +} -/***/ 2740: -/***/ (function(module) { +// Indents every line in a string. Empty lines (\n only) are not indented. +function indentString(string, spaces) { + var ind = common.repeat(' ', spaces), + position = 0, + next = -1, + result = '', + line, + length = string.length; -"use strict"; + while (position < length) { + next = string.indexOf('\n', position); + if (next === -1) { + line = string.slice(position); + position = length; + } else { + line = string.slice(position, next + 1); + position = next + 1; + } + if (line.length && line !== '\n') result += ind; + result += line; + } -function isNothing(subject) { - return (typeof subject === 'undefined') || (subject === null); + return result; } - -function isObject(subject) { - return (typeof subject === 'object') && (subject !== null); +function generateNextLine(state, level) { + return '\n' + common.repeat(' ', state.indent * level); } +function testImplicitResolving(state, str) { + var index, length, type; -function toArray(sequence) { - if (Array.isArray(sequence)) return sequence; - else if (isNothing(sequence)) return []; - - return [ sequence ]; -} - - -function extend(target, source) { - var index, length, key, sourceKeys; - - if (source) { - sourceKeys = Object.keys(source); + for (index = 0, length = state.implicitTypes.length; index < length; index += 1) { + type = state.implicitTypes[index]; - for (index = 0, length = sourceKeys.length; index < length; index += 1) { - key = sourceKeys[index]; - target[key] = source[key]; + if (type.resolve(str)) { + return true; } } - return target; + return false; } - -function repeat(string, count) { - var result = '', cycle; - - for (cycle = 0; cycle < count; cycle += 1) { - result += string; - } - - return result; +// [33] s-white ::= s-space | s-tab +function isWhitespace(c) { + return c === CHAR_SPACE || c === CHAR_TAB; } +// Returns true if the character can be printed without escaping. +// From YAML 1.2: "any allowed characters known to be non-printable +// should also be escaped. [However,] This isn’t mandatory" +// Derived from nb-char - \t - #x85 - #xA0 - #x2028 - #x2029. +function isPrintable(c) { + return (0x00020 <= c && c <= 0x00007E) + || ((0x000A1 <= c && c <= 0x00D7FF) && c !== 0x2028 && c !== 0x2029) + || ((0x0E000 <= c && c <= 0x00FFFD) && c !== CHAR_BOM) + || (0x10000 <= c && c <= 0x10FFFF); +} -function isNegativeZero(number) { - return (number === 0) && (Number.NEGATIVE_INFINITY === 1 / number); +// [34] ns-char ::= nb-char - s-white +// [27] nb-char ::= c-printable - b-char - c-byte-order-mark +// [26] b-char ::= b-line-feed | b-carriage-return +// Including s-white (for some reason, examples doesn't match specs in this aspect) +// ns-char ::= c-printable - b-line-feed - b-carriage-return - c-byte-order-mark +function isNsCharOrWhitespace(c) { + return isPrintable(c) + && c !== CHAR_BOM + // - b-char + && c !== CHAR_CARRIAGE_RETURN + && c !== CHAR_LINE_FEED; } +// [127] ns-plain-safe(c) ::= c = flow-out ⇒ ns-plain-safe-out +// c = flow-in ⇒ ns-plain-safe-in +// c = block-key ⇒ ns-plain-safe-out +// c = flow-key ⇒ ns-plain-safe-in +// [128] ns-plain-safe-out ::= ns-char +// [129] ns-plain-safe-in ::= ns-char - c-flow-indicator +// [130] ns-plain-char(c) ::= ( ns-plain-safe(c) - “:” - “#” ) +// | ( /* An ns-char preceding */ “#” ) +// | ( “:” /* Followed by an ns-plain-safe(c) */ ) +function isPlainSafe(c, prev, inblock) { + var cIsNsCharOrWhitespace = isNsCharOrWhitespace(c); + var cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace(c); + return ( + // ns-plain-safe + inblock ? // c = flow-in + cIsNsCharOrWhitespace + : cIsNsCharOrWhitespace + // - c-flow-indicator + && c !== CHAR_COMMA + && c !== CHAR_LEFT_SQUARE_BRACKET + && c !== CHAR_RIGHT_SQUARE_BRACKET + && c !== CHAR_LEFT_CURLY_BRACKET + && c !== CHAR_RIGHT_CURLY_BRACKET + ) + // ns-plain-char + && c !== CHAR_SHARP // false on '#' + && !(prev === CHAR_COLON && !cIsNsChar) // false on ': ' + || (isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c === CHAR_SHARP) // change to true on '[^ ]#' + || (prev === CHAR_COLON && cIsNsChar); // change to true on ':[^ ]' +} -module.exports.isNothing = isNothing; -module.exports.isObject = isObject; -module.exports.toArray = toArray; -module.exports.repeat = repeat; -module.exports.isNegativeZero = isNegativeZero; -module.exports.extend = extend; +// Simplified test for values allowed as the first character in plain style. +function isPlainSafeFirst(c) { + // Uses a subset of ns-char - c-indicator + // where ns-char = nb-char - s-white. + // No support of ( ( “?” | “:” | “-” ) /* Followed by an ns-plain-safe(c)) */ ) part + return isPrintable(c) && c !== CHAR_BOM + && !isWhitespace(c) // - s-white + // - (c-indicator ::= + // “-” | “?” | “:” | “,” | “[” | “]” | “{” | “}” + && c !== CHAR_MINUS + && c !== CHAR_QUESTION + && c !== CHAR_COLON + && c !== CHAR_COMMA + && c !== CHAR_LEFT_SQUARE_BRACKET + && c !== CHAR_RIGHT_SQUARE_BRACKET + && c !== CHAR_LEFT_CURLY_BRACKET + && c !== CHAR_RIGHT_CURLY_BRACKET + // | “#” | “&” | “*” | “!” | “|” | “=” | “>” | “'” | “"” + && c !== CHAR_SHARP + && c !== CHAR_AMPERSAND + && c !== CHAR_ASTERISK + && c !== CHAR_EXCLAMATION + && c !== CHAR_VERTICAL_LINE + && c !== CHAR_EQUALS + && c !== CHAR_GREATER_THAN + && c !== CHAR_SINGLE_QUOTE + && c !== CHAR_DOUBLE_QUOTE + // | “%” | “@” | “`”) + && c !== CHAR_PERCENT + && c !== CHAR_COMMERCIAL_AT + && c !== CHAR_GRAVE_ACCENT; +} +// Simplified test for values allowed as the last character in plain style. +function isPlainSafeLast(c) { + // just not whitespace or colon, it will be checked to be plain character later + return !isWhitespace(c) && c !== CHAR_COLON; +} -/***/ }), +// Same as 'string'.codePointAt(pos), but works in older browsers. +function codePointAt(string, pos) { + var first = string.charCodeAt(pos), second; + if (first >= 0xD800 && first <= 0xDBFF && pos + 1 < string.length) { + second = string.charCodeAt(pos + 1); + if (second >= 0xDC00 && second <= 0xDFFF) { + // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae + return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000; + } + } + return first; +} -/***/ 2747: -/***/ (function(module, __unusedexports, __webpack_require__) { +// Determines whether block indentation indicator is required. +function needIndentIndicator(string) { + var leadingSpaceRe = /^\n* /; + return leadingSpaceRe.test(string); +} -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +var STYLE_PLAIN = 1, + STYLE_SINGLE = 2, + STYLE_LITERAL = 3, + STYLE_FOLDED = 4, + STYLE_DOUBLE = 5; -apiLoader.services['sagemakerruntime'] = {}; -AWS.SageMakerRuntime = Service.defineService('sagemakerruntime', ['2017-05-13']); -Object.defineProperty(apiLoader.services['sagemakerruntime'], '2017-05-13', { - get: function get() { - var model = __webpack_require__(3387); - model.paginators = __webpack_require__(9239).pagination; - return model; - }, - enumerable: true, - configurable: true -}); +// Determines which scalar styles are possible and returns the preferred style. +// lineWidth = -1 => no limit. +// Pre-conditions: str.length > 0. +// Post-conditions: +// STYLE_PLAIN or STYLE_SINGLE => no \n are in the string. +// STYLE_LITERAL => no lines are suitable for folding (or lineWidth is -1). +// STYLE_FOLDED => a line > lineWidth and can be folded (and lineWidth != -1). +function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, + testAmbiguousType, quotingType, forceQuotes, inblock) { -module.exports = AWS.SageMakerRuntime; + var i; + var char = 0; + var prevChar = null; + var hasLineBreak = false; + var hasFoldableLine = false; // only checked if shouldTrackWidth + var shouldTrackWidth = lineWidth !== -1; + var previousLineBreak = -1; // count the first line correctly + var plain = isPlainSafeFirst(codePointAt(string, 0)) + && isPlainSafeLast(codePointAt(string, string.length - 1)); + if (singleLineOnly || forceQuotes) { + // Case: no block styles. + // Check for disallowed characters to rule out plain and single. + for (i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) { + char = codePointAt(string, i); + if (!isPrintable(char)) { + return STYLE_DOUBLE; + } + plain = plain && isPlainSafe(char, prevChar, inblock); + prevChar = char; + } + } else { + // Case: block styles permitted. + for (i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) { + char = codePointAt(string, i); + if (char === CHAR_LINE_FEED) { + hasLineBreak = true; + // Check if any line can be folded. + if (shouldTrackWidth) { + hasFoldableLine = hasFoldableLine || + // Foldable line = too long, and not more-indented. + (i - previousLineBreak - 1 > lineWidth && + string[previousLineBreak + 1] !== ' '); + previousLineBreak = i; + } + } else if (!isPrintable(char)) { + return STYLE_DOUBLE; + } + plain = plain && isPlainSafe(char, prevChar, inblock); + prevChar = char; + } + // in case the end is missing a \n + hasFoldableLine = hasFoldableLine || (shouldTrackWidth && + (i - previousLineBreak - 1 > lineWidth && + string[previousLineBreak + 1] !== ' ')); + } + // Although every style can represent \n without escaping, prefer block styles + // for multiline, since they're more readable and they don't add empty lines. + // Also prefer folding a super-long line. + if (!hasLineBreak && !hasFoldableLine) { + // Strings interpretable as another type have to be quoted; + // e.g. the string 'true' vs. the boolean true. + if (plain && !forceQuotes && !testAmbiguousType(string)) { + return STYLE_PLAIN; + } + return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE; + } + // Edge case: block indentation indicator can only have one digit. + if (indentPerLevel > 9 && needIndentIndicator(string)) { + return STYLE_DOUBLE; + } + // At this point we know block styles are valid. + // Prefer literal style unless we want to fold. + if (!forceQuotes) { + return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL; + } + return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE; +} -/***/ }), +// Note: line breaking/folding is implemented for only the folded style. +// NB. We drop the last trailing newline (if any) of a returned block scalar +// since the dumper adds its own newline. This always works: +// • No ending newline => unaffected; already using strip "-" chomping. +// • Ending newline => removed then restored. +// Importantly, this keeps the "+" chomp indicator from gaining an extra line. +function writeScalar(state, string, level, iskey, inblock) { + state.dump = (function () { + if (string.length === 0) { + return state.quotingType === QUOTING_TYPE_DOUBLE ? '""' : "''"; + } + if (!state.noCompatMode) { + if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string)) { + return state.quotingType === QUOTING_TYPE_DOUBLE ? ('"' + string + '"') : ("'" + string + "'"); + } + } -/***/ 2750: -/***/ (function(module, __unusedexports, __webpack_require__) { + var indent = state.indent * Math.max(1, level); // no 0-indent scalars + // As indentation gets deeper, let the width decrease monotonically + // to the lower bound min(state.lineWidth, 40). + // Note that this implies + // state.lineWidth ≤ 40 + state.indent: width is fixed at the lower bound. + // state.lineWidth > 40 + state.indent: width decreases until the lower bound. + // This behaves better than a constant minimum width which disallows narrower options, + // or an indent threshold which causes the width to suddenly increase. + var lineWidth = state.lineWidth === -1 + ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent); -// Generated by CoffeeScript 1.12.7 -(function() { - var XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLElement, XMLProcessingInstruction, XMLRaw, XMLStringWriter, XMLText, XMLWriterBase, - extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, - hasProp = {}.hasOwnProperty; + // Without knowing if keys are implicit/explicit, assume implicit for safety. + var singleLineOnly = iskey + // No block styles in flow mode. + || (state.flowLevel > -1 && level >= state.flowLevel); + function testAmbiguity(string) { + return testImplicitResolving(state, string); + } - XMLDeclaration = __webpack_require__(7738); + switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth, + testAmbiguity, state.quotingType, state.forceQuotes && !iskey, inblock)) { - XMLDocType = __webpack_require__(5735); + case STYLE_PLAIN: + return string; + case STYLE_SINGLE: + return "'" + string.replace(/'/g, "''") + "'"; + case STYLE_LITERAL: + return '|' + blockHeader(string, state.indent) + + dropEndingNewline(indentString(string, indent)); + case STYLE_FOLDED: + return '>' + blockHeader(string, state.indent) + + dropEndingNewline(indentString(foldString(string, lineWidth), indent)); + case STYLE_DOUBLE: + return '"' + escapeString(string, lineWidth) + '"'; + default: + throw new YAMLException('impossible error: invalid scalar style'); + } + }()); +} - XMLCData = __webpack_require__(9657); +// Pre-conditions: string is valid for a block scalar, 1 <= indentPerLevel <= 9. +function blockHeader(string, indentPerLevel) { + var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : ''; - XMLComment = __webpack_require__(7919); + // note the special case: the string '\n' counts as a "trailing" empty line. + var clip = string[string.length - 1] === '\n'; + var keep = clip && (string[string.length - 2] === '\n' || string === '\n'); + var chomp = keep ? '+' : (clip ? '' : '-'); - XMLElement = __webpack_require__(5796); + return indentIndicator + chomp + '\n'; +} - XMLRaw = __webpack_require__(7660); +// (See the note for writeScalar.) +function dropEndingNewline(string) { + return string[string.length - 1] === '\n' ? string.slice(0, -1) : string; +} - XMLText = __webpack_require__(9708); +// Note: a long line without a suitable break point will exceed the width limit. +// Pre-conditions: every char in str isPrintable, str.length > 0, width > 0. +function foldString(string, width) { + // In folded style, $k$ consecutive newlines output as $k+1$ newlines— + // unless they're before or after a more-indented line, or at the very + // beginning or end, in which case $k$ maps to $k$. + // Therefore, parse each chunk as newline(s) followed by a content line. + var lineRe = /(\n+)([^\n]*)/g; - XMLProcessingInstruction = __webpack_require__(2491); + // first line (possibly an empty line) + var result = (function () { + var nextLF = string.indexOf('\n'); + nextLF = nextLF !== -1 ? nextLF : string.length; + lineRe.lastIndex = nextLF; + return foldLine(string.slice(0, nextLF), width); + }()); + // If we haven't reached the first content line yet, don't add an extra \n. + var prevMoreIndented = string[0] === '\n' || string[0] === ' '; + var moreIndented; - XMLDTDAttList = __webpack_require__(3801); + // rest of the lines + var match; + while ((match = lineRe.exec(string))) { + var prefix = match[1], line = match[2]; + moreIndented = (line[0] === ' '); + result += prefix + + (!prevMoreIndented && !moreIndented && line !== '' + ? '\n' : '') + + foldLine(line, width); + prevMoreIndented = moreIndented; + } - XMLDTDElement = __webpack_require__(9463); + return result; +} - XMLDTDEntity = __webpack_require__(7661); +// Greedy line breaking. +// Picks the longest line under the limit each time, +// otherwise settles for the shortest line over the limit. +// NB. More-indented lines *cannot* be folded, as that would add an extra \n. +function foldLine(line, width) { + if (line === '' || line[0] === ' ') return line; - XMLDTDNotation = __webpack_require__(9019); - - XMLWriterBase = __webpack_require__(9423); - - module.exports = XMLStringWriter = (function(superClass) { - extend(XMLStringWriter, superClass); + // Since a more-indented line adds a \n, breaks can't be followed by a space. + var breakRe = / [^ ]/g; // note: the match index will always be <= length-2. + var match; + // start is an inclusive index. end, curr, and next are exclusive. + var start = 0, end, curr = 0, next = 0; + var result = ''; - function XMLStringWriter(options) { - XMLStringWriter.__super__.constructor.call(this, options); + // Invariants: 0 <= start <= length-1. + // 0 <= curr <= next <= max(0, length-2). curr - start <= width. + // Inside the loop: + // A match implies length >= 2, so curr and next are <= length-2. + while ((match = breakRe.exec(line))) { + next = match.index; + // maintain invariant: curr - start <= width + if (next - start > width) { + end = (curr > start) ? curr : next; // derive end <= length-2 + result += '\n' + line.slice(start, end); + // skip the space that was output as \n + start = end + 1; // derive start <= length-1 } + curr = next; + } - XMLStringWriter.prototype.document = function(doc) { - var child, i, len, r, ref; - this.textispresent = false; - r = ''; - ref = doc.children; - for (i = 0, len = ref.length; i < len; i++) { - child = ref[i]; - r += (function() { - switch (false) { - case !(child instanceof XMLDeclaration): - return this.declaration(child); - case !(child instanceof XMLDocType): - return this.docType(child); - case !(child instanceof XMLComment): - return this.comment(child); - case !(child instanceof XMLProcessingInstruction): - return this.processingInstruction(child); - default: - return this.element(child, 0); - } - }).call(this); - } - if (this.pretty && r.slice(-this.newline.length) === this.newline) { - r = r.slice(0, -this.newline.length); - } - return r; - }; - - XMLStringWriter.prototype.attribute = function(att) { - return ' ' + att.name + '="' + att.value + '"'; - }; - - XMLStringWriter.prototype.cdata = function(node, level) { - return this.space(level) + '' + this.newline; - }; - - XMLStringWriter.prototype.comment = function(node, level) { - return this.space(level) + '' + this.newline; - }; - - XMLStringWriter.prototype.declaration = function(node, level) { - var r; - r = this.space(level); - r += ''; - r += this.newline; - return r; - }; - - XMLStringWriter.prototype.docType = function(node, level) { - var child, i, len, r, ref; - level || (level = 0); - r = this.space(level); - r += ' 0) { - r += ' ['; - r += this.newline; - ref = node.children; - for (i = 0, len = ref.length; i < len; i++) { - child = ref[i]; - r += (function() { - switch (false) { - case !(child instanceof XMLDTDAttList): - return this.dtdAttList(child, level + 1); - case !(child instanceof XMLDTDElement): - return this.dtdElement(child, level + 1); - case !(child instanceof XMLDTDEntity): - return this.dtdEntity(child, level + 1); - case !(child instanceof XMLDTDNotation): - return this.dtdNotation(child, level + 1); - case !(child instanceof XMLCData): - return this.cdata(child, level + 1); - case !(child instanceof XMLComment): - return this.comment(child, level + 1); - case !(child instanceof XMLProcessingInstruction): - return this.processingInstruction(child, level + 1); - default: - throw new Error("Unknown DTD node type: " + child.constructor.name); - } - }).call(this); - } - r += ']'; - } - r += this.spacebeforeslash + '>'; - r += this.newline; - return r; - }; - - XMLStringWriter.prototype.element = function(node, level) { - var att, child, i, j, len, len1, name, r, ref, ref1, ref2, space, textispresentwasset; - level || (level = 0); - textispresentwasset = false; - if (this.textispresent) { - this.newline = ''; - this.pretty = false; - } else { - this.newline = this.newlinedefault; - this.pretty = this.prettydefault; - } - space = this.space(level); - r = ''; - r += space + '<' + node.name; - ref = node.attributes; - for (name in ref) { - if (!hasProp.call(ref, name)) continue; - att = ref[name]; - r += this.attribute(att); - } - if (node.children.length === 0 || node.children.every(function(e) { - return e.value === ''; - })) { - if (this.allowEmpty) { - r += '>' + this.newline; - } else { - r += this.spacebeforeslash + '/>' + this.newline; - } - } else if (this.pretty && node.children.length === 1 && (node.children[0].value != null)) { - r += '>'; - r += node.children[0].value; - r += '' + this.newline; - } else { - if (this.dontprettytextnodes) { - ref1 = node.children; - for (i = 0, len = ref1.length; i < len; i++) { - child = ref1[i]; - if (child.value != null) { - this.textispresent++; - textispresentwasset = true; - break; - } - } - } - if (this.textispresent) { - this.newline = ''; - this.pretty = false; - space = this.space(level); - } - r += '>' + this.newline; - ref2 = node.children; - for (j = 0, len1 = ref2.length; j < len1; j++) { - child = ref2[j]; - r += (function() { - switch (false) { - case !(child instanceof XMLCData): - return this.cdata(child, level + 1); - case !(child instanceof XMLComment): - return this.comment(child, level + 1); - case !(child instanceof XMLElement): - return this.element(child, level + 1); - case !(child instanceof XMLRaw): - return this.raw(child, level + 1); - case !(child instanceof XMLText): - return this.text(child, level + 1); - case !(child instanceof XMLProcessingInstruction): - return this.processingInstruction(child, level + 1); - default: - throw new Error("Unknown XML node type: " + child.constructor.name); - } - }).call(this); - } - if (textispresentwasset) { - this.textispresent--; - } - if (!this.textispresent) { - this.newline = this.newlinedefault; - this.pretty = this.prettydefault; - } - r += space + '' + this.newline; - } - return r; - }; - - XMLStringWriter.prototype.processingInstruction = function(node, level) { - var r; - r = this.space(level) + '' + this.newline; - return r; - }; - - XMLStringWriter.prototype.raw = function(node, level) { - return this.space(level) + node.value + this.newline; - }; - - XMLStringWriter.prototype.text = function(node, level) { - return this.space(level) + node.value + this.newline; - }; + // By the invariants, start <= length-1, so there is something left over. + // It is either the whole string or a part starting from non-whitespace. + result += '\n'; + // Insert a break if the remainder is too long and there is a break available. + if (line.length - start > width && curr > start) { + result += line.slice(start, curr) + '\n' + line.slice(curr + 1); + } else { + result += line.slice(start); + } - XMLStringWriter.prototype.dtdAttList = function(node, level) { - var r; - r = this.space(level) + '' + this.newline; - return r; - }; + return result.slice(1); // drop extra \n joiner +} - XMLStringWriter.prototype.dtdElement = function(node, level) { - return this.space(level) + '' + this.newline; - }; +// Escapes a double-quoted string. +function escapeString(string) { + var result = ''; + var char = 0; + var escapeSeq; - XMLStringWriter.prototype.dtdEntity = function(node, level) { - var r; - r = this.space(level) + '' + this.newline; - return r; - }; - - XMLStringWriter.prototype.dtdNotation = function(node, level) { - var r; - r = this.space(level) + '' + this.newline; - return r; - }; - - XMLStringWriter.prototype.openNode = function(node, level) { - var att, name, r, ref; - level || (level = 0); - if (node instanceof XMLElement) { - r = this.space(level) + '<' + node.name; - ref = node.attributes; - for (name in ref) { - if (!hasProp.call(ref, name)) continue; - att = ref[name]; - r += this.attribute(att); - } - r += (node.children ? '>' : '/>') + this.newline; - return r; - } else { - r = this.space(level) + '') + this.newline; - return r; - } - }; + for (var i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) { + char = codePointAt(string, i); + escapeSeq = ESCAPE_SEQUENCES[char]; - XMLStringWriter.prototype.closeNode = function(node, level) { - level || (level = 0); - switch (false) { - case !(node instanceof XMLElement): - return this.space(level) + '' + this.newline; - case !(node instanceof XMLDocType): - return this.space(level) + ']>' + this.newline; - } - }; + if (!escapeSeq && isPrintable(char)) { + result += string[i]; + if (char >= 0x10000) result += string[i + 1]; + } else { + result += escapeSeq || encodeHex(char); + } + } - return XMLStringWriter; + return result; +} - })(XMLWriterBase); +function writeFlowSequence(state, level, object) { + var _result = '', + _tag = state.tag, + index, + length, + value; -}).call(this); + for (index = 0, length = object.length; index < length; index += 1) { + value = object[index]; + if (state.replacer) { + value = state.replacer.call(object, String(index), value); + } -/***/ }), + // Write only valid elements, put null instead of invalid elements. + if (writeNode(state, level, value, false, false) || + (typeof value === 'undefined' && + writeNode(state, level, null, false, false))) { -/***/ 2751: -/***/ (function(module, __unusedexports, __webpack_require__) { + if (_result !== '') _result += ',' + (!state.condenseFlow ? ' ' : ''); + _result += state.dump; + } + } -var AWS = __webpack_require__(395); -__webpack_require__(3711); -var inherit = AWS.util.inherit; + state.tag = _tag; + state.dump = '[' + _result + ']'; +} -/** - * Represents a metadata service available on EC2 instances. Using the - * {request} method, you can receieve metadata about any available resource - * on the metadata service. - * - * You can disable the use of the IMDS by setting the AWS_EC2_METADATA_DISABLED - * environment variable to a truthy value. - * - * @!attribute [r] httpOptions - * @return [map] a map of options to pass to the underlying HTTP request: - * - * * **timeout** (Number) — a timeout value in milliseconds to wait - * before aborting the connection. Set to 0 for no timeout. - * - * @!macro nobrowser - */ -AWS.MetadataService = inherit({ - /** - * @return [String] the hostname of the instance metadata service - */ - host: '169.254.169.254', +function writeBlockSequence(state, level, object, compact) { + var _result = '', + _tag = state.tag, + index, + length, + value; - /** - * @!ignore - */ + for (index = 0, length = object.length; index < length; index += 1) { + value = object[index]; - /** - * Default HTTP options. By default, the metadata service is set to not - * timeout on long requests. This means that on non-EC2 machines, this - * request will never return. If you are calling this operation from an - * environment that may not always run on EC2, set a `timeout` value so - * the SDK will abort the request after a given number of milliseconds. - */ - httpOptions: { timeout: 0 }, + if (state.replacer) { + value = state.replacer.call(object, String(index), value); + } - /** - * when enabled, metadata service will not fetch token - */ - disableFetchToken: false, + // Write only valid elements, put null instead of invalid elements. + if (writeNode(state, level + 1, value, true, true, false, true) || + (typeof value === 'undefined' && + writeNode(state, level + 1, null, true, true, false, true))) { - /** - * Creates a new MetadataService object with a given set of options. - * - * @option options host [String] the hostname of the instance metadata - * service - * @option options httpOptions [map] a map of options to pass to the - * underlying HTTP request: - * - * * **timeout** (Number) — a timeout value in milliseconds to wait - * before aborting the connection. Set to 0 for no timeout. - * @option options maxRetries [Integer] the maximum number of retries to - * perform for timeout errors - * @option options retryDelayOptions [map] A set of options to configure the - * retry delay on retryable errors. See AWS.Config for details. - */ - constructor: function MetadataService(options) { - AWS.util.update(this, options); - }, + if (!compact || _result !== '') { + _result += generateNextLine(state, level); + } - /** - * Sends a request to the instance metadata service for a given resource. - * - * @param path [String] the path of the resource to get - * - * @param options [map] an optional map used to make request - * - * * **method** (String) — HTTP request method - * - * * **headers** (map) — a map of response header keys and their respective values - * - * @callback callback function(err, data) - * Called when a response is available from the service. - * @param err [Error, null] if an error occurred, this value will be set - * @param data [String, null] if the request was successful, the body of - * the response - */ - request: function request(path, options, callback) { - if (arguments.length === 2) { - callback = options; - options = {}; - } + if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { + _result += '-'; + } else { + _result += '- '; + } - if (process.env[AWS.util.imdsDisabledEnv]) { - callback(new Error('EC2 Instance Metadata Service access disabled')); - return; + _result += state.dump; } + } - path = path || '/'; - var httpRequest = new AWS.HttpRequest('http://' + this.host + path); - httpRequest.method = options.method || 'GET'; - if (options.headers) { - httpRequest.headers = options.headers; - } - AWS.util.handleRequestWithRetries(httpRequest, this, callback); - }, + state.tag = _tag; + state.dump = _result || '[]'; // Empty sequence if no valid values. +} - /** - * @api private - */ - loadCredentialsCallbacks: [], +function writeFlowMapping(state, level, object) { + var _result = '', + _tag = state.tag, + objectKeyList = Object.keys(object), + index, + length, + objectKey, + objectValue, + pairBuffer; - /** - * Fetches metadata token used for getting credentials - * - * @api private - * @callback callback function(err, token) - * Called when token is loaded from the resource - */ - fetchMetadataToken: function fetchMetadataToken(callback) { - var self = this; - var tokenFetchPath = '/latest/api/token'; - self.request( - tokenFetchPath, - { - 'method': 'PUT', - 'headers': { - 'x-aws-ec2-metadata-token-ttl-seconds': '21600' - } - }, - callback - ); - }, + for (index = 0, length = objectKeyList.length; index < length; index += 1) { - /** - * Fetches credentials - * - * @api private - * @callback cb function(err, creds) - * Called when credentials are loaded from the resource - */ - fetchCredentials: function fetchCredentials(options, cb) { - var self = this; - var basePath = '/latest/meta-data/iam/security-credentials/'; + pairBuffer = ''; + if (_result !== '') pairBuffer += ', '; - self.request(basePath, options, function (err, roleName) { - if (err) { - self.disableFetchToken = !(err.statusCode === 401); - cb(AWS.util.error( - err, - { - message: 'EC2 Metadata roleName request returned error' - } - )); - return; - } - roleName = roleName.split('\n')[0]; // grab first (and only) role - self.request(basePath + roleName, options, function (credErr, credData) { - if (credErr) { - self.disableFetchToken = !(credErr.statusCode === 401); - cb(AWS.util.error( - credErr, - { - message: 'EC2 Metadata creds request returned error' - } - )); - return; - } - try { - var credentials = JSON.parse(credData); - cb(null, credentials); - } catch (parseError) { - cb(parseError); - } - }); - }); - }, + if (state.condenseFlow) pairBuffer += '"'; - /** - * Loads a set of credentials stored in the instance metadata service - * - * @api private - * @callback callback function(err, credentials) - * Called when credentials are loaded from the resource - * @param err [Error] if an error occurred, this value will be set - * @param credentials [Object] the raw JSON object containing all - * metadata from the credentials resource - */ - loadCredentials: function loadCredentials(callback) { - var self = this; - self.loadCredentialsCallbacks.push(callback); - if (self.loadCredentialsCallbacks.length > 1) { return; } + objectKey = objectKeyList[index]; + objectValue = object[objectKey]; - function callbacks(err, creds) { - var cb; - while ((cb = self.loadCredentialsCallbacks.shift()) !== undefined) { - cb(err, creds); - } + if (state.replacer) { + objectValue = state.replacer.call(object, objectKey, objectValue); } - if (self.disableFetchToken) { - self.fetchCredentials({}, callbacks); - } else { - self.fetchMetadataToken(function(tokenError, token) { - if (tokenError) { - if (tokenError.code === 'TimeoutError') { - self.disableFetchToken = true; - } else if (tokenError.retryable === true) { - callbacks(AWS.util.error( - tokenError, - { - message: 'EC2 Metadata token request returned error' - } - )); - return; - } else if (tokenError.statusCode === 400) { - callbacks(AWS.util.error( - tokenError, - { - message: 'EC2 Metadata token request returned 400' - } - )); - return; - } - } - var options = {}; - if (token) { - options.headers = { - 'x-aws-ec2-metadata-token': token - }; - } - self.fetchCredentials(options, callbacks); - }); - + if (!writeNode(state, level, objectKey, false, false)) { + continue; // Skip this pair because of invalid key; } - } -}); -/** - * @api private - */ -module.exports = AWS.MetadataService; + if (state.dump.length > 1024) pairBuffer += '? '; + pairBuffer += state.dump + (state.condenseFlow ? '"' : '') + ':' + (state.condenseFlow ? '' : ' '); -/***/ }), + if (!writeNode(state, level, objectValue, false, false)) { + continue; // Skip this pair because of invalid value. + } -/***/ 2760: -/***/ (function(module) { + pairBuffer += state.dump; -module.exports = {"version":"2.0","metadata":{"apiVersion":"2017-10-15","endpointPrefix":"api.pricing","jsonVersion":"1.1","protocol":"json","serviceAbbreviation":"AWS Pricing","serviceFullName":"AWS Price List Service","serviceId":"Pricing","signatureVersion":"v4","signingName":"pricing","targetPrefix":"AWSPriceListService","uid":"pricing-2017-10-15"},"operations":{"DescribeServices":{"input":{"type":"structure","members":{"ServiceCode":{},"FormatVersion":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"Services":{"type":"list","member":{"type":"structure","members":{"ServiceCode":{},"AttributeNames":{"type":"list","member":{}}}}},"FormatVersion":{},"NextToken":{}}}},"GetAttributeValues":{"input":{"type":"structure","required":["ServiceCode","AttributeName"],"members":{"ServiceCode":{},"AttributeName":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"AttributeValues":{"type":"list","member":{"type":"structure","members":{"Value":{}}}},"NextToken":{}}}},"GetProducts":{"input":{"type":"structure","members":{"ServiceCode":{},"Filters":{"type":"list","member":{"type":"structure","required":["Type","Field","Value"],"members":{"Type":{},"Field":{},"Value":{}}}},"FormatVersion":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"FormatVersion":{},"PriceList":{"type":"list","member":{"jsonvalue":true}},"NextToken":{}}}}},"shapes":{}}; + // Both key and value are valid. + _result += pairBuffer; + } -/***/ }), + state.tag = _tag; + state.dump = '{' + _result + '}'; +} -/***/ 2766: -/***/ (function(module) { +function writeBlockMapping(state, level, object, compact) { + var _result = '', + _tag = state.tag, + objectKeyList = Object.keys(object), + index, + length, + objectKey, + objectValue, + explicitPair, + pairBuffer; -module.exports = {"version":"2.0","metadata":{"apiVersion":"2017-09-30","endpointPrefix":"kinesisvideo","protocol":"rest-json","serviceAbbreviation":"Kinesis Video","serviceFullName":"Amazon Kinesis Video Streams","serviceId":"Kinesis Video","signatureVersion":"v4","uid":"kinesisvideo-2017-09-30"},"operations":{"CreateSignalingChannel":{"http":{"requestUri":"/createSignalingChannel"},"input":{"type":"structure","required":["ChannelName"],"members":{"ChannelName":{},"ChannelType":{},"SingleMasterConfiguration":{"shape":"S4"},"Tags":{"type":"list","member":{"shape":"S7"}}}},"output":{"type":"structure","members":{"ChannelARN":{}}}},"CreateStream":{"http":{"requestUri":"/createStream"},"input":{"type":"structure","required":["StreamName"],"members":{"DeviceName":{},"StreamName":{},"MediaType":{},"KmsKeyId":{},"DataRetentionInHours":{"type":"integer"},"Tags":{"shape":"Si"}}},"output":{"type":"structure","members":{"StreamARN":{}}}},"DeleteSignalingChannel":{"http":{"requestUri":"/deleteSignalingChannel"},"input":{"type":"structure","required":["ChannelARN"],"members":{"ChannelARN":{},"CurrentVersion":{}}},"output":{"type":"structure","members":{}}},"DeleteStream":{"http":{"requestUri":"/deleteStream"},"input":{"type":"structure","required":["StreamARN"],"members":{"StreamARN":{},"CurrentVersion":{}}},"output":{"type":"structure","members":{}}},"DescribeSignalingChannel":{"http":{"requestUri":"/describeSignalingChannel"},"input":{"type":"structure","members":{"ChannelName":{},"ChannelARN":{}}},"output":{"type":"structure","members":{"ChannelInfo":{"shape":"Sr"}}}},"DescribeStream":{"http":{"requestUri":"/describeStream"},"input":{"type":"structure","members":{"StreamName":{},"StreamARN":{}}},"output":{"type":"structure","members":{"StreamInfo":{"shape":"Sw"}}}},"GetDataEndpoint":{"http":{"requestUri":"/getDataEndpoint"},"input":{"type":"structure","required":["APIName"],"members":{"StreamName":{},"StreamARN":{},"APIName":{}}},"output":{"type":"structure","members":{"DataEndpoint":{}}}},"GetSignalingChannelEndpoint":{"http":{"requestUri":"/getSignalingChannelEndpoint"},"input":{"type":"structure","required":["ChannelARN"],"members":{"ChannelARN":{},"SingleMasterChannelEndpointConfiguration":{"type":"structure","members":{"Protocols":{"type":"list","member":{}},"Role":{}}}}},"output":{"type":"structure","members":{"ResourceEndpointList":{"type":"list","member":{"type":"structure","members":{"Protocol":{},"ResourceEndpoint":{}}}}}}},"ListSignalingChannels":{"http":{"requestUri":"/listSignalingChannels"},"input":{"type":"structure","members":{"MaxResults":{"type":"integer"},"NextToken":{},"ChannelNameCondition":{"type":"structure","members":{"ComparisonOperator":{},"ComparisonValue":{}}}}},"output":{"type":"structure","members":{"ChannelInfoList":{"type":"list","member":{"shape":"Sr"}},"NextToken":{}}}},"ListStreams":{"http":{"requestUri":"/listStreams"},"input":{"type":"structure","members":{"MaxResults":{"type":"integer"},"NextToken":{},"StreamNameCondition":{"type":"structure","members":{"ComparisonOperator":{},"ComparisonValue":{}}}}},"output":{"type":"structure","members":{"StreamInfoList":{"type":"list","member":{"shape":"Sw"}},"NextToken":{}}}},"ListTagsForResource":{"http":{"requestUri":"/ListTagsForResource"},"input":{"type":"structure","required":["ResourceARN"],"members":{"NextToken":{},"ResourceARN":{}}},"output":{"type":"structure","members":{"NextToken":{},"Tags":{"shape":"Si"}}}},"ListTagsForStream":{"http":{"requestUri":"/listTagsForStream"},"input":{"type":"structure","members":{"NextToken":{},"StreamARN":{},"StreamName":{}}},"output":{"type":"structure","members":{"NextToken":{},"Tags":{"shape":"Si"}}}},"TagResource":{"http":{"requestUri":"/TagResource"},"input":{"type":"structure","required":["ResourceARN","Tags"],"members":{"ResourceARN":{},"Tags":{"type":"list","member":{"shape":"S7"}}}},"output":{"type":"structure","members":{}}},"TagStream":{"http":{"requestUri":"/tagStream"},"input":{"type":"structure","required":["Tags"],"members":{"StreamARN":{},"StreamName":{},"Tags":{"shape":"Si"}}},"output":{"type":"structure","members":{}}},"UntagResource":{"http":{"requestUri":"/UntagResource"},"input":{"type":"structure","required":["ResourceARN","TagKeyList"],"members":{"ResourceARN":{},"TagKeyList":{"shape":"S1v"}}},"output":{"type":"structure","members":{}}},"UntagStream":{"http":{"requestUri":"/untagStream"},"input":{"type":"structure","required":["TagKeyList"],"members":{"StreamARN":{},"StreamName":{},"TagKeyList":{"shape":"S1v"}}},"output":{"type":"structure","members":{}}},"UpdateDataRetention":{"http":{"requestUri":"/updateDataRetention"},"input":{"type":"structure","required":["CurrentVersion","Operation","DataRetentionChangeInHours"],"members":{"StreamName":{},"StreamARN":{},"CurrentVersion":{},"Operation":{},"DataRetentionChangeInHours":{"type":"integer"}}},"output":{"type":"structure","members":{}}},"UpdateSignalingChannel":{"http":{"requestUri":"/updateSignalingChannel"},"input":{"type":"structure","required":["ChannelARN","CurrentVersion"],"members":{"ChannelARN":{},"CurrentVersion":{},"SingleMasterConfiguration":{"shape":"S4"}}},"output":{"type":"structure","members":{}}},"UpdateStream":{"http":{"requestUri":"/updateStream"},"input":{"type":"structure","required":["CurrentVersion"],"members":{"StreamName":{},"StreamARN":{},"CurrentVersion":{},"DeviceName":{},"MediaType":{}}},"output":{"type":"structure","members":{}}}},"shapes":{"S4":{"type":"structure","members":{"MessageTtlSeconds":{"type":"integer"}}},"S7":{"type":"structure","required":["Key","Value"],"members":{"Key":{},"Value":{}}},"Si":{"type":"map","key":{},"value":{}},"Sr":{"type":"structure","members":{"ChannelName":{},"ChannelARN":{},"ChannelType":{},"ChannelStatus":{},"CreationTime":{"type":"timestamp"},"SingleMasterConfiguration":{"shape":"S4"},"Version":{}}},"Sw":{"type":"structure","members":{"DeviceName":{},"StreamName":{},"StreamARN":{},"MediaType":{},"KmsKeyId":{},"Version":{},"Status":{},"CreationTime":{"type":"timestamp"},"DataRetentionInHours":{"type":"integer"}}},"S1v":{"type":"list","member":{}}}}; + // Allow sorting keys so that the output file is deterministic + if (state.sortKeys === true) { + // Default sorting + objectKeyList.sort(); + } else if (typeof state.sortKeys === 'function') { + // Custom sort function + objectKeyList.sort(state.sortKeys); + } else if (state.sortKeys) { + // Something is wrong + throw new YAMLException('sortKeys must be a boolean or a function'); + } -/***/ }), + for (index = 0, length = objectKeyList.length; index < length; index += 1) { + pairBuffer = ''; -/***/ 2802: -/***/ (function(__unusedmodule, exports) { + if (!compact || _result !== '') { + pairBuffer += generateNextLine(state, level); + } -(function(exports) { - "use strict"; + objectKey = objectKeyList[index]; + objectValue = object[objectKey]; - function isArray(obj) { - if (obj !== null) { - return Object.prototype.toString.call(obj) === "[object Array]"; - } else { - return false; + if (state.replacer) { + objectValue = state.replacer.call(object, objectKey, objectValue); } - } - function isObject(obj) { - if (obj !== null) { - return Object.prototype.toString.call(obj) === "[object Object]"; - } else { - return false; + if (!writeNode(state, level + 1, objectKey, true, true, true)) { + continue; // Skip this pair because of invalid key. } - } - function strictDeepEqual(first, second) { - // Check the scalar case first. - if (first === second) { - return true; - } + explicitPair = (state.tag !== null && state.tag !== '?') || + (state.dump && state.dump.length > 1024); - // Check if they are the same type. - var firstType = Object.prototype.toString.call(first); - if (firstType !== Object.prototype.toString.call(second)) { - return false; - } - // We know that first and second have the same type so we can just check the - // first type from now on. - if (isArray(first) === true) { - // Short circuit if they're not the same length; - if (first.length !== second.length) { - return false; - } - for (var i = 0; i < first.length; i++) { - if (strictDeepEqual(first[i], second[i]) === false) { - return false; - } + if (explicitPair) { + if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { + pairBuffer += '?'; + } else { + pairBuffer += '? '; } - return true; } - if (isObject(first) === true) { - // An object is equal if it has the same key/value pairs. - var keysSeen = {}; - for (var key in first) { - if (hasOwnProperty.call(first, key)) { - if (strictDeepEqual(first[key], second[key]) === false) { - return false; - } - keysSeen[key] = true; + + pairBuffer += state.dump; + + if (explicitPair) { + pairBuffer += generateNextLine(state, level); + } + + if (!writeNode(state, level + 1, objectValue, true, explicitPair)) { + continue; // Skip this pair because of invalid value. + } + + if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { + pairBuffer += ':'; + } else { + pairBuffer += ': '; + } + + pairBuffer += state.dump; + + // Both key and value are valid. + _result += pairBuffer; + } + + state.tag = _tag; + state.dump = _result || '{}'; // Empty mapping if no valid pairs. +} + +function detectType(state, object, explicit) { + var _result, typeList, index, length, type, style; + + typeList = explicit ? state.explicitTypes : state.implicitTypes; + + for (index = 0, length = typeList.length; index < length; index += 1) { + type = typeList[index]; + + if ((type.instanceOf || type.predicate) && + (!type.instanceOf || ((typeof object === 'object') && (object instanceof type.instanceOf))) && + (!type.predicate || type.predicate(object))) { + + if (explicit) { + if (type.multi && type.representName) { + state.tag = type.representName(object); + } else { + state.tag = type.tag; } + } else { + state.tag = '?'; } - // Now check that there aren't any keys in second that weren't - // in first. - for (var key2 in second) { - if (hasOwnProperty.call(second, key2)) { - if (keysSeen[key2] !== true) { - return false; - } + + if (type.represent) { + style = state.styleMap[type.tag] || type.defaultStyle; + + if (_toString.call(type.represent) === '[object Function]') { + _result = type.represent(object, style); + } else if (_hasOwnProperty.call(type.represent, style)) { + _result = type.represent[style](object, style); + } else { + throw new YAMLException('!<' + type.tag + '> tag resolver accepts not "' + style + '" style'); } + + state.dump = _result; } + return true; } - return false; } - function isFalse(obj) { - // From the spec: - // A false value corresponds to the following values: - // Empty list - // Empty object - // Empty string - // False boolean - // null value + return false; +} - // First check the scalar values. - if (obj === "" || obj === false || obj === null) { - return true; - } else if (isArray(obj) && obj.length === 0) { - // Check for an empty array. - return true; - } else if (isObject(obj)) { - // Check for an empty object. - for (var key in obj) { - // If there are any keys, then - // the object is not empty so the object - // is not false. - if (obj.hasOwnProperty(key)) { - return false; - } +// Serializes `object` and writes it to global `result`. +// Returns true on success, or false on invalid object. +// +function writeNode(state, level, object, block, compact, iskey, isblockseq) { + state.tag = null; + state.dump = object; + + if (!detectType(state, object, false)) { + detectType(state, object, true); + } + + var type = _toString.call(state.dump); + var inblock = block; + var tagStr; + + if (block) { + block = (state.flowLevel < 0 || state.flowLevel > level); + } + + var objectOrArray = type === '[object Object]' || type === '[object Array]', + duplicateIndex, + duplicate; + + if (objectOrArray) { + duplicateIndex = state.duplicates.indexOf(object); + duplicate = duplicateIndex !== -1; + } + + if ((state.tag !== null && state.tag !== '?') || duplicate || (state.indent !== 2 && level > 0)) { + compact = false; + } + + if (duplicate && state.usedDuplicates[duplicateIndex]) { + state.dump = '*ref_' + duplicateIndex; + } else { + if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) { + state.usedDuplicates[duplicateIndex] = true; + } + if (type === '[object Object]') { + if (block && (Object.keys(state.dump).length !== 0)) { + writeBlockMapping(state, level, state.dump, compact); + if (duplicate) { + state.dump = '&ref_' + duplicateIndex + state.dump; } - return true; + } else { + writeFlowMapping(state, level, state.dump); + if (duplicate) { + state.dump = '&ref_' + duplicateIndex + ' ' + state.dump; + } + } + } else if (type === '[object Array]') { + if (block && (state.dump.length !== 0)) { + if (state.noArrayIndent && !isblockseq && level > 0) { + writeBlockSequence(state, level - 1, state.dump, compact); + } else { + writeBlockSequence(state, level, state.dump, compact); + } + if (duplicate) { + state.dump = '&ref_' + duplicateIndex + state.dump; + } + } else { + writeFlowSequence(state, level, state.dump); + if (duplicate) { + state.dump = '&ref_' + duplicateIndex + ' ' + state.dump; + } + } + } else if (type === '[object String]') { + if (state.tag !== '?') { + writeScalar(state, state.dump, level, iskey, inblock); + } + } else if (type === '[object Undefined]') { + return false; } else { - return false; + if (state.skipInvalid) return false; + throw new YAMLException('unacceptable kind of an object to dump ' + type); } - } - function objValues(obj) { - var keys = Object.keys(obj); - var values = []; - for (var i = 0; i < keys.length; i++) { - values.push(obj[keys[i]]); + if (state.tag !== null && state.tag !== '?') { + // Need to encode all characters except those allowed by the spec: + // + // [35] ns-dec-digit ::= [#x30-#x39] /* 0-9 */ + // [36] ns-hex-digit ::= ns-dec-digit + // | [#x41-#x46] /* A-F */ | [#x61-#x66] /* a-f */ + // [37] ns-ascii-letter ::= [#x41-#x5A] /* A-Z */ | [#x61-#x7A] /* a-z */ + // [38] ns-word-char ::= ns-dec-digit | ns-ascii-letter | “-” + // [39] ns-uri-char ::= “%” ns-hex-digit ns-hex-digit | ns-word-char | “#” + // | “;” | “/” | “?” | “:” | “@” | “&” | “=” | “+” | “$” | “,” + // | “_” | “.” | “!” | “~” | “*” | “'” | “(” | “)” | “[” | “]” + // + // Also need to encode '!' because it has special meaning (end of tag prefix). + // + tagStr = encodeURI( + state.tag[0] === '!' ? state.tag.slice(1) : state.tag + ).replace(/!/g, '%21'); + + if (state.tag[0] === '!') { + tagStr = '!' + tagStr; + } else if (tagStr.slice(0, 18) === 'tag:yaml.org,2002:') { + tagStr = '!!' + tagStr.slice(18); + } else { + tagStr = '!<' + tagStr + '>'; + } + + state.dump = tagStr + ' ' + state.dump; } - return values; } - function merge(a, b) { - var merged = {}; - for (var key in a) { - merged[key] = a[key]; + return true; +} + +function getDuplicateReferences(object, state) { + var objects = [], + duplicatesIndexes = [], + index, + length; + + inspectNode(object, objects, duplicatesIndexes); + + for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) { + state.duplicates.push(objects[duplicatesIndexes[index]]); + } + state.usedDuplicates = new Array(length); +} + +function inspectNode(object, objects, duplicatesIndexes) { + var objectKeyList, + index, + length; + + if (object !== null && typeof object === 'object') { + index = objects.indexOf(object); + if (index !== -1) { + if (duplicatesIndexes.indexOf(index) === -1) { + duplicatesIndexes.push(index); } - for (var key2 in b) { - merged[key2] = b[key2]; + } else { + objects.push(object); + + if (Array.isArray(object)) { + for (index = 0, length = object.length; index < length; index += 1) { + inspectNode(object[index], objects, duplicatesIndexes); + } + } else { + objectKeyList = Object.keys(object); + + for (index = 0, length = objectKeyList.length; index < length; index += 1) { + inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes); + } } - return merged; + } } +} - var trimLeft; - if (typeof String.prototype.trimLeft === "function") { - trimLeft = function(str) { - return str.trimLeft(); - }; - } else { - trimLeft = function(str) { - return str.match(/^\s*(.*)/)[1]; - }; - } - - // Type constants used to define functions. - var TYPE_NUMBER = 0; - var TYPE_ANY = 1; - var TYPE_STRING = 2; - var TYPE_ARRAY = 3; - var TYPE_OBJECT = 4; - var TYPE_BOOLEAN = 5; - var TYPE_EXPREF = 6; - var TYPE_NULL = 7; - var TYPE_ARRAY_NUMBER = 8; - var TYPE_ARRAY_STRING = 9; - - var TOK_EOF = "EOF"; - var TOK_UNQUOTEDIDENTIFIER = "UnquotedIdentifier"; - var TOK_QUOTEDIDENTIFIER = "QuotedIdentifier"; - var TOK_RBRACKET = "Rbracket"; - var TOK_RPAREN = "Rparen"; - var TOK_COMMA = "Comma"; - var TOK_COLON = "Colon"; - var TOK_RBRACE = "Rbrace"; - var TOK_NUMBER = "Number"; - var TOK_CURRENT = "Current"; - var TOK_EXPREF = "Expref"; - var TOK_PIPE = "Pipe"; - var TOK_OR = "Or"; - var TOK_AND = "And"; - var TOK_EQ = "EQ"; - var TOK_GT = "GT"; - var TOK_LT = "LT"; - var TOK_GTE = "GTE"; - var TOK_LTE = "LTE"; - var TOK_NE = "NE"; - var TOK_FLATTEN = "Flatten"; - var TOK_STAR = "Star"; - var TOK_FILTER = "Filter"; - var TOK_DOT = "Dot"; - var TOK_NOT = "Not"; - var TOK_LBRACE = "Lbrace"; - var TOK_LBRACKET = "Lbracket"; - var TOK_LPAREN= "Lparen"; - var TOK_LITERAL= "Literal"; - - // The "&", "[", "<", ">" tokens - // are not in basicToken because - // there are two token variants - // ("&&", "[?", "<=", ">="). This is specially handled - // below. - - var basicTokens = { - ".": TOK_DOT, - "*": TOK_STAR, - ",": TOK_COMMA, - ":": TOK_COLON, - "{": TOK_LBRACE, - "}": TOK_RBRACE, - "]": TOK_RBRACKET, - "(": TOK_LPAREN, - ")": TOK_RPAREN, - "@": TOK_CURRENT - }; +function dump(input, options) { + options = options || {}; - var operatorStartToken = { - "<": true, - ">": true, - "=": true, - "!": true - }; + var state = new State(options); - var skipChars = { - " ": true, - "\t": true, - "\n": true - }; + if (!state.noRefs) getDuplicateReferences(input, state); + var value = input; - function isAlpha(ch) { - return (ch >= "a" && ch <= "z") || - (ch >= "A" && ch <= "Z") || - ch === "_"; - } - - function isNum(ch) { - return (ch >= "0" && ch <= "9") || - ch === "-"; - } - function isAlphaNum(ch) { - return (ch >= "a" && ch <= "z") || - (ch >= "A" && ch <= "Z") || - (ch >= "0" && ch <= "9") || - ch === "_"; - } - - function Lexer() { - } - Lexer.prototype = { - tokenize: function(stream) { - var tokens = []; - this._current = 0; - var start; - var identifier; - var token; - while (this._current < stream.length) { - if (isAlpha(stream[this._current])) { - start = this._current; - identifier = this._consumeUnquotedIdentifier(stream); - tokens.push({type: TOK_UNQUOTEDIDENTIFIER, - value: identifier, - start: start}); - } else if (basicTokens[stream[this._current]] !== undefined) { - tokens.push({type: basicTokens[stream[this._current]], - value: stream[this._current], - start: this._current}); - this._current++; - } else if (isNum(stream[this._current])) { - token = this._consumeNumber(stream); - tokens.push(token); - } else if (stream[this._current] === "[") { - // No need to increment this._current. This happens - // in _consumeLBracket - token = this._consumeLBracket(stream); - tokens.push(token); - } else if (stream[this._current] === "\"") { - start = this._current; - identifier = this._consumeQuotedIdentifier(stream); - tokens.push({type: TOK_QUOTEDIDENTIFIER, - value: identifier, - start: start}); - } else if (stream[this._current] === "'") { - start = this._current; - identifier = this._consumeRawStringLiteral(stream); - tokens.push({type: TOK_LITERAL, - value: identifier, - start: start}); - } else if (stream[this._current] === "`") { - start = this._current; - var literal = this._consumeLiteral(stream); - tokens.push({type: TOK_LITERAL, - value: literal, - start: start}); - } else if (operatorStartToken[stream[this._current]] !== undefined) { - tokens.push(this._consumeOperator(stream)); - } else if (skipChars[stream[this._current]] !== undefined) { - // Ignore whitespace. - this._current++; - } else if (stream[this._current] === "&") { - start = this._current; - this._current++; - if (stream[this._current] === "&") { - this._current++; - tokens.push({type: TOK_AND, value: "&&", start: start}); - } else { - tokens.push({type: TOK_EXPREF, value: "&", start: start}); - } - } else if (stream[this._current] === "|") { - start = this._current; - this._current++; - if (stream[this._current] === "|") { - this._current++; - tokens.push({type: TOK_OR, value: "||", start: start}); - } else { - tokens.push({type: TOK_PIPE, value: "|", start: start}); - } - } else { - var error = new Error("Unknown character:" + stream[this._current]); - error.name = "LexerError"; - throw error; - } - } - return tokens; - }, + if (state.replacer) { + value = state.replacer.call({ '': value }, '', value); + } - _consumeUnquotedIdentifier: function(stream) { - var start = this._current; - this._current++; - while (this._current < stream.length && isAlphaNum(stream[this._current])) { - this._current++; - } - return stream.slice(start, this._current); - }, + if (writeNode(state, 0, value, true, true)) return state.dump + '\n'; - _consumeQuotedIdentifier: function(stream) { - var start = this._current; - this._current++; - var maxLength = stream.length; - while (stream[this._current] !== "\"" && this._current < maxLength) { - // You can escape a double quote and you can escape an escape. - var current = this._current; - if (stream[current] === "\\" && (stream[current + 1] === "\\" || - stream[current + 1] === "\"")) { - current += 2; - } else { - current++; - } - this._current = current; - } - this._current++; - return JSON.parse(stream.slice(start, this._current)); - }, + return ''; +} - _consumeRawStringLiteral: function(stream) { - var start = this._current; - this._current++; - var maxLength = stream.length; - while (stream[this._current] !== "'" && this._current < maxLength) { - // You can escape a single quote and you can escape an escape. - var current = this._current; - if (stream[current] === "\\" && (stream[current + 1] === "\\" || - stream[current + 1] === "'")) { - current += 2; - } else { - current++; - } - this._current = current; - } - this._current++; - var literal = stream.slice(start + 1, this._current - 1); - return literal.replace("\\'", "'"); - }, +module.exports.dump = dump; - _consumeNumber: function(stream) { - var start = this._current; - this._current++; - var maxLength = stream.length; - while (isNum(stream[this._current]) && this._current < maxLength) { - this._current++; - } - var value = parseInt(stream.slice(start, this._current)); - return {type: TOK_NUMBER, value: value, start: start}; - }, - _consumeLBracket: function(stream) { - var start = this._current; - this._current++; - if (stream[this._current] === "?") { - this._current++; - return {type: TOK_FILTER, value: "[?", start: start}; - } else if (stream[this._current] === "]") { - this._current++; - return {type: TOK_FLATTEN, value: "[]", start: start}; - } else { - return {type: TOK_LBRACKET, value: "[", start: start}; - } - }, +/***/ }), - _consumeOperator: function(stream) { - var start = this._current; - var startingChar = stream[start]; - this._current++; - if (startingChar === "!") { - if (stream[this._current] === "=") { - this._current++; - return {type: TOK_NE, value: "!=", start: start}; - } else { - return {type: TOK_NOT, value: "!", start: start}; - } - } else if (startingChar === "<") { - if (stream[this._current] === "=") { - this._current++; - return {type: TOK_LTE, value: "<=", start: start}; - } else { - return {type: TOK_LT, value: "<", start: start}; - } - } else if (startingChar === ">") { - if (stream[this._current] === "=") { - this._current++; - return {type: TOK_GTE, value: ">=", start: start}; - } else { - return {type: TOK_GT, value: ">", start: start}; - } - } else if (startingChar === "=") { - if (stream[this._current] === "=") { - this._current++; - return {type: TOK_EQ, value: "==", start: start}; - } - } - }, +/***/ 1248: +/***/ ((module) => { - _consumeLiteral: function(stream) { - this._current++; - var start = this._current; - var maxLength = stream.length; - var literal; - while(stream[this._current] !== "`" && this._current < maxLength) { - // You can escape a literal char or you can escape the escape. - var current = this._current; - if (stream[current] === "\\" && (stream[current + 1] === "\\" || - stream[current + 1] === "`")) { - current += 2; - } else { - current++; - } - this._current = current; - } - var literalString = trimLeft(stream.slice(start, this._current)); - literalString = literalString.replace("\\`", "`"); - if (this._looksLikeJSON(literalString)) { - literal = JSON.parse(literalString); - } else { - // Try to JSON parse it as "" - literal = JSON.parse("\"" + literalString + "\""); - } - // +1 gets us to the ending "`", +1 to move on to the next char. - this._current++; - return literal; - }, +"use strict"; +// YAML error class. http://stackoverflow.com/questions/8458984 +// - _looksLikeJSON: function(literalString) { - var startingChars = "[{\""; - var jsonLiterals = ["true", "false", "null"]; - var numberLooking = "-0123456789"; - - if (literalString === "") { - return false; - } else if (startingChars.indexOf(literalString[0]) >= 0) { - return true; - } else if (jsonLiterals.indexOf(literalString) >= 0) { - return true; - } else if (numberLooking.indexOf(literalString[0]) >= 0) { - try { - JSON.parse(literalString); - return true; - } catch (ex) { - return false; - } - } else { - return false; - } - } - }; - var bindingPower = {}; - bindingPower[TOK_EOF] = 0; - bindingPower[TOK_UNQUOTEDIDENTIFIER] = 0; - bindingPower[TOK_QUOTEDIDENTIFIER] = 0; - bindingPower[TOK_RBRACKET] = 0; - bindingPower[TOK_RPAREN] = 0; - bindingPower[TOK_COMMA] = 0; - bindingPower[TOK_RBRACE] = 0; - bindingPower[TOK_NUMBER] = 0; - bindingPower[TOK_CURRENT] = 0; - bindingPower[TOK_EXPREF] = 0; - bindingPower[TOK_PIPE] = 1; - bindingPower[TOK_OR] = 2; - bindingPower[TOK_AND] = 3; - bindingPower[TOK_EQ] = 5; - bindingPower[TOK_GT] = 5; - bindingPower[TOK_LT] = 5; - bindingPower[TOK_GTE] = 5; - bindingPower[TOK_LTE] = 5; - bindingPower[TOK_NE] = 5; - bindingPower[TOK_FLATTEN] = 9; - bindingPower[TOK_STAR] = 20; - bindingPower[TOK_FILTER] = 21; - bindingPower[TOK_DOT] = 40; - bindingPower[TOK_NOT] = 45; - bindingPower[TOK_LBRACE] = 50; - bindingPower[TOK_LBRACKET] = 55; - bindingPower[TOK_LPAREN] = 60; - - function Parser() { - } - - Parser.prototype = { - parse: function(expression) { - this._loadTokens(expression); - this.index = 0; - var ast = this.expression(0); - if (this._lookahead(0) !== TOK_EOF) { - var t = this._lookaheadToken(0); - var error = new Error( - "Unexpected token type: " + t.type + ", value: " + t.value); - error.name = "ParserError"; - throw error; - } - return ast; - }, - _loadTokens: function(expression) { - var lexer = new Lexer(); - var tokens = lexer.tokenize(expression); - tokens.push({type: TOK_EOF, value: "", start: expression.length}); - this.tokens = tokens; - }, +function formatError(exception, compact) { + var where = '', message = exception.reason || '(unknown reason)'; - expression: function(rbp) { - var leftToken = this._lookaheadToken(0); - this._advance(); - var left = this.nud(leftToken); - var currentToken = this._lookahead(0); - while (rbp < bindingPower[currentToken]) { - this._advance(); - left = this.led(currentToken, left); - currentToken = this._lookahead(0); - } - return left; - }, + if (!exception.mark) return message; - _lookahead: function(number) { - return this.tokens[this.index + number].type; - }, + if (exception.mark.name) { + where += 'in "' + exception.mark.name + '" '; + } - _lookaheadToken: function(number) { - return this.tokens[this.index + number]; - }, + where += '(' + (exception.mark.line + 1) + ':' + (exception.mark.column + 1) + ')'; - _advance: function() { - this.index++; - }, + if (!compact && exception.mark.snippet) { + where += '\n\n' + exception.mark.snippet; + } - nud: function(token) { - var left; - var right; - var expression; - switch (token.type) { - case TOK_LITERAL: - return {type: "Literal", value: token.value}; - case TOK_UNQUOTEDIDENTIFIER: - return {type: "Field", name: token.value}; - case TOK_QUOTEDIDENTIFIER: - var node = {type: "Field", name: token.value}; - if (this._lookahead(0) === TOK_LPAREN) { - throw new Error("Quoted identifier not allowed for function names."); - } else { - return node; - } - break; - case TOK_NOT: - right = this.expression(bindingPower.Not); - return {type: "NotExpression", children: [right]}; - case TOK_STAR: - left = {type: "Identity"}; - right = null; - if (this._lookahead(0) === TOK_RBRACKET) { - // This can happen in a multiselect, - // [a, b, *] - right = {type: "Identity"}; - } else { - right = this._parseProjectionRHS(bindingPower.Star); - } - return {type: "ValueProjection", children: [left, right]}; - case TOK_FILTER: - return this.led(token.type, {type: "Identity"}); - case TOK_LBRACE: - return this._parseMultiselectHash(); - case TOK_FLATTEN: - left = {type: TOK_FLATTEN, children: [{type: "Identity"}]}; - right = this._parseProjectionRHS(bindingPower.Flatten); - return {type: "Projection", children: [left, right]}; - case TOK_LBRACKET: - if (this._lookahead(0) === TOK_NUMBER || this._lookahead(0) === TOK_COLON) { - right = this._parseIndexExpression(); - return this._projectIfSlice({type: "Identity"}, right); - } else if (this._lookahead(0) === TOK_STAR && - this._lookahead(1) === TOK_RBRACKET) { - this._advance(); - this._advance(); - right = this._parseProjectionRHS(bindingPower.Star); - return {type: "Projection", - children: [{type: "Identity"}, right]}; - } else { - return this._parseMultiselectList(); - } - break; - case TOK_CURRENT: - return {type: TOK_CURRENT}; - case TOK_EXPREF: - expression = this.expression(bindingPower.Expref); - return {type: "ExpressionReference", children: [expression]}; - case TOK_LPAREN: - var args = []; - while (this._lookahead(0) !== TOK_RPAREN) { - if (this._lookahead(0) === TOK_CURRENT) { - expression = {type: TOK_CURRENT}; - this._advance(); - } else { - expression = this.expression(0); - } - args.push(expression); - } - this._match(TOK_RPAREN); - return args[0]; - default: - this._errorToken(token); - } - }, + return message + ' ' + where; +} - led: function(tokenName, left) { - var right; - switch(tokenName) { - case TOK_DOT: - var rbp = bindingPower.Dot; - if (this._lookahead(0) !== TOK_STAR) { - right = this._parseDotRHS(rbp); - return {type: "Subexpression", children: [left, right]}; - } else { - // Creating a projection. - this._advance(); - right = this._parseProjectionRHS(rbp); - return {type: "ValueProjection", children: [left, right]}; - } - break; - case TOK_PIPE: - right = this.expression(bindingPower.Pipe); - return {type: TOK_PIPE, children: [left, right]}; - case TOK_OR: - right = this.expression(bindingPower.Or); - return {type: "OrExpression", children: [left, right]}; - case TOK_AND: - right = this.expression(bindingPower.And); - return {type: "AndExpression", children: [left, right]}; - case TOK_LPAREN: - var name = left.name; - var args = []; - var expression, node; - while (this._lookahead(0) !== TOK_RPAREN) { - if (this._lookahead(0) === TOK_CURRENT) { - expression = {type: TOK_CURRENT}; - this._advance(); - } else { - expression = this.expression(0); - } - if (this._lookahead(0) === TOK_COMMA) { - this._match(TOK_COMMA); - } - args.push(expression); - } - this._match(TOK_RPAREN); - node = {type: "Function", name: name, children: args}; - return node; - case TOK_FILTER: - var condition = this.expression(0); - this._match(TOK_RBRACKET); - if (this._lookahead(0) === TOK_FLATTEN) { - right = {type: "Identity"}; - } else { - right = this._parseProjectionRHS(bindingPower.Filter); - } - return {type: "FilterProjection", children: [left, right, condition]}; - case TOK_FLATTEN: - var leftNode = {type: TOK_FLATTEN, children: [left]}; - var rightNode = this._parseProjectionRHS(bindingPower.Flatten); - return {type: "Projection", children: [leftNode, rightNode]}; - case TOK_EQ: - case TOK_NE: - case TOK_GT: - case TOK_GTE: - case TOK_LT: - case TOK_LTE: - return this._parseComparator(left, tokenName); - case TOK_LBRACKET: - var token = this._lookaheadToken(0); - if (token.type === TOK_NUMBER || token.type === TOK_COLON) { - right = this._parseIndexExpression(); - return this._projectIfSlice(left, right); - } else { - this._match(TOK_STAR); - this._match(TOK_RBRACKET); - right = this._parseProjectionRHS(bindingPower.Star); - return {type: "Projection", children: [left, right]}; - } - break; - default: - this._errorToken(this._lookaheadToken(0)); - } - }, - _match: function(tokenType) { - if (this._lookahead(0) === tokenType) { - this._advance(); - } else { - var t = this._lookaheadToken(0); - var error = new Error("Expected " + tokenType + ", got: " + t.type); - error.name = "ParserError"; - throw error; - } - }, +function YAMLException(reason, mark) { + // Super constructor + Error.call(this); - _errorToken: function(token) { - var error = new Error("Invalid token (" + - token.type + "): \"" + - token.value + "\""); - error.name = "ParserError"; - throw error; - }, + this.name = 'YAMLException'; + this.reason = reason; + this.mark = mark; + this.message = formatError(this, false); + // Include stack trace in error object + if (Error.captureStackTrace) { + // Chrome and NodeJS + Error.captureStackTrace(this, this.constructor); + } else { + // FF, IE 10+ and Safari 6+. Fallback for others + this.stack = (new Error()).stack || ''; + } +} - _parseIndexExpression: function() { - if (this._lookahead(0) === TOK_COLON || this._lookahead(1) === TOK_COLON) { - return this._parseSliceExpression(); - } else { - var node = { - type: "Index", - value: this._lookaheadToken(0).value}; - this._advance(); - this._match(TOK_RBRACKET); - return node; - } - }, - _projectIfSlice: function(left, right) { - var indexExpr = {type: "IndexExpression", children: [left, right]}; - if (right.type === "Slice") { - return { - type: "Projection", - children: [indexExpr, this._parseProjectionRHS(bindingPower.Star)] - }; - } else { - return indexExpr; - } - }, +// Inherit from Error +YAMLException.prototype = Object.create(Error.prototype); +YAMLException.prototype.constructor = YAMLException; - _parseSliceExpression: function() { - // [start:end:step] where each part is optional, as well as the last - // colon. - var parts = [null, null, null]; - var index = 0; - var currentToken = this._lookahead(0); - while (currentToken !== TOK_RBRACKET && index < 3) { - if (currentToken === TOK_COLON) { - index++; - this._advance(); - } else if (currentToken === TOK_NUMBER) { - parts[index] = this._lookaheadToken(0).value; - this._advance(); - } else { - var t = this._lookahead(0); - var error = new Error("Syntax error, unexpected token: " + - t.value + "(" + t.type + ")"); - error.name = "Parsererror"; - throw error; - } - currentToken = this._lookahead(0); - } - this._match(TOK_RBRACKET); - return { - type: "Slice", - children: parts - }; - }, - _parseComparator: function(left, comparator) { - var right = this.expression(bindingPower[comparator]); - return {type: "Comparator", name: comparator, children: [left, right]}; - }, +YAMLException.prototype.toString = function toString(compact) { + return this.name + ': ' + formatError(this, compact); +}; - _parseDotRHS: function(rbp) { - var lookahead = this._lookahead(0); - var exprTokens = [TOK_UNQUOTEDIDENTIFIER, TOK_QUOTEDIDENTIFIER, TOK_STAR]; - if (exprTokens.indexOf(lookahead) >= 0) { - return this.expression(rbp); - } else if (lookahead === TOK_LBRACKET) { - this._match(TOK_LBRACKET); - return this._parseMultiselectList(); - } else if (lookahead === TOK_LBRACE) { - this._match(TOK_LBRACE); - return this._parseMultiselectHash(); - } - }, - _parseProjectionRHS: function(rbp) { - var right; - if (bindingPower[this._lookahead(0)] < 10) { - right = {type: "Identity"}; - } else if (this._lookahead(0) === TOK_LBRACKET) { - right = this.expression(rbp); - } else if (this._lookahead(0) === TOK_FILTER) { - right = this.expression(rbp); - } else if (this._lookahead(0) === TOK_DOT) { - this._match(TOK_DOT); - right = this._parseDotRHS(rbp); - } else { - var t = this._lookaheadToken(0); - var error = new Error("Sytanx error, unexpected token: " + - t.value + "(" + t.type + ")"); - error.name = "ParserError"; - throw error; - } - return right; - }, +module.exports = YAMLException; - _parseMultiselectList: function() { - var expressions = []; - while (this._lookahead(0) !== TOK_RBRACKET) { - var expression = this.expression(0); - expressions.push(expression); - if (this._lookahead(0) === TOK_COMMA) { - this._match(TOK_COMMA); - if (this._lookahead(0) === TOK_RBRACKET) { - throw new Error("Unexpected token Rbracket"); - } - } - } - this._match(TOK_RBRACKET); - return {type: "MultiSelectList", children: expressions}; - }, - _parseMultiselectHash: function() { - var pairs = []; - var identifierTypes = [TOK_UNQUOTEDIDENTIFIER, TOK_QUOTEDIDENTIFIER]; - var keyToken, keyName, value, node; - for (;;) { - keyToken = this._lookaheadToken(0); - if (identifierTypes.indexOf(keyToken.type) < 0) { - throw new Error("Expecting an identifier token, got: " + - keyToken.type); - } - keyName = keyToken.value; - this._advance(); - this._match(TOK_COLON); - value = this.expression(0); - node = {type: "KeyValuePair", name: keyName, value: value}; - pairs.push(node); - if (this._lookahead(0) === TOK_COMMA) { - this._match(TOK_COMMA); - } else if (this._lookahead(0) === TOK_RBRACE) { - this._match(TOK_RBRACE); - break; - } - } - return {type: "MultiSelectHash", children: pairs}; - } - }; +/***/ }), +/***/ 1950: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - function TreeInterpreter(runtime) { - this.runtime = runtime; - } +"use strict"; - TreeInterpreter.prototype = { - search: function(node, value) { - return this.visit(node, value); - }, - visit: function(node, value) { - var matched, current, result, first, second, field, left, right, collected, i; - switch (node.type) { - case "Field": - if (value === null ) { - return null; - } else if (isObject(value)) { - field = value[node.name]; - if (field === undefined) { - return null; - } else { - return field; - } - } else { - return null; - } - break; - case "Subexpression": - result = this.visit(node.children[0], value); - for (i = 1; i < node.children.length; i++) { - result = this.visit(node.children[1], result); - if (result === null) { - return null; - } - } - return result; - case "IndexExpression": - left = this.visit(node.children[0], value); - right = this.visit(node.children[1], left); - return right; - case "Index": - if (!isArray(value)) { - return null; - } - var index = node.value; - if (index < 0) { - index = value.length + index; - } - result = value[index]; - if (result === undefined) { - result = null; - } - return result; - case "Slice": - if (!isArray(value)) { - return null; - } - var sliceParams = node.children.slice(0); - var computed = this.computeSliceParams(value.length, sliceParams); - var start = computed[0]; - var stop = computed[1]; - var step = computed[2]; - result = []; - if (step > 0) { - for (i = start; i < stop; i += step) { - result.push(value[i]); - } - } else { - for (i = start; i > stop; i += step) { - result.push(value[i]); - } - } - return result; - case "Projection": - // Evaluate left child. - var base = this.visit(node.children[0], value); - if (!isArray(base)) { - return null; - } - collected = []; - for (i = 0; i < base.length; i++) { - current = this.visit(node.children[1], base[i]); - if (current !== null) { - collected.push(current); - } - } - return collected; - case "ValueProjection": - // Evaluate left child. - base = this.visit(node.children[0], value); - if (!isObject(base)) { - return null; - } - collected = []; - var values = objValues(base); - for (i = 0; i < values.length; i++) { - current = this.visit(node.children[1], values[i]); - if (current !== null) { - collected.push(current); - } - } - return collected; - case "FilterProjection": - base = this.visit(node.children[0], value); - if (!isArray(base)) { - return null; - } - var filtered = []; - var finalResults = []; - for (i = 0; i < base.length; i++) { - matched = this.visit(node.children[2], base[i]); - if (!isFalse(matched)) { - filtered.push(base[i]); - } - } - for (var j = 0; j < filtered.length; j++) { - current = this.visit(node.children[1], filtered[j]); - if (current !== null) { - finalResults.push(current); - } - } - return finalResults; - case "Comparator": - first = this.visit(node.children[0], value); - second = this.visit(node.children[1], value); - switch(node.name) { - case TOK_EQ: - result = strictDeepEqual(first, second); - break; - case TOK_NE: - result = !strictDeepEqual(first, second); - break; - case TOK_GT: - result = first > second; - break; - case TOK_GTE: - result = first >= second; - break; - case TOK_LT: - result = first < second; - break; - case TOK_LTE: - result = first <= second; - break; - default: - throw new Error("Unknown comparator: " + node.name); - } - return result; - case TOK_FLATTEN: - var original = this.visit(node.children[0], value); - if (!isArray(original)) { - return null; - } - var merged = []; - for (i = 0; i < original.length; i++) { - current = original[i]; - if (isArray(current)) { - merged.push.apply(merged, current); - } else { - merged.push(current); - } - } - return merged; - case "Identity": - return value; - case "MultiSelectList": - if (value === null) { - return null; - } - collected = []; - for (i = 0; i < node.children.length; i++) { - collected.push(this.visit(node.children[i], value)); - } - return collected; - case "MultiSelectHash": - if (value === null) { - return null; - } - collected = {}; - var child; - for (i = 0; i < node.children.length; i++) { - child = node.children[i]; - collected[child.name] = this.visit(child.value, value); - } - return collected; - case "OrExpression": - matched = this.visit(node.children[0], value); - if (isFalse(matched)) { - matched = this.visit(node.children[1], value); - } - return matched; - case "AndExpression": - first = this.visit(node.children[0], value); +/*eslint-disable max-len,no-use-before-define*/ - if (isFalse(first) === true) { - return first; - } - return this.visit(node.children[1], value); - case "NotExpression": - first = this.visit(node.children[0], value); - return isFalse(first); - case "Literal": - return node.value; - case TOK_PIPE: - left = this.visit(node.children[0], value); - return this.visit(node.children[1], left); - case TOK_CURRENT: - return value; - case "Function": - var resolvedArgs = []; - for (i = 0; i < node.children.length; i++) { - resolvedArgs.push(this.visit(node.children[i], value)); - } - return this.runtime.callFunction(node.name, resolvedArgs); - case "ExpressionReference": - var refNode = node.children[0]; - // Tag the node with a specific attribute so the type - // checker verify the type. - refNode.jmespathType = TOK_EXPREF; - return refNode; - default: - throw new Error("Unknown node type: " + node.type); - } - }, +var common = __nccwpck_require__(9816); +var YAMLException = __nccwpck_require__(1248); +var makeSnippet = __nccwpck_require__(9440); +var DEFAULT_SCHEMA = __nccwpck_require__(7336); - computeSliceParams: function(arrayLength, sliceParams) { - var start = sliceParams[0]; - var stop = sliceParams[1]; - var step = sliceParams[2]; - var computed = [null, null, null]; - if (step === null) { - step = 1; - } else if (step === 0) { - var error = new Error("Invalid slice, step cannot be 0"); - error.name = "RuntimeError"; - throw error; - } - var stepValueNegative = step < 0 ? true : false; - - if (start === null) { - start = stepValueNegative ? arrayLength - 1 : 0; - } else { - start = this.capSliceRange(arrayLength, start, step); - } - if (stop === null) { - stop = stepValueNegative ? -1 : arrayLength; - } else { - stop = this.capSliceRange(arrayLength, stop, step); - } - computed[0] = start; - computed[1] = stop; - computed[2] = step; - return computed; - }, +var _hasOwnProperty = Object.prototype.hasOwnProperty; - capSliceRange: function(arrayLength, actualValue, step) { - if (actualValue < 0) { - actualValue += arrayLength; - if (actualValue < 0) { - actualValue = step < 0 ? -1 : 0; - } - } else if (actualValue >= arrayLength) { - actualValue = step < 0 ? arrayLength - 1 : arrayLength; - } - return actualValue; - } - }; +var CONTEXT_FLOW_IN = 1; +var CONTEXT_FLOW_OUT = 2; +var CONTEXT_BLOCK_IN = 3; +var CONTEXT_BLOCK_OUT = 4; - function Runtime(interpreter) { - this._interpreter = interpreter; - this.functionTable = { - // name: [function, ] - // The can be: - // - // { - // args: [[type1, type2], [type1, type2]], - // variadic: true|false - // } - // - // Each arg in the arg list is a list of valid types - // (if the function is overloaded and supports multiple - // types. If the type is "any" then no type checking - // occurs on the argument. Variadic is optional - // and if not provided is assumed to be false. - abs: {_func: this._functionAbs, _signature: [{types: [TYPE_NUMBER]}]}, - avg: {_func: this._functionAvg, _signature: [{types: [TYPE_ARRAY_NUMBER]}]}, - ceil: {_func: this._functionCeil, _signature: [{types: [TYPE_NUMBER]}]}, - contains: { - _func: this._functionContains, - _signature: [{types: [TYPE_STRING, TYPE_ARRAY]}, - {types: [TYPE_ANY]}]}, - "ends_with": { - _func: this._functionEndsWith, - _signature: [{types: [TYPE_STRING]}, {types: [TYPE_STRING]}]}, - floor: {_func: this._functionFloor, _signature: [{types: [TYPE_NUMBER]}]}, - length: { - _func: this._functionLength, - _signature: [{types: [TYPE_STRING, TYPE_ARRAY, TYPE_OBJECT]}]}, - map: { - _func: this._functionMap, - _signature: [{types: [TYPE_EXPREF]}, {types: [TYPE_ARRAY]}]}, - max: { - _func: this._functionMax, - _signature: [{types: [TYPE_ARRAY_NUMBER, TYPE_ARRAY_STRING]}]}, - "merge": { - _func: this._functionMerge, - _signature: [{types: [TYPE_OBJECT], variadic: true}] - }, - "max_by": { - _func: this._functionMaxBy, - _signature: [{types: [TYPE_ARRAY]}, {types: [TYPE_EXPREF]}] - }, - sum: {_func: this._functionSum, _signature: [{types: [TYPE_ARRAY_NUMBER]}]}, - "starts_with": { - _func: this._functionStartsWith, - _signature: [{types: [TYPE_STRING]}, {types: [TYPE_STRING]}]}, - min: { - _func: this._functionMin, - _signature: [{types: [TYPE_ARRAY_NUMBER, TYPE_ARRAY_STRING]}]}, - "min_by": { - _func: this._functionMinBy, - _signature: [{types: [TYPE_ARRAY]}, {types: [TYPE_EXPREF]}] - }, - type: {_func: this._functionType, _signature: [{types: [TYPE_ANY]}]}, - keys: {_func: this._functionKeys, _signature: [{types: [TYPE_OBJECT]}]}, - values: {_func: this._functionValues, _signature: [{types: [TYPE_OBJECT]}]}, - sort: {_func: this._functionSort, _signature: [{types: [TYPE_ARRAY_STRING, TYPE_ARRAY_NUMBER]}]}, - "sort_by": { - _func: this._functionSortBy, - _signature: [{types: [TYPE_ARRAY]}, {types: [TYPE_EXPREF]}] - }, - join: { - _func: this._functionJoin, - _signature: [ - {types: [TYPE_STRING]}, - {types: [TYPE_ARRAY_STRING]} - ] - }, - reverse: { - _func: this._functionReverse, - _signature: [{types: [TYPE_STRING, TYPE_ARRAY]}]}, - "to_array": {_func: this._functionToArray, _signature: [{types: [TYPE_ANY]}]}, - "to_string": {_func: this._functionToString, _signature: [{types: [TYPE_ANY]}]}, - "to_number": {_func: this._functionToNumber, _signature: [{types: [TYPE_ANY]}]}, - "not_null": { - _func: this._functionNotNull, - _signature: [{types: [TYPE_ANY], variadic: true}] - } - }; - } - Runtime.prototype = { - callFunction: function(name, resolvedArgs) { - var functionEntry = this.functionTable[name]; - if (functionEntry === undefined) { - throw new Error("Unknown function: " + name + "()"); - } - this._validateArgs(name, resolvedArgs, functionEntry._signature); - return functionEntry._func.call(this, resolvedArgs); - }, +var CHOMPING_CLIP = 1; +var CHOMPING_STRIP = 2; +var CHOMPING_KEEP = 3; - _validateArgs: function(name, args, signature) { - // Validating the args requires validating - // the correct arity and the correct type of each arg. - // If the last argument is declared as variadic, then we need - // a minimum number of args to be required. Otherwise it has to - // be an exact amount. - var pluralized; - if (signature[signature.length - 1].variadic) { - if (args.length < signature.length) { - pluralized = signature.length === 1 ? " argument" : " arguments"; - throw new Error("ArgumentError: " + name + "() " + - "takes at least" + signature.length + pluralized + - " but received " + args.length); - } - } else if (args.length !== signature.length) { - pluralized = signature.length === 1 ? " argument" : " arguments"; - throw new Error("ArgumentError: " + name + "() " + - "takes " + signature.length + pluralized + - " but received " + args.length); - } - var currentSpec; - var actualType; - var typeMatched; - for (var i = 0; i < signature.length; i++) { - typeMatched = false; - currentSpec = signature[i].types; - actualType = this._getTypeName(args[i]); - for (var j = 0; j < currentSpec.length; j++) { - if (this._typeMatches(actualType, currentSpec[j], args[i])) { - typeMatched = true; - break; - } - } - if (!typeMatched) { - throw new Error("TypeError: " + name + "() " + - "expected argument " + (i + 1) + - " to be type " + currentSpec + - " but received type " + actualType + - " instead."); - } - } - }, - _typeMatches: function(actual, expected, argValue) { - if (expected === TYPE_ANY) { - return true; - } - if (expected === TYPE_ARRAY_STRING || - expected === TYPE_ARRAY_NUMBER || - expected === TYPE_ARRAY) { - // The expected type can either just be array, - // or it can require a specific subtype (array of numbers). - // - // The simplest case is if "array" with no subtype is specified. - if (expected === TYPE_ARRAY) { - return actual === TYPE_ARRAY; - } else if (actual === TYPE_ARRAY) { - // Otherwise we need to check subtypes. - // I think this has potential to be improved. - var subtype; - if (expected === TYPE_ARRAY_NUMBER) { - subtype = TYPE_NUMBER; - } else if (expected === TYPE_ARRAY_STRING) { - subtype = TYPE_STRING; - } - for (var i = 0; i < argValue.length; i++) { - if (!this._typeMatches( - this._getTypeName(argValue[i]), subtype, - argValue[i])) { - return false; - } - } - return true; - } - } else { - return actual === expected; - } - }, - _getTypeName: function(obj) { - switch (Object.prototype.toString.call(obj)) { - case "[object String]": - return TYPE_STRING; - case "[object Number]": - return TYPE_NUMBER; - case "[object Array]": - return TYPE_ARRAY; - case "[object Boolean]": - return TYPE_BOOLEAN; - case "[object Null]": - return TYPE_NULL; - case "[object Object]": - // Check if it's an expref. If it has, it's been - // tagged with a jmespathType attr of 'Expref'; - if (obj.jmespathType === TOK_EXPREF) { - return TYPE_EXPREF; - } else { - return TYPE_OBJECT; - } - } - }, +var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/; +var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/; +var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/; +var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i; +var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i; - _functionStartsWith: function(resolvedArgs) { - return resolvedArgs[0].lastIndexOf(resolvedArgs[1]) === 0; - }, - _functionEndsWith: function(resolvedArgs) { - var searchStr = resolvedArgs[0]; - var suffix = resolvedArgs[1]; - return searchStr.indexOf(suffix, searchStr.length - suffix.length) !== -1; - }, +function _class(obj) { return Object.prototype.toString.call(obj); } - _functionReverse: function(resolvedArgs) { - var typeName = this._getTypeName(resolvedArgs[0]); - if (typeName === TYPE_STRING) { - var originalStr = resolvedArgs[0]; - var reversedStr = ""; - for (var i = originalStr.length - 1; i >= 0; i--) { - reversedStr += originalStr[i]; - } - return reversedStr; - } else { - var reversedArray = resolvedArgs[0].slice(0); - reversedArray.reverse(); - return reversedArray; - } - }, +function is_EOL(c) { + return (c === 0x0A/* LF */) || (c === 0x0D/* CR */); +} - _functionAbs: function(resolvedArgs) { - return Math.abs(resolvedArgs[0]); - }, +function is_WHITE_SPACE(c) { + return (c === 0x09/* Tab */) || (c === 0x20/* Space */); +} - _functionCeil: function(resolvedArgs) { - return Math.ceil(resolvedArgs[0]); - }, +function is_WS_OR_EOL(c) { + return (c === 0x09/* Tab */) || + (c === 0x20/* Space */) || + (c === 0x0A/* LF */) || + (c === 0x0D/* CR */); +} - _functionAvg: function(resolvedArgs) { - var sum = 0; - var inputArray = resolvedArgs[0]; - for (var i = 0; i < inputArray.length; i++) { - sum += inputArray[i]; - } - return sum / inputArray.length; - }, +function is_FLOW_INDICATOR(c) { + return c === 0x2C/* , */ || + c === 0x5B/* [ */ || + c === 0x5D/* ] */ || + c === 0x7B/* { */ || + c === 0x7D/* } */; +} - _functionContains: function(resolvedArgs) { - return resolvedArgs[0].indexOf(resolvedArgs[1]) >= 0; - }, +function fromHexCode(c) { + var lc; - _functionFloor: function(resolvedArgs) { - return Math.floor(resolvedArgs[0]); - }, + if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) { + return c - 0x30; + } - _functionLength: function(resolvedArgs) { - if (!isObject(resolvedArgs[0])) { - return resolvedArgs[0].length; - } else { - // As far as I can tell, there's no way to get the length - // of an object without O(n) iteration through the object. - return Object.keys(resolvedArgs[0]).length; - } - }, + /*eslint-disable no-bitwise*/ + lc = c | 0x20; - _functionMap: function(resolvedArgs) { - var mapped = []; - var interpreter = this._interpreter; - var exprefNode = resolvedArgs[0]; - var elements = resolvedArgs[1]; - for (var i = 0; i < elements.length; i++) { - mapped.push(interpreter.visit(exprefNode, elements[i])); - } - return mapped; - }, + if ((0x61/* a */ <= lc) && (lc <= 0x66/* f */)) { + return lc - 0x61 + 10; + } - _functionMerge: function(resolvedArgs) { - var merged = {}; - for (var i = 0; i < resolvedArgs.length; i++) { - var current = resolvedArgs[i]; - for (var key in current) { - merged[key] = current[key]; - } - } - return merged; - }, + return -1; +} - _functionMax: function(resolvedArgs) { - if (resolvedArgs[0].length > 0) { - var typeName = this._getTypeName(resolvedArgs[0][0]); - if (typeName === TYPE_NUMBER) { - return Math.max.apply(Math, resolvedArgs[0]); - } else { - var elements = resolvedArgs[0]; - var maxElement = elements[0]; - for (var i = 1; i < elements.length; i++) { - if (maxElement.localeCompare(elements[i]) < 0) { - maxElement = elements[i]; - } - } - return maxElement; - } - } else { - return null; - } - }, +function escapedHexLen(c) { + if (c === 0x78/* x */) { return 2; } + if (c === 0x75/* u */) { return 4; } + if (c === 0x55/* U */) { return 8; } + return 0; +} - _functionMin: function(resolvedArgs) { - if (resolvedArgs[0].length > 0) { - var typeName = this._getTypeName(resolvedArgs[0][0]); - if (typeName === TYPE_NUMBER) { - return Math.min.apply(Math, resolvedArgs[0]); - } else { - var elements = resolvedArgs[0]; - var minElement = elements[0]; - for (var i = 1; i < elements.length; i++) { - if (elements[i].localeCompare(minElement) < 0) { - minElement = elements[i]; - } - } - return minElement; - } - } else { - return null; - } - }, +function fromDecimalCode(c) { + if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) { + return c - 0x30; + } - _functionSum: function(resolvedArgs) { - var sum = 0; - var listToSum = resolvedArgs[0]; - for (var i = 0; i < listToSum.length; i++) { - sum += listToSum[i]; - } - return sum; - }, + return -1; +} - _functionType: function(resolvedArgs) { - switch (this._getTypeName(resolvedArgs[0])) { - case TYPE_NUMBER: - return "number"; - case TYPE_STRING: - return "string"; - case TYPE_ARRAY: - return "array"; - case TYPE_OBJECT: - return "object"; - case TYPE_BOOLEAN: - return "boolean"; - case TYPE_EXPREF: - return "expref"; - case TYPE_NULL: - return "null"; - } - }, +function simpleEscapeSequence(c) { + /* eslint-disable indent */ + return (c === 0x30/* 0 */) ? '\x00' : + (c === 0x61/* a */) ? '\x07' : + (c === 0x62/* b */) ? '\x08' : + (c === 0x74/* t */) ? '\x09' : + (c === 0x09/* Tab */) ? '\x09' : + (c === 0x6E/* n */) ? '\x0A' : + (c === 0x76/* v */) ? '\x0B' : + (c === 0x66/* f */) ? '\x0C' : + (c === 0x72/* r */) ? '\x0D' : + (c === 0x65/* e */) ? '\x1B' : + (c === 0x20/* Space */) ? ' ' : + (c === 0x22/* " */) ? '\x22' : + (c === 0x2F/* / */) ? '/' : + (c === 0x5C/* \ */) ? '\x5C' : + (c === 0x4E/* N */) ? '\x85' : + (c === 0x5F/* _ */) ? '\xA0' : + (c === 0x4C/* L */) ? '\u2028' : + (c === 0x50/* P */) ? '\u2029' : ''; +} - _functionKeys: function(resolvedArgs) { - return Object.keys(resolvedArgs[0]); - }, +function charFromCodepoint(c) { + if (c <= 0xFFFF) { + return String.fromCharCode(c); + } + // Encode UTF-16 surrogate pair + // https://en.wikipedia.org/wiki/UTF-16#Code_points_U.2B010000_to_U.2B10FFFF + return String.fromCharCode( + ((c - 0x010000) >> 10) + 0xD800, + ((c - 0x010000) & 0x03FF) + 0xDC00 + ); +} - _functionValues: function(resolvedArgs) { - var obj = resolvedArgs[0]; - var keys = Object.keys(obj); - var values = []; - for (var i = 0; i < keys.length; i++) { - values.push(obj[keys[i]]); - } - return values; - }, +// set a property of a literal object, while protecting against prototype pollution, +// see https://github.com/nodeca/js-yaml/issues/164 for more details +function setProperty(object, key, value) { + // used for this specific key only because Object.defineProperty is slow + if (key === '__proto__') { + Object.defineProperty(object, key, { + configurable: true, + enumerable: true, + writable: true, + value: value + }); + } else { + object[key] = value; + } +} - _functionJoin: function(resolvedArgs) { - var joinChar = resolvedArgs[0]; - var listJoin = resolvedArgs[1]; - return listJoin.join(joinChar); - }, +var simpleEscapeCheck = new Array(256); // integer, for fast access +var simpleEscapeMap = new Array(256); +for (var i = 0; i < 256; i++) { + simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0; + simpleEscapeMap[i] = simpleEscapeSequence(i); +} - _functionToArray: function(resolvedArgs) { - if (this._getTypeName(resolvedArgs[0]) === TYPE_ARRAY) { - return resolvedArgs[0]; - } else { - return [resolvedArgs[0]]; - } - }, - _functionToString: function(resolvedArgs) { - if (this._getTypeName(resolvedArgs[0]) === TYPE_STRING) { - return resolvedArgs[0]; - } else { - return JSON.stringify(resolvedArgs[0]); - } - }, +function State(input, options) { + this.input = input; - _functionToNumber: function(resolvedArgs) { - var typeName = this._getTypeName(resolvedArgs[0]); - var convertedValue; - if (typeName === TYPE_NUMBER) { - return resolvedArgs[0]; - } else if (typeName === TYPE_STRING) { - convertedValue = +resolvedArgs[0]; - if (!isNaN(convertedValue)) { - return convertedValue; - } - } - return null; - }, + this.filename = options['filename'] || null; + this.schema = options['schema'] || DEFAULT_SCHEMA; + this.onWarning = options['onWarning'] || null; + // (Hidden) Remove? makes the loader to expect YAML 1.1 documents + // if such documents have no explicit %YAML directive + this.legacy = options['legacy'] || false; - _functionNotNull: function(resolvedArgs) { - for (var i = 0; i < resolvedArgs.length; i++) { - if (this._getTypeName(resolvedArgs[i]) !== TYPE_NULL) { - return resolvedArgs[i]; - } - } - return null; - }, + this.json = options['json'] || false; + this.listener = options['listener'] || null; - _functionSort: function(resolvedArgs) { - var sortedArray = resolvedArgs[0].slice(0); - sortedArray.sort(); - return sortedArray; - }, + this.implicitTypes = this.schema.compiledImplicit; + this.typeMap = this.schema.compiledTypeMap; - _functionSortBy: function(resolvedArgs) { - var sortedArray = resolvedArgs[0].slice(0); - if (sortedArray.length === 0) { - return sortedArray; - } - var interpreter = this._interpreter; - var exprefNode = resolvedArgs[1]; - var requiredType = this._getTypeName( - interpreter.visit(exprefNode, sortedArray[0])); - if ([TYPE_NUMBER, TYPE_STRING].indexOf(requiredType) < 0) { - throw new Error("TypeError"); - } - var that = this; - // In order to get a stable sort out of an unstable - // sort algorithm, we decorate/sort/undecorate (DSU) - // by creating a new list of [index, element] pairs. - // In the cmp function, if the evaluated elements are - // equal, then the index will be used as the tiebreaker. - // After the decorated list has been sorted, it will be - // undecorated to extract the original elements. - var decorated = []; - for (var i = 0; i < sortedArray.length; i++) { - decorated.push([i, sortedArray[i]]); - } - decorated.sort(function(a, b) { - var exprA = interpreter.visit(exprefNode, a[1]); - var exprB = interpreter.visit(exprefNode, b[1]); - if (that._getTypeName(exprA) !== requiredType) { - throw new Error( - "TypeError: expected " + requiredType + ", received " + - that._getTypeName(exprA)); - } else if (that._getTypeName(exprB) !== requiredType) { - throw new Error( - "TypeError: expected " + requiredType + ", received " + - that._getTypeName(exprB)); - } - if (exprA > exprB) { - return 1; - } else if (exprA < exprB) { - return -1; - } else { - // If they're equal compare the items by their - // order to maintain relative order of equal keys - // (i.e. to get a stable sort). - return a[0] - b[0]; - } - }); - // Undecorate: extract out the original list elements. - for (var j = 0; j < decorated.length; j++) { - sortedArray[j] = decorated[j][1]; - } - return sortedArray; - }, + this.length = input.length; + this.position = 0; + this.line = 0; + this.lineStart = 0; + this.lineIndent = 0; - _functionMaxBy: function(resolvedArgs) { - var exprefNode = resolvedArgs[1]; - var resolvedArray = resolvedArgs[0]; - var keyFunction = this.createKeyFunction(exprefNode, [TYPE_NUMBER, TYPE_STRING]); - var maxNumber = -Infinity; - var maxRecord; - var current; - for (var i = 0; i < resolvedArray.length; i++) { - current = keyFunction(resolvedArray[i]); - if (current > maxNumber) { - maxNumber = current; - maxRecord = resolvedArray[i]; - } - } - return maxRecord; - }, + // position of first leading tab in the current line, + // used to make sure there are no tabs in the indentation + this.firstTabInLine = -1; - _functionMinBy: function(resolvedArgs) { - var exprefNode = resolvedArgs[1]; - var resolvedArray = resolvedArgs[0]; - var keyFunction = this.createKeyFunction(exprefNode, [TYPE_NUMBER, TYPE_STRING]); - var minNumber = Infinity; - var minRecord; - var current; - for (var i = 0; i < resolvedArray.length; i++) { - current = keyFunction(resolvedArray[i]); - if (current < minNumber) { - minNumber = current; - minRecord = resolvedArray[i]; - } - } - return minRecord; - }, + this.documents = []; - createKeyFunction: function(exprefNode, allowedTypes) { - var that = this; - var interpreter = this._interpreter; - var keyFunc = function(x) { - var current = interpreter.visit(exprefNode, x); - if (allowedTypes.indexOf(that._getTypeName(current)) < 0) { - var msg = "TypeError: expected one of " + allowedTypes + - ", received " + that._getTypeName(current); - throw new Error(msg); - } - return current; - }; - return keyFunc; - } + /* + this.version; + this.checkLineBreaks; + this.tagMap; + this.anchorMap; + this.tag; + this.anchor; + this.kind; + this.result;*/ - }; +} - function compile(stream) { - var parser = new Parser(); - var ast = parser.parse(stream); - return ast; - } - function tokenize(stream) { - var lexer = new Lexer(); - return lexer.tokenize(stream); - } +function generateError(state, message) { + var mark = { + name: state.filename, + buffer: state.input.slice(0, -1), // omit trailing \0 + position: state.position, + line: state.line, + column: state.position - state.lineStart + }; - function search(data, expression) { - var parser = new Parser(); - // This needs to be improved. Both the interpreter and runtime depend on - // each other. The runtime needs the interpreter to support exprefs. - // There's likely a clean way to avoid the cyclic dependency. - var runtime = new Runtime(); - var interpreter = new TreeInterpreter(runtime); - runtime._interpreter = interpreter; - var node = parser.parse(expression); - return interpreter.search(node, data); - } + mark.snippet = makeSnippet(mark); - exports.tokenize = tokenize; - exports.compile = compile; - exports.search = search; - exports.strictDeepEqual = strictDeepEqual; -})( false ? undefined : exports); + return new YAMLException(message, mark); +} +function throwError(state, message) { + throw generateError(state, message); +} -/***/ }), +function throwWarning(state, message) { + if (state.onWarning) { + state.onWarning.call(null, generateError(state, message)); + } +} -/***/ 2816: -/***/ (function(module) { -module.exports = {"pagination":{"ListInvitations":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListMembers":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListNetworks":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListNodes":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListProposalVotes":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListProposals":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"}}}; +var directiveHandlers = { -/***/ }), + YAML: function handleYamlDirective(state, name, args) { -/***/ 2857: -/***/ (function(module) { + var match, major, minor; -module.exports = {"version":"2.0","metadata":{"apiVersion":"2012-06-01","checksumFormat":"sha256","endpointPrefix":"glacier","protocol":"rest-json","serviceFullName":"Amazon Glacier","serviceId":"Glacier","signatureVersion":"v4","uid":"glacier-2012-06-01"},"operations":{"AbortMultipartUpload":{"http":{"method":"DELETE","requestUri":"/{accountId}/vaults/{vaultName}/multipart-uploads/{uploadId}","responseCode":204},"input":{"type":"structure","required":["accountId","vaultName","uploadId"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"vaultName":{"location":"uri","locationName":"vaultName"},"uploadId":{"location":"uri","locationName":"uploadId"}}}},"AbortVaultLock":{"http":{"method":"DELETE","requestUri":"/{accountId}/vaults/{vaultName}/lock-policy","responseCode":204},"input":{"type":"structure","required":["accountId","vaultName"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"vaultName":{"location":"uri","locationName":"vaultName"}}}},"AddTagsToVault":{"http":{"requestUri":"/{accountId}/vaults/{vaultName}/tags?operation=add","responseCode":204},"input":{"type":"structure","required":["accountId","vaultName"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"vaultName":{"location":"uri","locationName":"vaultName"},"Tags":{"shape":"S5"}}}},"CompleteMultipartUpload":{"http":{"requestUri":"/{accountId}/vaults/{vaultName}/multipart-uploads/{uploadId}","responseCode":201},"input":{"type":"structure","required":["accountId","vaultName","uploadId"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"vaultName":{"location":"uri","locationName":"vaultName"},"uploadId":{"location":"uri","locationName":"uploadId"},"archiveSize":{"location":"header","locationName":"x-amz-archive-size"},"checksum":{"location":"header","locationName":"x-amz-sha256-tree-hash"}}},"output":{"shape":"S9"}},"CompleteVaultLock":{"http":{"requestUri":"/{accountId}/vaults/{vaultName}/lock-policy/{lockId}","responseCode":204},"input":{"type":"structure","required":["accountId","vaultName","lockId"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"vaultName":{"location":"uri","locationName":"vaultName"},"lockId":{"location":"uri","locationName":"lockId"}}}},"CreateVault":{"http":{"method":"PUT","requestUri":"/{accountId}/vaults/{vaultName}","responseCode":201},"input":{"type":"structure","required":["accountId","vaultName"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"vaultName":{"location":"uri","locationName":"vaultName"}}},"output":{"type":"structure","members":{"location":{"location":"header","locationName":"Location"}}}},"DeleteArchive":{"http":{"method":"DELETE","requestUri":"/{accountId}/vaults/{vaultName}/archives/{archiveId}","responseCode":204},"input":{"type":"structure","required":["accountId","vaultName","archiveId"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"vaultName":{"location":"uri","locationName":"vaultName"},"archiveId":{"location":"uri","locationName":"archiveId"}}}},"DeleteVault":{"http":{"method":"DELETE","requestUri":"/{accountId}/vaults/{vaultName}","responseCode":204},"input":{"type":"structure","required":["accountId","vaultName"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"vaultName":{"location":"uri","locationName":"vaultName"}}}},"DeleteVaultAccessPolicy":{"http":{"method":"DELETE","requestUri":"/{accountId}/vaults/{vaultName}/access-policy","responseCode":204},"input":{"type":"structure","required":["accountId","vaultName"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"vaultName":{"location":"uri","locationName":"vaultName"}}}},"DeleteVaultNotifications":{"http":{"method":"DELETE","requestUri":"/{accountId}/vaults/{vaultName}/notification-configuration","responseCode":204},"input":{"type":"structure","required":["accountId","vaultName"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"vaultName":{"location":"uri","locationName":"vaultName"}}}},"DescribeJob":{"http":{"method":"GET","requestUri":"/{accountId}/vaults/{vaultName}/jobs/{jobId}"},"input":{"type":"structure","required":["accountId","vaultName","jobId"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"vaultName":{"location":"uri","locationName":"vaultName"},"jobId":{"location":"uri","locationName":"jobId"}}},"output":{"shape":"Si"}},"DescribeVault":{"http":{"method":"GET","requestUri":"/{accountId}/vaults/{vaultName}"},"input":{"type":"structure","required":["accountId","vaultName"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"vaultName":{"location":"uri","locationName":"vaultName"}}},"output":{"shape":"S1a"}},"GetDataRetrievalPolicy":{"http":{"method":"GET","requestUri":"/{accountId}/policies/data-retrieval"},"input":{"type":"structure","required":["accountId"],"members":{"accountId":{"location":"uri","locationName":"accountId"}}},"output":{"type":"structure","members":{"Policy":{"shape":"S1e"}}}},"GetJobOutput":{"http":{"method":"GET","requestUri":"/{accountId}/vaults/{vaultName}/jobs/{jobId}/output"},"input":{"type":"structure","required":["accountId","vaultName","jobId"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"vaultName":{"location":"uri","locationName":"vaultName"},"jobId":{"location":"uri","locationName":"jobId"},"range":{"location":"header","locationName":"Range"}}},"output":{"type":"structure","members":{"body":{"shape":"S1k"},"checksum":{"location":"header","locationName":"x-amz-sha256-tree-hash"},"status":{"location":"statusCode","type":"integer"},"contentRange":{"location":"header","locationName":"Content-Range"},"acceptRanges":{"location":"header","locationName":"Accept-Ranges"},"contentType":{"location":"header","locationName":"Content-Type"},"archiveDescription":{"location":"header","locationName":"x-amz-archive-description"}},"payload":"body"}},"GetVaultAccessPolicy":{"http":{"method":"GET","requestUri":"/{accountId}/vaults/{vaultName}/access-policy"},"input":{"type":"structure","required":["accountId","vaultName"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"vaultName":{"location":"uri","locationName":"vaultName"}}},"output":{"type":"structure","members":{"policy":{"shape":"S1o"}},"payload":"policy"}},"GetVaultLock":{"http":{"method":"GET","requestUri":"/{accountId}/vaults/{vaultName}/lock-policy"},"input":{"type":"structure","required":["accountId","vaultName"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"vaultName":{"location":"uri","locationName":"vaultName"}}},"output":{"type":"structure","members":{"Policy":{},"State":{},"ExpirationDate":{},"CreationDate":{}}}},"GetVaultNotifications":{"http":{"method":"GET","requestUri":"/{accountId}/vaults/{vaultName}/notification-configuration"},"input":{"type":"structure","required":["accountId","vaultName"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"vaultName":{"location":"uri","locationName":"vaultName"}}},"output":{"type":"structure","members":{"vaultNotificationConfig":{"shape":"S1t"}},"payload":"vaultNotificationConfig"}},"InitiateJob":{"http":{"requestUri":"/{accountId}/vaults/{vaultName}/jobs","responseCode":202},"input":{"type":"structure","required":["accountId","vaultName"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"vaultName":{"location":"uri","locationName":"vaultName"},"jobParameters":{"type":"structure","members":{"Format":{},"Type":{},"ArchiveId":{},"Description":{},"SNSTopic":{},"RetrievalByteRange":{},"Tier":{},"InventoryRetrievalParameters":{"type":"structure","members":{"StartDate":{},"EndDate":{},"Limit":{},"Marker":{}}},"SelectParameters":{"shape":"Sp"},"OutputLocation":{"shape":"Sx"}}}},"payload":"jobParameters"},"output":{"type":"structure","members":{"location":{"location":"header","locationName":"Location"},"jobId":{"location":"header","locationName":"x-amz-job-id"},"jobOutputPath":{"location":"header","locationName":"x-amz-job-output-path"}}}},"InitiateMultipartUpload":{"http":{"requestUri":"/{accountId}/vaults/{vaultName}/multipart-uploads","responseCode":201},"input":{"type":"structure","required":["accountId","vaultName"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"vaultName":{"location":"uri","locationName":"vaultName"},"archiveDescription":{"location":"header","locationName":"x-amz-archive-description"},"partSize":{"location":"header","locationName":"x-amz-part-size"}}},"output":{"type":"structure","members":{"location":{"location":"header","locationName":"Location"},"uploadId":{"location":"header","locationName":"x-amz-multipart-upload-id"}}}},"InitiateVaultLock":{"http":{"requestUri":"/{accountId}/vaults/{vaultName}/lock-policy","responseCode":201},"input":{"type":"structure","required":["accountId","vaultName"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"vaultName":{"location":"uri","locationName":"vaultName"},"policy":{"type":"structure","members":{"Policy":{}}}},"payload":"policy"},"output":{"type":"structure","members":{"lockId":{"location":"header","locationName":"x-amz-lock-id"}}}},"ListJobs":{"http":{"method":"GET","requestUri":"/{accountId}/vaults/{vaultName}/jobs"},"input":{"type":"structure","required":["accountId","vaultName"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"vaultName":{"location":"uri","locationName":"vaultName"},"limit":{"location":"querystring","locationName":"limit"},"marker":{"location":"querystring","locationName":"marker"},"statuscode":{"location":"querystring","locationName":"statuscode"},"completed":{"location":"querystring","locationName":"completed"}}},"output":{"type":"structure","members":{"JobList":{"type":"list","member":{"shape":"Si"}},"Marker":{}}}},"ListMultipartUploads":{"http":{"method":"GET","requestUri":"/{accountId}/vaults/{vaultName}/multipart-uploads"},"input":{"type":"structure","required":["accountId","vaultName"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"vaultName":{"location":"uri","locationName":"vaultName"},"marker":{"location":"querystring","locationName":"marker"},"limit":{"location":"querystring","locationName":"limit"}}},"output":{"type":"structure","members":{"UploadsList":{"type":"list","member":{"type":"structure","members":{"MultipartUploadId":{},"VaultARN":{},"ArchiveDescription":{},"PartSizeInBytes":{"type":"long"},"CreationDate":{}}}},"Marker":{}}}},"ListParts":{"http":{"method":"GET","requestUri":"/{accountId}/vaults/{vaultName}/multipart-uploads/{uploadId}"},"input":{"type":"structure","required":["accountId","vaultName","uploadId"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"vaultName":{"location":"uri","locationName":"vaultName"},"uploadId":{"location":"uri","locationName":"uploadId"},"marker":{"location":"querystring","locationName":"marker"},"limit":{"location":"querystring","locationName":"limit"}}},"output":{"type":"structure","members":{"MultipartUploadId":{},"VaultARN":{},"ArchiveDescription":{},"PartSizeInBytes":{"type":"long"},"CreationDate":{},"Parts":{"type":"list","member":{"type":"structure","members":{"RangeInBytes":{},"SHA256TreeHash":{}}}},"Marker":{}}}},"ListProvisionedCapacity":{"http":{"method":"GET","requestUri":"/{accountId}/provisioned-capacity"},"input":{"type":"structure","required":["accountId"],"members":{"accountId":{"location":"uri","locationName":"accountId"}}},"output":{"type":"structure","members":{"ProvisionedCapacityList":{"type":"list","member":{"type":"structure","members":{"CapacityId":{},"StartDate":{},"ExpirationDate":{}}}}}}},"ListTagsForVault":{"http":{"method":"GET","requestUri":"/{accountId}/vaults/{vaultName}/tags"},"input":{"type":"structure","required":["accountId","vaultName"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"vaultName":{"location":"uri","locationName":"vaultName"}}},"output":{"type":"structure","members":{"Tags":{"shape":"S5"}}}},"ListVaults":{"http":{"method":"GET","requestUri":"/{accountId}/vaults"},"input":{"type":"structure","required":["accountId"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"marker":{"location":"querystring","locationName":"marker"},"limit":{"location":"querystring","locationName":"limit"}}},"output":{"type":"structure","members":{"VaultList":{"type":"list","member":{"shape":"S1a"}},"Marker":{}}}},"PurchaseProvisionedCapacity":{"http":{"requestUri":"/{accountId}/provisioned-capacity","responseCode":201},"input":{"type":"structure","required":["accountId"],"members":{"accountId":{"location":"uri","locationName":"accountId"}}},"output":{"type":"structure","members":{"capacityId":{"location":"header","locationName":"x-amz-capacity-id"}}}},"RemoveTagsFromVault":{"http":{"requestUri":"/{accountId}/vaults/{vaultName}/tags?operation=remove","responseCode":204},"input":{"type":"structure","required":["accountId","vaultName"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"vaultName":{"location":"uri","locationName":"vaultName"},"TagKeys":{"type":"list","member":{}}}}},"SetDataRetrievalPolicy":{"http":{"method":"PUT","requestUri":"/{accountId}/policies/data-retrieval","responseCode":204},"input":{"type":"structure","required":["accountId"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"Policy":{"shape":"S1e"}}}},"SetVaultAccessPolicy":{"http":{"method":"PUT","requestUri":"/{accountId}/vaults/{vaultName}/access-policy","responseCode":204},"input":{"type":"structure","required":["accountId","vaultName"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"vaultName":{"location":"uri","locationName":"vaultName"},"policy":{"shape":"S1o"}},"payload":"policy"}},"SetVaultNotifications":{"http":{"method":"PUT","requestUri":"/{accountId}/vaults/{vaultName}/notification-configuration","responseCode":204},"input":{"type":"structure","required":["accountId","vaultName"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"vaultName":{"location":"uri","locationName":"vaultName"},"vaultNotificationConfig":{"shape":"S1t"}},"payload":"vaultNotificationConfig"}},"UploadArchive":{"http":{"requestUri":"/{accountId}/vaults/{vaultName}/archives","responseCode":201},"input":{"type":"structure","required":["vaultName","accountId"],"members":{"vaultName":{"location":"uri","locationName":"vaultName"},"accountId":{"location":"uri","locationName":"accountId"},"archiveDescription":{"location":"header","locationName":"x-amz-archive-description"},"checksum":{"location":"header","locationName":"x-amz-sha256-tree-hash"},"body":{"shape":"S1k"}},"payload":"body"},"output":{"shape":"S9"}},"UploadMultipartPart":{"http":{"method":"PUT","requestUri":"/{accountId}/vaults/{vaultName}/multipart-uploads/{uploadId}","responseCode":204},"input":{"type":"structure","required":["accountId","vaultName","uploadId"],"members":{"accountId":{"location":"uri","locationName":"accountId"},"vaultName":{"location":"uri","locationName":"vaultName"},"uploadId":{"location":"uri","locationName":"uploadId"},"checksum":{"location":"header","locationName":"x-amz-sha256-tree-hash"},"range":{"location":"header","locationName":"Content-Range"},"body":{"shape":"S1k"}},"payload":"body"},"output":{"type":"structure","members":{"checksum":{"location":"header","locationName":"x-amz-sha256-tree-hash"}}}}},"shapes":{"S5":{"type":"map","key":{},"value":{}},"S9":{"type":"structure","members":{"location":{"location":"header","locationName":"Location"},"checksum":{"location":"header","locationName":"x-amz-sha256-tree-hash"},"archiveId":{"location":"header","locationName":"x-amz-archive-id"}}},"Si":{"type":"structure","members":{"JobId":{},"JobDescription":{},"Action":{},"ArchiveId":{},"VaultARN":{},"CreationDate":{},"Completed":{"type":"boolean"},"StatusCode":{},"StatusMessage":{},"ArchiveSizeInBytes":{"type":"long"},"InventorySizeInBytes":{"type":"long"},"SNSTopic":{},"CompletionDate":{},"SHA256TreeHash":{},"ArchiveSHA256TreeHash":{},"RetrievalByteRange":{},"Tier":{},"InventoryRetrievalParameters":{"type":"structure","members":{"Format":{},"StartDate":{},"EndDate":{},"Limit":{},"Marker":{}}},"JobOutputPath":{},"SelectParameters":{"shape":"Sp"},"OutputLocation":{"shape":"Sx"}}},"Sp":{"type":"structure","members":{"InputSerialization":{"type":"structure","members":{"csv":{"type":"structure","members":{"FileHeaderInfo":{},"Comments":{},"QuoteEscapeCharacter":{},"RecordDelimiter":{},"FieldDelimiter":{},"QuoteCharacter":{}}}}},"ExpressionType":{},"Expression":{},"OutputSerialization":{"type":"structure","members":{"csv":{"type":"structure","members":{"QuoteFields":{},"QuoteEscapeCharacter":{},"RecordDelimiter":{},"FieldDelimiter":{},"QuoteCharacter":{}}}}}}},"Sx":{"type":"structure","members":{"S3":{"type":"structure","members":{"BucketName":{},"Prefix":{},"Encryption":{"type":"structure","members":{"EncryptionType":{},"KMSKeyId":{},"KMSContext":{}}},"CannedACL":{},"AccessControlList":{"type":"list","member":{"type":"structure","members":{"Grantee":{"type":"structure","required":["Type"],"members":{"Type":{},"DisplayName":{},"URI":{},"ID":{},"EmailAddress":{}}},"Permission":{}}}},"Tagging":{"shape":"S17"},"UserMetadata":{"shape":"S17"},"StorageClass":{}}}}},"S17":{"type":"map","key":{},"value":{}},"S1a":{"type":"structure","members":{"VaultARN":{},"VaultName":{},"CreationDate":{},"LastInventoryDate":{},"NumberOfArchives":{"type":"long"},"SizeInBytes":{"type":"long"}}},"S1e":{"type":"structure","members":{"Rules":{"type":"list","member":{"type":"structure","members":{"Strategy":{},"BytesPerHour":{"type":"long"}}}}}},"S1k":{"type":"blob","streaming":true},"S1o":{"type":"structure","members":{"Policy":{}}},"S1t":{"type":"structure","members":{"SNSTopic":{},"Events":{"type":"list","member":{}}}}}}; + if (state.version !== null) { + throwError(state, 'duplication of %YAML directive'); + } -/***/ }), + if (args.length !== 1) { + throwError(state, 'YAML directive accepts exactly one argument'); + } -/***/ 2862: -/***/ (function(module) { + match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]); -module.exports = {"pagination":{"ListEventSources":{"input_token":"Marker","output_token":"NextMarker","limit_key":"MaxItems","result_key":"EventSources"},"ListFunctions":{"input_token":"Marker","output_token":"NextMarker","limit_key":"MaxItems","result_key":"Functions"}}}; + if (match === null) { + throwError(state, 'ill-formed argument of the YAML directive'); + } -/***/ }), + major = parseInt(match[1], 10); + minor = parseInt(match[2], 10); -/***/ 2873: -/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) { + if (major !== 1) { + throwError(state, 'unacceptable YAML version of the document'); + } -var AWS = __webpack_require__(395); + state.version = args[0]; + state.checkLineBreaks = (minor < 2); -/** - * @api private - */ -var blobPayloadOutputOps = [ - 'deleteThingShadow', - 'getThingShadow', - 'updateThingShadow' -]; + if (minor !== 1 && minor !== 2) { + throwWarning(state, 'unsupported YAML version of the document'); + } + }, -/** - * Constructs a service interface object. Each API operation is exposed as a - * function on service. - * - * ### Sending a Request Using IotData - * - * ```javascript - * var iotdata = new AWS.IotData({endpoint: 'my.host.tld'}); - * iotdata.getThingShadow(params, function (err, data) { - * if (err) console.log(err, err.stack); // an error occurred - * else console.log(data); // successful response - * }); - * ``` - * - * ### Locking the API Version - * - * In order to ensure that the IotData object uses this specific API, - * you can construct the object by passing the `apiVersion` option to the - * constructor: - * - * ```javascript - * var iotdata = new AWS.IotData({ - * endpoint: 'my.host.tld', - * apiVersion: '2015-05-28' - * }); - * ``` - * - * You can also set the API version globally in `AWS.config.apiVersions` using - * the **iotdata** service identifier: - * - * ```javascript - * AWS.config.apiVersions = { - * iotdata: '2015-05-28', - * // other service API versions - * }; - * - * var iotdata = new AWS.IotData({endpoint: 'my.host.tld'}); - * ``` - * - * @note You *must* provide an `endpoint` configuration parameter when - * constructing this service. See {constructor} for more information. - * - * @!method constructor(options = {}) - * Constructs a service object. This object has one method for each - * API operation. - * - * @example Constructing a IotData object - * var iotdata = new AWS.IotData({endpoint: 'my.host.tld'}); - * @note You *must* provide an `endpoint` when constructing this service. - * @option (see AWS.Config.constructor) - * - * @service iotdata - * @version 2015-05-28 - */ -AWS.util.update(AWS.IotData.prototype, { - /** - * @api private - */ - validateService: function validateService() { - if (!this.config.endpoint || this.config.endpoint.indexOf('{') >= 0) { - var msg = 'AWS.IotData requires an explicit ' + - '`endpoint\' configuration option.'; - throw AWS.util.error(new Error(), - {name: 'InvalidEndpoint', message: msg}); - } - }, + TAG: function handleTagDirective(state, name, args) { - /** - * @api private - */ - setupRequestListeners: function setupRequestListeners(request) { - request.addListener('validateResponse', this.validateResponseBody); - if (blobPayloadOutputOps.indexOf(request.operation) > -1) { - request.addListener('extractData', AWS.util.convertPayloadToString); - } - }, + var handle, prefix; - /** - * @api private - */ - validateResponseBody: function validateResponseBody(resp) { - var body = resp.httpResponse.body.toString() || '{}'; - var bodyCheck = body.trim(); - if (!bodyCheck || bodyCheck.charAt(0) !== '{') { - resp.httpResponse.body = ''; - } + if (args.length !== 2) { + throwError(state, 'TAG directive accepts exactly two arguments'); } -}); - - -/***/ }), + handle = args[0]; + prefix = args[1]; -/***/ 2883: -/***/ (function(module, __unusedexports, __webpack_require__) { + if (!PATTERN_TAG_HANDLE.test(handle)) { + throwError(state, 'ill-formed tag handle (first argument) of the TAG directive'); + } -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; + if (_hasOwnProperty.call(state.tagMap, handle)) { + throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle'); + } -apiLoader.services['ssm'] = {}; -AWS.SSM = Service.defineService('ssm', ['2014-11-06']); -Object.defineProperty(apiLoader.services['ssm'], '2014-11-06', { - get: function get() { - var model = __webpack_require__(5948); - model.paginators = __webpack_require__(9836).pagination; - return model; - }, - enumerable: true, - configurable: true -}); + if (!PATTERN_TAG_URI.test(prefix)) { + throwError(state, 'ill-formed tag prefix (second argument) of the TAG directive'); + } -module.exports = AWS.SSM; + try { + prefix = decodeURIComponent(prefix); + } catch (err) { + throwError(state, 'tag prefix is malformed: ' + prefix); + } + state.tagMap[handle] = prefix; + } +}; -/***/ }), -/***/ 2884: -/***/ (function(module) { +function captureSegment(state, start, end, checkJson) { + var _position, _length, _character, _result; -// Generated by CoffeeScript 1.12.7 -(function() { - var XMLAttribute; + if (start < end) { + _result = state.input.slice(start, end); - module.exports = XMLAttribute = (function() { - function XMLAttribute(parent, name, value) { - this.options = parent.options; - this.stringify = parent.stringify; - if (name == null) { - throw new Error("Missing attribute name of element " + parent.name); - } - if (value == null) { - throw new Error("Missing attribute value for attribute " + name + " of element " + parent.name); + if (checkJson) { + for (_position = 0, _length = _result.length; _position < _length; _position += 1) { + _character = _result.charCodeAt(_position); + if (!(_character === 0x09 || + (0x20 <= _character && _character <= 0x10FFFF))) { + throwError(state, 'expected valid JSON character'); + } } - this.name = this.stringify.attName(name); - this.value = this.stringify.attValue(value); + } else if (PATTERN_NON_PRINTABLE.test(_result)) { + throwError(state, 'the stream contains non-printable characters'); } - XMLAttribute.prototype.clone = function() { - return Object.create(this); - }; + state.result += _result; + } +} - XMLAttribute.prototype.toString = function(options) { - return this.options.writer.set(options).attribute(this); - }; +function mergeMappings(state, destination, source, overridableKeys) { + var sourceKeys, key, index, quantity; - return XMLAttribute; + if (!common.isObject(source)) { + throwError(state, 'cannot merge mappings; the provided source object is unacceptable'); + } - })(); + sourceKeys = Object.keys(source); -}).call(this); + for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) { + key = sourceKeys[index]; + if (!_hasOwnProperty.call(destination, key)) { + setProperty(destination, key, source[key]); + overridableKeys[key] = true; + } + } +} -/***/ }), +function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, + startLine, startLineStart, startPos) { -/***/ 2904: -/***/ (function(module) { + var index, quantity; -module.exports = {"pagination":{"DescribeDBEngineVersions":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DBEngineVersions"},"DescribeDBInstances":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DBInstances"},"DescribeDBParameterGroups":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DBParameterGroups"},"DescribeDBParameters":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"Parameters"},"DescribeDBSecurityGroups":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DBSecurityGroups"},"DescribeDBSnapshots":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DBSnapshots"},"DescribeDBSubnetGroups":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DBSubnetGroups"},"DescribeEngineDefaultParameters":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"EngineDefaults.Marker","result_key":"EngineDefaults.Parameters"},"DescribeEventSubscriptions":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"EventSubscriptionsList"},"DescribeEvents":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"Events"},"DescribeOptionGroupOptions":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"OptionGroupOptions"},"DescribeOptionGroups":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"OptionGroupsList"},"DescribeOrderableDBInstanceOptions":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"OrderableDBInstanceOptions"},"DescribeReservedDBInstances":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"ReservedDBInstances"},"DescribeReservedDBInstancesOfferings":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"ReservedDBInstancesOfferings"},"ListTagsForResource":{"result_key":"TagList"}}}; + // The output is a plain object here, so keys can only be strings. + // We need to convert keyNode to a string, but doing so can hang the process + // (deeply nested arrays that explode exponentially using aliases). + if (Array.isArray(keyNode)) { + keyNode = Array.prototype.slice.call(keyNode); -/***/ }), + for (index = 0, quantity = keyNode.length; index < quantity; index += 1) { + if (Array.isArray(keyNode[index])) { + throwError(state, 'nested arrays are not supported inside keys'); + } -/***/ 2906: -/***/ (function(module, __unusedexports, __webpack_require__) { + if (typeof keyNode === 'object' && _class(keyNode[index]) === '[object Object]') { + keyNode[index] = '[object Object]'; + } + } + } -var AWS = __webpack_require__(395); -var inherit = AWS.util.inherit; + // Avoid code execution in load() via toString property + // (still use its own toString for arrays, timestamps, + // and whatever user schema extensions happen to have @@toStringTag) + if (typeof keyNode === 'object' && _class(keyNode) === '[object Object]') { + keyNode = '[object Object]'; + } -/** - * @api private - */ -AWS.Signers.V2 = inherit(AWS.Signers.RequestSigner, { - addAuthorization: function addAuthorization(credentials, date) { - - if (!date) date = AWS.util.date.getDate(); - var r = this.request; + keyNode = String(keyNode); - r.params.Timestamp = AWS.util.date.iso8601(date); - r.params.SignatureVersion = '2'; - r.params.SignatureMethod = 'HmacSHA256'; - r.params.AWSAccessKeyId = credentials.accessKeyId; + if (_result === null) { + _result = {}; + } - if (credentials.sessionToken) { - r.params.SecurityToken = credentials.sessionToken; + if (keyTag === 'tag:yaml.org,2002:merge') { + if (Array.isArray(valueNode)) { + for (index = 0, quantity = valueNode.length; index < quantity; index += 1) { + mergeMappings(state, _result, valueNode[index], overridableKeys); + } + } else { + mergeMappings(state, _result, valueNode, overridableKeys); + } + } else { + if (!state.json && + !_hasOwnProperty.call(overridableKeys, keyNode) && + _hasOwnProperty.call(_result, keyNode)) { + state.line = startLine || state.line; + state.lineStart = startLineStart || state.lineStart; + state.position = startPos || state.position; + throwError(state, 'duplicated mapping key'); } - delete r.params.Signature; // delete old Signature for re-signing - r.params.Signature = this.signature(credentials); - - r.body = AWS.util.queryParamsToString(r.params); - r.headers['Content-Length'] = r.body.length; - }, - - signature: function signature(credentials) { - return AWS.util.crypto.hmac(credentials.secretAccessKey, this.stringToSign(), 'base64'); - }, - - stringToSign: function stringToSign() { - var parts = []; - parts.push(this.request.method); - parts.push(this.request.endpoint.host.toLowerCase()); - parts.push(this.request.pathname()); - parts.push(AWS.util.queryParamsToString(this.request.params)); - return parts.join('\n'); + setProperty(_result, keyNode, valueNode); + delete overridableKeys[keyNode]; } -}); + return _result; +} -/** - * @api private - */ -module.exports = AWS.Signers.V2; +function readLineBreak(state) { + var ch; + ch = state.input.charCodeAt(state.position); -/***/ }), + if (ch === 0x0A/* LF */) { + state.position++; + } else if (ch === 0x0D/* CR */) { + state.position++; + if (state.input.charCodeAt(state.position) === 0x0A/* LF */) { + state.position++; + } + } else { + throwError(state, 'a line break is expected'); + } -/***/ 2907: -/***/ (function(module) { + state.line += 1; + state.lineStart = state.position; + state.firstTabInLine = -1; +} -module.exports = {"version":"2.0","metadata":{"apiVersion":"2017-07-25","endpointPrefix":"amplify","jsonVersion":"1.1","protocol":"rest-json","serviceAbbreviation":"Amplify","serviceFullName":"AWS Amplify","serviceId":"Amplify","signatureVersion":"v4","signingName":"amplify","uid":"amplify-2017-07-25"},"operations":{"CreateApp":{"http":{"requestUri":"/apps"},"input":{"type":"structure","required":["name"],"members":{"name":{},"description":{},"repository":{},"platform":{},"iamServiceRoleArn":{},"oauthToken":{"shape":"S7"},"accessToken":{"shape":"S8"},"environmentVariables":{"shape":"S9"},"enableBranchAutoBuild":{"type":"boolean"},"enableBranchAutoDeletion":{"type":"boolean"},"enableBasicAuth":{"type":"boolean"},"basicAuthCredentials":{"shape":"Sf"},"customRules":{"shape":"Sg"},"tags":{"shape":"Sm"},"buildSpec":{},"enableAutoBranchCreation":{"type":"boolean"},"autoBranchCreationPatterns":{"shape":"Sr"},"autoBranchCreationConfig":{"shape":"St"}}},"output":{"type":"structure","required":["app"],"members":{"app":{"shape":"S10"}}}},"CreateBackendEnvironment":{"http":{"requestUri":"/apps/{appId}/backendenvironments"},"input":{"type":"structure","required":["appId","environmentName"],"members":{"appId":{"location":"uri","locationName":"appId"},"environmentName":{},"stackName":{},"deploymentArtifacts":{}}},"output":{"type":"structure","required":["backendEnvironment"],"members":{"backendEnvironment":{"shape":"S1f"}}}},"CreateBranch":{"http":{"requestUri":"/apps/{appId}/branches"},"input":{"type":"structure","required":["appId","branchName"],"members":{"appId":{"location":"uri","locationName":"appId"},"branchName":{},"description":{},"stage":{},"framework":{},"enableNotification":{"type":"boolean"},"enableAutoBuild":{"type":"boolean"},"environmentVariables":{"shape":"S9"},"basicAuthCredentials":{"shape":"Sf"},"enableBasicAuth":{"type":"boolean"},"tags":{"shape":"Sm"},"buildSpec":{},"ttl":{},"displayName":{},"enablePullRequestPreview":{"type":"boolean"},"pullRequestEnvironmentName":{},"backendEnvironmentArn":{}}},"output":{"type":"structure","required":["branch"],"members":{"branch":{"shape":"S1m"}}}},"CreateDeployment":{"http":{"requestUri":"/apps/{appId}/branches/{branchName}/deployments"},"input":{"type":"structure","required":["appId","branchName"],"members":{"appId":{"location":"uri","locationName":"appId"},"branchName":{"location":"uri","locationName":"branchName"},"fileMap":{"type":"map","key":{},"value":{}}}},"output":{"type":"structure","required":["fileUploadUrls","zipUploadUrl"],"members":{"jobId":{},"fileUploadUrls":{"type":"map","key":{},"value":{}},"zipUploadUrl":{}}}},"CreateDomainAssociation":{"http":{"requestUri":"/apps/{appId}/domains"},"input":{"type":"structure","required":["appId","domainName","subDomainSettings"],"members":{"appId":{"location":"uri","locationName":"appId"},"domainName":{},"enableAutoSubDomain":{"type":"boolean"},"subDomainSettings":{"shape":"S25"},"autoSubDomainCreationPatterns":{"shape":"S28"},"autoSubDomainIAMRole":{}}},"output":{"type":"structure","required":["domainAssociation"],"members":{"domainAssociation":{"shape":"S2c"}}}},"CreateWebhook":{"http":{"requestUri":"/apps/{appId}/webhooks"},"input":{"type":"structure","required":["appId","branchName"],"members":{"appId":{"location":"uri","locationName":"appId"},"branchName":{},"description":{}}},"output":{"type":"structure","required":["webhook"],"members":{"webhook":{"shape":"S2n"}}}},"DeleteApp":{"http":{"method":"DELETE","requestUri":"/apps/{appId}"},"input":{"type":"structure","required":["appId"],"members":{"appId":{"location":"uri","locationName":"appId"}}},"output":{"type":"structure","required":["app"],"members":{"app":{"shape":"S10"}}}},"DeleteBackendEnvironment":{"http":{"method":"DELETE","requestUri":"/apps/{appId}/backendenvironments/{environmentName}"},"input":{"type":"structure","required":["appId","environmentName"],"members":{"appId":{"location":"uri","locationName":"appId"},"environmentName":{"location":"uri","locationName":"environmentName"}}},"output":{"type":"structure","required":["backendEnvironment"],"members":{"backendEnvironment":{"shape":"S1f"}}}},"DeleteBranch":{"http":{"method":"DELETE","requestUri":"/apps/{appId}/branches/{branchName}"},"input":{"type":"structure","required":["appId","branchName"],"members":{"appId":{"location":"uri","locationName":"appId"},"branchName":{"location":"uri","locationName":"branchName"}}},"output":{"type":"structure","required":["branch"],"members":{"branch":{"shape":"S1m"}}}},"DeleteDomainAssociation":{"http":{"method":"DELETE","requestUri":"/apps/{appId}/domains/{domainName}"},"input":{"type":"structure","required":["appId","domainName"],"members":{"appId":{"location":"uri","locationName":"appId"},"domainName":{"location":"uri","locationName":"domainName"}}},"output":{"type":"structure","required":["domainAssociation"],"members":{"domainAssociation":{"shape":"S2c"}}}},"DeleteJob":{"http":{"method":"DELETE","requestUri":"/apps/{appId}/branches/{branchName}/jobs/{jobId}"},"input":{"type":"structure","required":["appId","branchName","jobId"],"members":{"appId":{"location":"uri","locationName":"appId"},"branchName":{"location":"uri","locationName":"branchName"},"jobId":{"location":"uri","locationName":"jobId"}}},"output":{"type":"structure","required":["jobSummary"],"members":{"jobSummary":{"shape":"S31"}}}},"DeleteWebhook":{"http":{"method":"DELETE","requestUri":"/webhooks/{webhookId}"},"input":{"type":"structure","required":["webhookId"],"members":{"webhookId":{"location":"uri","locationName":"webhookId"}}},"output":{"type":"structure","required":["webhook"],"members":{"webhook":{"shape":"S2n"}}}},"GenerateAccessLogs":{"http":{"requestUri":"/apps/{appId}/accesslogs"},"input":{"type":"structure","required":["domainName","appId"],"members":{"startTime":{"type":"timestamp"},"endTime":{"type":"timestamp"},"domainName":{},"appId":{"location":"uri","locationName":"appId"}}},"output":{"type":"structure","members":{"logUrl":{}}}},"GetApp":{"http":{"method":"GET","requestUri":"/apps/{appId}"},"input":{"type":"structure","required":["appId"],"members":{"appId":{"location":"uri","locationName":"appId"}}},"output":{"type":"structure","required":["app"],"members":{"app":{"shape":"S10"}}}},"GetArtifactUrl":{"http":{"method":"GET","requestUri":"/artifacts/{artifactId}"},"input":{"type":"structure","required":["artifactId"],"members":{"artifactId":{"location":"uri","locationName":"artifactId"}}},"output":{"type":"structure","required":["artifactId","artifactUrl"],"members":{"artifactId":{},"artifactUrl":{}}}},"GetBackendEnvironment":{"http":{"method":"GET","requestUri":"/apps/{appId}/backendenvironments/{environmentName}"},"input":{"type":"structure","required":["appId","environmentName"],"members":{"appId":{"location":"uri","locationName":"appId"},"environmentName":{"location":"uri","locationName":"environmentName"}}},"output":{"type":"structure","required":["backendEnvironment"],"members":{"backendEnvironment":{"shape":"S1f"}}}},"GetBranch":{"http":{"method":"GET","requestUri":"/apps/{appId}/branches/{branchName}"},"input":{"type":"structure","required":["appId","branchName"],"members":{"appId":{"location":"uri","locationName":"appId"},"branchName":{"location":"uri","locationName":"branchName"}}},"output":{"type":"structure","required":["branch"],"members":{"branch":{"shape":"S1m"}}}},"GetDomainAssociation":{"http":{"method":"GET","requestUri":"/apps/{appId}/domains/{domainName}"},"input":{"type":"structure","required":["appId","domainName"],"members":{"appId":{"location":"uri","locationName":"appId"},"domainName":{"location":"uri","locationName":"domainName"}}},"output":{"type":"structure","required":["domainAssociation"],"members":{"domainAssociation":{"shape":"S2c"}}}},"GetJob":{"http":{"method":"GET","requestUri":"/apps/{appId}/branches/{branchName}/jobs/{jobId}"},"input":{"type":"structure","required":["appId","branchName","jobId"],"members":{"appId":{"location":"uri","locationName":"appId"},"branchName":{"location":"uri","locationName":"branchName"},"jobId":{"location":"uri","locationName":"jobId"}}},"output":{"type":"structure","required":["job"],"members":{"job":{"type":"structure","required":["summary","steps"],"members":{"summary":{"shape":"S31"},"steps":{"type":"list","member":{"type":"structure","required":["stepName","startTime","status","endTime"],"members":{"stepName":{},"startTime":{"type":"timestamp"},"status":{},"endTime":{"type":"timestamp"},"logUrl":{},"artifactsUrl":{},"testArtifactsUrl":{},"testConfigUrl":{},"screenshots":{"type":"map","key":{},"value":{}},"statusReason":{},"context":{}}}}}}}}},"GetWebhook":{"http":{"method":"GET","requestUri":"/webhooks/{webhookId}"},"input":{"type":"structure","required":["webhookId"],"members":{"webhookId":{"location":"uri","locationName":"webhookId"}}},"output":{"type":"structure","required":["webhook"],"members":{"webhook":{"shape":"S2n"}}}},"ListApps":{"http":{"method":"GET","requestUri":"/apps"},"input":{"type":"structure","members":{"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","required":["apps"],"members":{"apps":{"type":"list","member":{"shape":"S10"}},"nextToken":{}}}},"ListArtifacts":{"http":{"method":"GET","requestUri":"/apps/{appId}/branches/{branchName}/jobs/{jobId}/artifacts"},"input":{"type":"structure","required":["appId","branchName","jobId"],"members":{"appId":{"location":"uri","locationName":"appId"},"branchName":{"location":"uri","locationName":"branchName"},"jobId":{"location":"uri","locationName":"jobId"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","required":["artifacts"],"members":{"artifacts":{"type":"list","member":{"type":"structure","required":["artifactFileName","artifactId"],"members":{"artifactFileName":{},"artifactId":{}}}},"nextToken":{}}}},"ListBackendEnvironments":{"http":{"method":"GET","requestUri":"/apps/{appId}/backendenvironments"},"input":{"type":"structure","required":["appId"],"members":{"appId":{"location":"uri","locationName":"appId"},"environmentName":{"location":"querystring","locationName":"environmentName"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","required":["backendEnvironments"],"members":{"backendEnvironments":{"type":"list","member":{"shape":"S1f"}},"nextToken":{}}}},"ListBranches":{"http":{"method":"GET","requestUri":"/apps/{appId}/branches"},"input":{"type":"structure","required":["appId"],"members":{"appId":{"location":"uri","locationName":"appId"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","required":["branches"],"members":{"branches":{"type":"list","member":{"shape":"S1m"}},"nextToken":{}}}},"ListDomainAssociations":{"http":{"method":"GET","requestUri":"/apps/{appId}/domains"},"input":{"type":"structure","required":["appId"],"members":{"appId":{"location":"uri","locationName":"appId"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","required":["domainAssociations"],"members":{"domainAssociations":{"type":"list","member":{"shape":"S2c"}},"nextToken":{}}}},"ListJobs":{"http":{"method":"GET","requestUri":"/apps/{appId}/branches/{branchName}/jobs"},"input":{"type":"structure","required":["appId","branchName"],"members":{"appId":{"location":"uri","locationName":"appId"},"branchName":{"location":"uri","locationName":"branchName"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","required":["jobSummaries"],"members":{"jobSummaries":{"type":"list","member":{"shape":"S31"}},"nextToken":{}}}},"ListTagsForResource":{"http":{"method":"GET","requestUri":"/tags/{resourceArn}"},"input":{"type":"structure","required":["resourceArn"],"members":{"resourceArn":{"location":"uri","locationName":"resourceArn"}}},"output":{"type":"structure","members":{"tags":{"shape":"Sm"}}}},"ListWebhooks":{"http":{"method":"GET","requestUri":"/apps/{appId}/webhooks"},"input":{"type":"structure","required":["appId"],"members":{"appId":{"location":"uri","locationName":"appId"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","required":["webhooks"],"members":{"webhooks":{"type":"list","member":{"shape":"S2n"}},"nextToken":{}}}},"StartDeployment":{"http":{"requestUri":"/apps/{appId}/branches/{branchName}/deployments/start"},"input":{"type":"structure","required":["appId","branchName"],"members":{"appId":{"location":"uri","locationName":"appId"},"branchName":{"location":"uri","locationName":"branchName"},"jobId":{},"sourceUrl":{}}},"output":{"type":"structure","required":["jobSummary"],"members":{"jobSummary":{"shape":"S31"}}}},"StartJob":{"http":{"requestUri":"/apps/{appId}/branches/{branchName}/jobs"},"input":{"type":"structure","required":["appId","branchName","jobType"],"members":{"appId":{"location":"uri","locationName":"appId"},"branchName":{"location":"uri","locationName":"branchName"},"jobId":{},"jobType":{},"jobReason":{},"commitId":{},"commitMessage":{},"commitTime":{"type":"timestamp"}}},"output":{"type":"structure","required":["jobSummary"],"members":{"jobSummary":{"shape":"S31"}}}},"StopJob":{"http":{"method":"DELETE","requestUri":"/apps/{appId}/branches/{branchName}/jobs/{jobId}/stop"},"input":{"type":"structure","required":["appId","branchName","jobId"],"members":{"appId":{"location":"uri","locationName":"appId"},"branchName":{"location":"uri","locationName":"branchName"},"jobId":{"location":"uri","locationName":"jobId"}}},"output":{"type":"structure","required":["jobSummary"],"members":{"jobSummary":{"shape":"S31"}}}},"TagResource":{"http":{"requestUri":"/tags/{resourceArn}"},"input":{"type":"structure","required":["resourceArn","tags"],"members":{"resourceArn":{"location":"uri","locationName":"resourceArn"},"tags":{"shape":"Sm"}}},"output":{"type":"structure","members":{}}},"UntagResource":{"http":{"method":"DELETE","requestUri":"/tags/{resourceArn}"},"input":{"type":"structure","required":["resourceArn","tagKeys"],"members":{"resourceArn":{"location":"uri","locationName":"resourceArn"},"tagKeys":{"location":"querystring","locationName":"tagKeys","type":"list","member":{}}}},"output":{"type":"structure","members":{}}},"UpdateApp":{"http":{"requestUri":"/apps/{appId}"},"input":{"type":"structure","required":["appId"],"members":{"appId":{"location":"uri","locationName":"appId"},"name":{},"description":{},"platform":{},"iamServiceRoleArn":{},"environmentVariables":{"shape":"S9"},"enableBranchAutoBuild":{"type":"boolean"},"enableBranchAutoDeletion":{"type":"boolean"},"enableBasicAuth":{"type":"boolean"},"basicAuthCredentials":{"shape":"Sf"},"customRules":{"shape":"Sg"},"buildSpec":{},"enableAutoBranchCreation":{"type":"boolean"},"autoBranchCreationPatterns":{"shape":"Sr"},"autoBranchCreationConfig":{"shape":"St"},"repository":{},"oauthToken":{"shape":"S7"},"accessToken":{"shape":"S8"}}},"output":{"type":"structure","required":["app"],"members":{"app":{"shape":"S10"}}}},"UpdateBranch":{"http":{"requestUri":"/apps/{appId}/branches/{branchName}"},"input":{"type":"structure","required":["appId","branchName"],"members":{"appId":{"location":"uri","locationName":"appId"},"branchName":{"location":"uri","locationName":"branchName"},"description":{},"framework":{},"stage":{},"enableNotification":{"type":"boolean"},"enableAutoBuild":{"type":"boolean"},"environmentVariables":{"shape":"S9"},"basicAuthCredentials":{"shape":"Sf"},"enableBasicAuth":{"type":"boolean"},"buildSpec":{},"ttl":{},"displayName":{},"enablePullRequestPreview":{"type":"boolean"},"pullRequestEnvironmentName":{},"backendEnvironmentArn":{}}},"output":{"type":"structure","required":["branch"],"members":{"branch":{"shape":"S1m"}}}},"UpdateDomainAssociation":{"http":{"requestUri":"/apps/{appId}/domains/{domainName}"},"input":{"type":"structure","required":["appId","domainName","subDomainSettings"],"members":{"appId":{"location":"uri","locationName":"appId"},"domainName":{"location":"uri","locationName":"domainName"},"enableAutoSubDomain":{"type":"boolean"},"subDomainSettings":{"shape":"S25"},"autoSubDomainCreationPatterns":{"shape":"S28"},"autoSubDomainIAMRole":{}}},"output":{"type":"structure","required":["domainAssociation"],"members":{"domainAssociation":{"shape":"S2c"}}}},"UpdateWebhook":{"http":{"requestUri":"/webhooks/{webhookId}"},"input":{"type":"structure","required":["webhookId"],"members":{"webhookId":{"location":"uri","locationName":"webhookId"},"branchName":{},"description":{}}},"output":{"type":"structure","required":["webhook"],"members":{"webhook":{"shape":"S2n"}}}}},"shapes":{"S7":{"type":"string","sensitive":true},"S8":{"type":"string","sensitive":true},"S9":{"type":"map","key":{},"value":{}},"Sf":{"type":"string","sensitive":true},"Sg":{"type":"list","member":{"type":"structure","required":["source","target"],"members":{"source":{},"target":{},"status":{},"condition":{}}}},"Sm":{"type":"map","key":{},"value":{}},"Sr":{"type":"list","member":{}},"St":{"type":"structure","members":{"stage":{},"framework":{},"enableAutoBuild":{"type":"boolean"},"environmentVariables":{"shape":"S9"},"basicAuthCredentials":{"shape":"Sf"},"enableBasicAuth":{"type":"boolean"},"buildSpec":{},"enablePullRequestPreview":{"type":"boolean"},"pullRequestEnvironmentName":{}}},"S10":{"type":"structure","required":["appId","appArn","name","description","repository","platform","createTime","updateTime","environmentVariables","defaultDomain","enableBranchAutoBuild","enableBasicAuth"],"members":{"appId":{},"appArn":{},"name":{},"tags":{"shape":"Sm"},"description":{},"repository":{},"platform":{},"createTime":{"type":"timestamp"},"updateTime":{"type":"timestamp"},"iamServiceRoleArn":{},"environmentVariables":{"shape":"S9"},"defaultDomain":{},"enableBranchAutoBuild":{"type":"boolean"},"enableBranchAutoDeletion":{"type":"boolean"},"enableBasicAuth":{"type":"boolean"},"basicAuthCredentials":{"shape":"Sf"},"customRules":{"shape":"Sg"},"productionBranch":{"type":"structure","members":{"lastDeployTime":{"type":"timestamp"},"status":{},"thumbnailUrl":{},"branchName":{}}},"buildSpec":{},"enableAutoBranchCreation":{"type":"boolean"},"autoBranchCreationPatterns":{"shape":"Sr"},"autoBranchCreationConfig":{"shape":"St"}}},"S1f":{"type":"structure","required":["backendEnvironmentArn","environmentName","createTime","updateTime"],"members":{"backendEnvironmentArn":{},"environmentName":{},"stackName":{},"deploymentArtifacts":{},"createTime":{"type":"timestamp"},"updateTime":{"type":"timestamp"}}},"S1m":{"type":"structure","required":["branchArn","branchName","description","stage","displayName","enableNotification","createTime","updateTime","environmentVariables","enableAutoBuild","customDomains","framework","activeJobId","totalNumberOfJobs","enableBasicAuth","ttl","enablePullRequestPreview"],"members":{"branchArn":{},"branchName":{},"description":{},"tags":{"shape":"Sm"},"stage":{},"displayName":{},"enableNotification":{"type":"boolean"},"createTime":{"type":"timestamp"},"updateTime":{"type":"timestamp"},"environmentVariables":{"shape":"S9"},"enableAutoBuild":{"type":"boolean"},"customDomains":{"type":"list","member":{}},"framework":{},"activeJobId":{},"totalNumberOfJobs":{},"enableBasicAuth":{"type":"boolean"},"thumbnailUrl":{},"basicAuthCredentials":{"shape":"Sf"},"buildSpec":{},"ttl":{},"associatedResources":{"type":"list","member":{}},"enablePullRequestPreview":{"type":"boolean"},"pullRequestEnvironmentName":{},"destinationBranch":{},"sourceBranch":{},"backendEnvironmentArn":{}}},"S25":{"type":"list","member":{"shape":"S26"}},"S26":{"type":"structure","required":["prefix","branchName"],"members":{"prefix":{},"branchName":{}}},"S28":{"type":"list","member":{}},"S2c":{"type":"structure","required":["domainAssociationArn","domainName","enableAutoSubDomain","domainStatus","statusReason","subDomains"],"members":{"domainAssociationArn":{},"domainName":{},"enableAutoSubDomain":{"type":"boolean"},"autoSubDomainCreationPatterns":{"shape":"S28"},"autoSubDomainIAMRole":{},"domainStatus":{},"statusReason":{},"certificateVerificationDNSRecord":{},"subDomains":{"type":"list","member":{"type":"structure","required":["subDomainSetting","verified","dnsRecord"],"members":{"subDomainSetting":{"shape":"S26"},"verified":{"type":"boolean"},"dnsRecord":{}}}}}},"S2n":{"type":"structure","required":["webhookArn","webhookId","webhookUrl","branchName","description","createTime","updateTime"],"members":{"webhookArn":{},"webhookId":{},"webhookUrl":{},"branchName":{},"description":{},"createTime":{"type":"timestamp"},"updateTime":{"type":"timestamp"}}},"S31":{"type":"structure","required":["jobArn","jobId","commitId","commitMessage","commitTime","startTime","status","jobType"],"members":{"jobArn":{},"jobId":{},"commitId":{},"commitMessage":{},"commitTime":{"type":"timestamp"},"startTime":{"type":"timestamp"},"status":{},"endTime":{"type":"timestamp"},"jobType":{}}}}}; +function skipSeparationSpace(state, allowComments, checkIndent) { + var lineBreaks = 0, + ch = state.input.charCodeAt(state.position); -/***/ }), + while (ch !== 0) { + while (is_WHITE_SPACE(ch)) { + if (ch === 0x09/* Tab */ && state.firstTabInLine === -1) { + state.firstTabInLine = state.position; + } + ch = state.input.charCodeAt(++state.position); + } -/***/ 2911: -/***/ (function(module) { + if (allowComments && ch === 0x23/* # */) { + do { + ch = state.input.charCodeAt(++state.position); + } while (ch !== 0x0A/* LF */ && ch !== 0x0D/* CR */ && ch !== 0); + } -module.exports = {"pagination":{"GetClassifiers":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"GetConnections":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"GetCrawlerMetrics":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"GetCrawlers":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"GetDatabases":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"GetDevEndpoints":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"GetJobRuns":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"GetJobs":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"GetMLTaskRuns":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"GetMLTransforms":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"GetPartitions":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"GetSecurityConfigurations":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"SecurityConfigurations"},"GetTableVersions":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"GetTables":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"GetTriggers":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"GetUserDefinedFunctions":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"GetWorkflowRuns":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"ListCrawlers":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"ListDevEndpoints":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"ListJobs":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"ListMLTransforms":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"ListTriggers":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"ListWorkflows":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"},"SearchTables":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"}}}; + if (is_EOL(ch)) { + readLineBreak(state); -/***/ }), + ch = state.input.charCodeAt(state.position); + lineBreaks++; + state.lineIndent = 0; -/***/ 2922: -/***/ (function(module) { + while (ch === 0x20/* Space */) { + state.lineIndent++; + ch = state.input.charCodeAt(++state.position); + } + } else { + break; + } + } -module.exports = {"metadata":{"apiVersion":"2018-05-14","endpointPrefix":"devices.iot1click","signingName":"iot1click","serviceFullName":"AWS IoT 1-Click Devices Service","serviceId":"IoT 1Click Devices Service","protocol":"rest-json","jsonVersion":"1.1","uid":"devices-2018-05-14","signatureVersion":"v4"},"operations":{"ClaimDevicesByClaimCode":{"http":{"method":"PUT","requestUri":"/claims/{claimCode}","responseCode":200},"input":{"type":"structure","members":{"ClaimCode":{"location":"uri","locationName":"claimCode"}},"required":["ClaimCode"]},"output":{"type":"structure","members":{"ClaimCode":{"locationName":"claimCode"},"Total":{"locationName":"total","type":"integer"}}}},"DescribeDevice":{"http":{"method":"GET","requestUri":"/devices/{deviceId}","responseCode":200},"input":{"type":"structure","members":{"DeviceId":{"location":"uri","locationName":"deviceId"}},"required":["DeviceId"]},"output":{"type":"structure","members":{"DeviceDescription":{"shape":"S8","locationName":"deviceDescription"}}}},"FinalizeDeviceClaim":{"http":{"method":"PUT","requestUri":"/devices/{deviceId}/finalize-claim","responseCode":200},"input":{"type":"structure","members":{"DeviceId":{"location":"uri","locationName":"deviceId"},"Tags":{"shape":"Sc","locationName":"tags"}},"required":["DeviceId"]},"output":{"type":"structure","members":{"State":{"locationName":"state"}}}},"GetDeviceMethods":{"http":{"method":"GET","requestUri":"/devices/{deviceId}/methods","responseCode":200},"input":{"type":"structure","members":{"DeviceId":{"location":"uri","locationName":"deviceId"}},"required":["DeviceId"]},"output":{"type":"structure","members":{"DeviceMethods":{"locationName":"deviceMethods","type":"list","member":{"shape":"Si"}}}}},"InitiateDeviceClaim":{"http":{"method":"PUT","requestUri":"/devices/{deviceId}/initiate-claim","responseCode":200},"input":{"type":"structure","members":{"DeviceId":{"location":"uri","locationName":"deviceId"}},"required":["DeviceId"]},"output":{"type":"structure","members":{"State":{"locationName":"state"}}}},"InvokeDeviceMethod":{"http":{"requestUri":"/devices/{deviceId}/methods","responseCode":200},"input":{"type":"structure","members":{"DeviceId":{"location":"uri","locationName":"deviceId"},"DeviceMethod":{"shape":"Si","locationName":"deviceMethod"},"DeviceMethodParameters":{"locationName":"deviceMethodParameters"}},"required":["DeviceId"]},"output":{"type":"structure","members":{"DeviceMethodResponse":{"locationName":"deviceMethodResponse"}}}},"ListDeviceEvents":{"http":{"method":"GET","requestUri":"/devices/{deviceId}/events","responseCode":200},"input":{"type":"structure","members":{"DeviceId":{"location":"uri","locationName":"deviceId"},"FromTimeStamp":{"shape":"So","location":"querystring","locationName":"fromTimeStamp"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"},"ToTimeStamp":{"shape":"So","location":"querystring","locationName":"toTimeStamp"}},"required":["DeviceId","FromTimeStamp","ToTimeStamp"]},"output":{"type":"structure","members":{"Events":{"locationName":"events","type":"list","member":{"type":"structure","members":{"Device":{"locationName":"device","type":"structure","members":{"Attributes":{"locationName":"attributes","type":"structure","members":{}},"DeviceId":{"locationName":"deviceId"},"Type":{"locationName":"type"}}},"StdEvent":{"locationName":"stdEvent"}}}},"NextToken":{"locationName":"nextToken"}}}},"ListDevices":{"http":{"method":"GET","requestUri":"/devices","responseCode":200},"input":{"type":"structure","members":{"DeviceType":{"location":"querystring","locationName":"deviceType"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"Devices":{"locationName":"devices","type":"list","member":{"shape":"S8"}},"NextToken":{"locationName":"nextToken"}}}},"ListTagsForResource":{"http":{"method":"GET","requestUri":"/tags/{resource-arn}","responseCode":200},"input":{"type":"structure","members":{"ResourceArn":{"location":"uri","locationName":"resource-arn"}},"required":["ResourceArn"]},"output":{"type":"structure","members":{"Tags":{"shape":"Sc","locationName":"tags"}}}},"TagResource":{"http":{"requestUri":"/tags/{resource-arn}","responseCode":204},"input":{"type":"structure","members":{"ResourceArn":{"location":"uri","locationName":"resource-arn"},"Tags":{"shape":"Sc","locationName":"tags"}},"required":["ResourceArn","Tags"]}},"UnclaimDevice":{"http":{"method":"PUT","requestUri":"/devices/{deviceId}/unclaim","responseCode":200},"input":{"type":"structure","members":{"DeviceId":{"location":"uri","locationName":"deviceId"}},"required":["DeviceId"]},"output":{"type":"structure","members":{"State":{"locationName":"state"}}}},"UntagResource":{"http":{"method":"DELETE","requestUri":"/tags/{resource-arn}","responseCode":204},"input":{"type":"structure","members":{"ResourceArn":{"location":"uri","locationName":"resource-arn"},"TagKeys":{"location":"querystring","locationName":"tagKeys","type":"list","member":{}}},"required":["TagKeys","ResourceArn"]}},"UpdateDeviceState":{"http":{"method":"PUT","requestUri":"/devices/{deviceId}/state","responseCode":200},"input":{"type":"structure","members":{"DeviceId":{"location":"uri","locationName":"deviceId"},"Enabled":{"locationName":"enabled","type":"boolean"}},"required":["DeviceId"]},"output":{"type":"structure","members":{}}}},"shapes":{"S8":{"type":"structure","members":{"Arn":{"locationName":"arn"},"Attributes":{"locationName":"attributes","type":"map","key":{},"value":{}},"DeviceId":{"locationName":"deviceId"},"Enabled":{"locationName":"enabled","type":"boolean"},"RemainingLife":{"locationName":"remainingLife","type":"double"},"Type":{"locationName":"type"},"Tags":{"shape":"Sc","locationName":"tags"}}},"Sc":{"type":"map","key":{},"value":{}},"Si":{"type":"structure","members":{"DeviceType":{"locationName":"deviceType"},"MethodName":{"locationName":"methodName"}}},"So":{"type":"timestamp","timestampFormat":"iso8601"}}}; + if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) { + throwWarning(state, 'deficient indentation'); + } -/***/ }), + return lineBreaks; +} -/***/ 2966: -/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) { +function testDocumentSeparator(state) { + var _position = state.position, + ch; -var AWS = __webpack_require__(395); -var STS = __webpack_require__(1733); + ch = state.input.charCodeAt(_position); -/** - * Represents credentials retrieved from STS SAML support. - * - * By default this provider gets credentials using the - * {AWS.STS.assumeRoleWithSAML} service operation. This operation - * requires a `RoleArn` containing the ARN of the IAM trust policy for the - * application for which credentials will be given, as well as a `PrincipalArn` - * representing the ARN for the SAML identity provider. In addition, the - * `SAMLAssertion` must be set to the token provided by the identity - * provider. See {constructor} for an example on creating a credentials - * object with proper `RoleArn`, `PrincipalArn`, and `SAMLAssertion` values. - * - * ## Refreshing Credentials from Identity Service - * - * In addition to AWS credentials expiring after a given amount of time, the - * login token from the identity provider will also expire. Once this token - * expires, it will not be usable to refresh AWS credentials, and another - * token will be needed. The SDK does not manage refreshing of the token value, - * but this can be done through a "refresh token" supported by most identity - * providers. Consult the documentation for the identity provider for refreshing - * tokens. Once the refreshed token is acquired, you should make sure to update - * this new token in the credentials object's {params} property. The following - * code will update the SAMLAssertion, assuming you have retrieved an updated - * token from the identity provider: - * - * ```javascript - * AWS.config.credentials.params.SAMLAssertion = updatedToken; - * ``` - * - * Future calls to `credentials.refresh()` will now use the new token. - * - * @!attribute params - * @return [map] the map of params passed to - * {AWS.STS.assumeRoleWithSAML}. To update the token, set the - * `params.SAMLAssertion` property. - */ -AWS.SAMLCredentials = AWS.util.inherit(AWS.Credentials, { - /** - * Creates a new credentials object. - * @param (see AWS.STS.assumeRoleWithSAML) - * @example Creating a new credentials object - * AWS.config.credentials = new AWS.SAMLCredentials({ - * RoleArn: 'arn:aws:iam::1234567890:role/SAMLRole', - * PrincipalArn: 'arn:aws:iam::1234567890:role/SAMLPrincipal', - * SAMLAssertion: 'base64-token', // base64-encoded token from IdP - * }); - * @see AWS.STS.assumeRoleWithSAML - */ - constructor: function SAMLCredentials(params) { - AWS.Credentials.call(this); - this.expired = true; - this.params = params; - }, + // Condition state.position === state.lineStart is tested + // in parent on each call, for efficiency. No needs to test here again. + if ((ch === 0x2D/* - */ || ch === 0x2E/* . */) && + ch === state.input.charCodeAt(_position + 1) && + ch === state.input.charCodeAt(_position + 2)) { - /** - * Refreshes credentials using {AWS.STS.assumeRoleWithSAML} - * - * @callback callback function(err) - * Called when the STS service responds (or fails). When - * this callback is called with no error, it means that the credentials - * information has been loaded into the object (as the `accessKeyId`, - * `secretAccessKey`, and `sessionToken` properties). - * @param err [Error] if an error occurred, this value will be filled - * @see get - */ - refresh: function refresh(callback) { - this.coalesceRefresh(callback || AWS.util.fn.callback); - }, + _position += 3; - /** - * @api private - */ - load: function load(callback) { - var self = this; - self.createClients(); - self.service.assumeRoleWithSAML(function (err, data) { - if (!err) { - self.service.credentialsFrom(data, self); - } - callback(err); - }); - }, + ch = state.input.charCodeAt(_position); - /** - * @api private - */ - createClients: function() { - this.service = this.service || new STS({params: this.params}); + if (ch === 0 || is_WS_OR_EOL(ch)) { + return true; + } } -}); + return false; +} +function writeFoldedLines(state, count) { + if (count === 1) { + state.result += ' '; + } else if (count > 1) { + state.result += common.repeat('\n', count - 1); + } +} -/***/ }), -/***/ 2971: -/***/ (function(module) { +function readPlainScalar(state, nodeIndent, withinFlowCollection) { + var preceding, + following, + captureStart, + captureEnd, + hasPendingContent, + _line, + _lineStart, + _lineIndent, + _kind = state.kind, + _result = state.result, + ch; -module.exports = {"pagination":{"ListApplicationRevisions":{"input_token":"nextToken","output_token":"nextToken","result_key":"revisions"},"ListApplications":{"input_token":"nextToken","output_token":"nextToken","result_key":"applications"},"ListDeploymentConfigs":{"input_token":"nextToken","output_token":"nextToken","result_key":"deploymentConfigsList"},"ListDeploymentGroups":{"input_token":"nextToken","output_token":"nextToken","result_key":"deploymentGroups"},"ListDeploymentInstances":{"input_token":"nextToken","output_token":"nextToken","result_key":"instancesList"},"ListDeployments":{"input_token":"nextToken","output_token":"nextToken","result_key":"deployments"}}}; + ch = state.input.charCodeAt(state.position); -/***/ }), + if (is_WS_OR_EOL(ch) || + is_FLOW_INDICATOR(ch) || + ch === 0x23/* # */ || + ch === 0x26/* & */ || + ch === 0x2A/* * */ || + ch === 0x21/* ! */ || + ch === 0x7C/* | */ || + ch === 0x3E/* > */ || + ch === 0x27/* ' */ || + ch === 0x22/* " */ || + ch === 0x25/* % */ || + ch === 0x40/* @ */ || + ch === 0x60/* ` */) { + return false; + } -/***/ 2982: -/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) { + if (ch === 0x3F/* ? */ || ch === 0x2D/* - */) { + following = state.input.charCodeAt(state.position + 1); -var AWS = __webpack_require__(395); -var proc = __webpack_require__(3129); -var iniLoader = AWS.util.iniLoader; + if (is_WS_OR_EOL(following) || + withinFlowCollection && is_FLOW_INDICATOR(following)) { + return false; + } + } -/** - * Represents credentials loaded from shared credentials file - * (defaulting to ~/.aws/credentials or defined by the - * `AWS_SHARED_CREDENTIALS_FILE` environment variable). - * - * ## Using process credentials - * - * The credentials file can specify a credential provider that executes - * a given process and attempts to read its stdout to recieve a JSON payload - * containing the credentials: - * - * [default] - * credential_process = /usr/bin/credential_proc - * - * Automatically handles refreshing credentials if an Expiration time is - * provided in the credentials payload. Credentials supplied in the same profile - * will take precedence over the credential_process. - * - * Sourcing credentials from an external process can potentially be dangerous, - * so proceed with caution. Other credential providers should be preferred if - * at all possible. If using this option, you should make sure that the shared - * credentials file is as locked down as possible using security best practices - * for your operating system. - * - * ## Using custom profiles - * - * The SDK supports loading credentials for separate profiles. This can be done - * in two ways: - * - * 1. Set the `AWS_PROFILE` environment variable in your process prior to - * loading the SDK. - * 2. Directly load the AWS.ProcessCredentials provider: - * - * ```javascript - * var creds = new AWS.ProcessCredentials({profile: 'myprofile'}); - * AWS.config.credentials = creds; - * ``` - * - * @!macro nobrowser - */ -AWS.ProcessCredentials = AWS.util.inherit(AWS.Credentials, { - /** - * Creates a new ProcessCredentials object. - * - * @param options [map] a set of options - * @option options profile [String] (AWS_PROFILE env var or 'default') - * the name of the profile to load. - * @option options filename [String] ('~/.aws/credentials' or defined by - * AWS_SHARED_CREDENTIALS_FILE process env var) - * the filename to use when loading credentials. - * @option options callback [Function] (err) Credentials are eagerly loaded - * by the constructor. When the callback is called with no error, the - * credentials have been loaded successfully. - */ - constructor: function ProcessCredentials(options) { - AWS.Credentials.call(this); + state.kind = 'scalar'; + state.result = ''; + captureStart = captureEnd = state.position; + hasPendingContent = false; - options = options || {}; + while (ch !== 0) { + if (ch === 0x3A/* : */) { + following = state.input.charCodeAt(state.position + 1); - this.filename = options.filename; - this.profile = options.profile || process.env.AWS_PROFILE || AWS.util.defaultProfile; - this.get(options.callback || AWS.util.fn.noop); - }, + if (is_WS_OR_EOL(following) || + withinFlowCollection && is_FLOW_INDICATOR(following)) { + break; + } - /** - * @api private - */ - load: function load(callback) { - var self = this; - try { - var profiles = AWS.util.getProfilesFromSharedConfig(iniLoader, this.filename); - var profile = profiles[this.profile] || {}; + } else if (ch === 0x23/* # */) { + preceding = state.input.charCodeAt(state.position - 1); - if (Object.keys(profile).length === 0) { - throw AWS.util.error( - new Error('Profile ' + this.profile + ' not found'), - { code: 'ProcessCredentialsProviderFailure' } - ); + if (is_WS_OR_EOL(preceding)) { + break; } - if (profile['credential_process']) { - this.loadViaCredentialProcess(profile, function(err, data) { - if (err) { - callback(err, null); - } else { - self.expired = false; - self.accessKeyId = data.AccessKeyId; - self.secretAccessKey = data.SecretAccessKey; - self.sessionToken = data.SessionToken; - if (data.Expiration) { - self.expireTime = new Date(data.Expiration); - } - callback(null); - } - }); + } else if ((state.position === state.lineStart && testDocumentSeparator(state)) || + withinFlowCollection && is_FLOW_INDICATOR(ch)) { + break; + + } else if (is_EOL(ch)) { + _line = state.line; + _lineStart = state.lineStart; + _lineIndent = state.lineIndent; + skipSeparationSpace(state, false, -1); + + if (state.lineIndent >= nodeIndent) { + hasPendingContent = true; + ch = state.input.charCodeAt(state.position); + continue; } else { - throw AWS.util.error( - new Error('Profile ' + this.profile + ' did not include credential process'), - { code: 'ProcessCredentialsProviderFailure' } - ); + state.position = captureEnd; + state.line = _line; + state.lineStart = _lineStart; + state.lineIndent = _lineIndent; + break; } - } catch (err) { - callback(err); } - }, - /** - * Executes the credential_process and retrieves - * credentials from the output - * @api private - * @param profile [map] credentials profile - * @throws ProcessCredentialsProviderFailure - */ - loadViaCredentialProcess: function loadViaCredentialProcess(profile, callback) { - proc.exec(profile['credential_process'], function(err, stdOut, stdErr) { - if (err) { - callback(AWS.util.error( - new Error('credential_process returned error'), - { code: 'ProcessCredentialsProviderFailure'} - ), null); - } else { - try { - var credData = JSON.parse(stdOut); - if (credData.Expiration) { - var currentTime = AWS.util.date.getDate(); - var expireTime = new Date(credData.Expiration); - if (expireTime < currentTime) { - throw Error('credential_process returned expired credentials'); - } - } + if (hasPendingContent) { + captureSegment(state, captureStart, captureEnd, false); + writeFoldedLines(state, state.line - _line); + captureStart = captureEnd = state.position; + hasPendingContent = false; + } - if (credData.Version !== 1) { - throw Error('credential_process does not return Version == 1'); - } - callback(null, credData); - } catch (err) { - callback(AWS.util.error( - new Error(err.message), - { code: 'ProcessCredentialsProviderFailure'} - ), null); - } - } - }); - }, + if (!is_WHITE_SPACE(ch)) { + captureEnd = state.position + 1; + } - /** - * Loads the credentials from the credential process - * - * @callback callback function(err) - * Called after the credential process has been executed. When this - * callback is called with no error, it means that the credentials - * information has been loaded into the object (as the `accessKeyId`, - * `secretAccessKey`, and `sessionToken` properties). - * @param err [Error] if an error occurred, this value will be filled - * @see get - */ - refresh: function refresh(callback) { - iniLoader.clearCachedFiles(); - this.coalesceRefresh(callback || AWS.util.fn.callback); + ch = state.input.charCodeAt(++state.position); } -}); + captureSegment(state, captureStart, captureEnd, false); -/***/ }), - -/***/ 3034: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2017-04-28","endpointPrefix":"cloudhsmv2","jsonVersion":"1.1","protocol":"json","serviceAbbreviation":"CloudHSM V2","serviceFullName":"AWS CloudHSM V2","serviceId":"CloudHSM V2","signatureVersion":"v4","signingName":"cloudhsm","targetPrefix":"BaldrApiService","uid":"cloudhsmv2-2017-04-28"},"operations":{"CopyBackupToRegion":{"input":{"type":"structure","required":["DestinationRegion","BackupId"],"members":{"DestinationRegion":{},"BackupId":{},"TagList":{"shape":"S4"}}},"output":{"type":"structure","members":{"DestinationBackup":{"type":"structure","members":{"CreateTimestamp":{"type":"timestamp"},"SourceRegion":{},"SourceBackup":{},"SourceCluster":{}}}}}},"CreateCluster":{"input":{"type":"structure","required":["SubnetIds","HsmType"],"members":{"SubnetIds":{"type":"list","member":{}},"HsmType":{},"SourceBackupId":{},"TagList":{"shape":"S4"}}},"output":{"type":"structure","members":{"Cluster":{"shape":"Sh"}}}},"CreateHsm":{"input":{"type":"structure","required":["ClusterId","AvailabilityZone"],"members":{"ClusterId":{},"AvailabilityZone":{},"IpAddress":{}}},"output":{"type":"structure","members":{"Hsm":{"shape":"Sk"}}}},"DeleteBackup":{"input":{"type":"structure","required":["BackupId"],"members":{"BackupId":{}}},"output":{"type":"structure","members":{"Backup":{"shape":"S13"}}}},"DeleteCluster":{"input":{"type":"structure","required":["ClusterId"],"members":{"ClusterId":{}}},"output":{"type":"structure","members":{"Cluster":{"shape":"Sh"}}}},"DeleteHsm":{"input":{"type":"structure","required":["ClusterId"],"members":{"ClusterId":{},"HsmId":{},"EniId":{},"EniIp":{}}},"output":{"type":"structure","members":{"HsmId":{}}}},"DescribeBackups":{"input":{"type":"structure","members":{"NextToken":{},"MaxResults":{"type":"integer"},"Filters":{"shape":"S1c"},"SortAscending":{"type":"boolean"}}},"output":{"type":"structure","members":{"Backups":{"type":"list","member":{"shape":"S13"}},"NextToken":{}}}},"DescribeClusters":{"input":{"type":"structure","members":{"Filters":{"shape":"S1c"},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"Clusters":{"type":"list","member":{"shape":"Sh"}},"NextToken":{}}}},"InitializeCluster":{"input":{"type":"structure","required":["ClusterId","SignedCert","TrustAnchor"],"members":{"ClusterId":{},"SignedCert":{},"TrustAnchor":{}}},"output":{"type":"structure","members":{"State":{},"StateMessage":{}}}},"ListTags":{"input":{"type":"structure","required":["ResourceId"],"members":{"ResourceId":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","required":["TagList"],"members":{"TagList":{"shape":"S4"},"NextToken":{}}}},"RestoreBackup":{"input":{"type":"structure","required":["BackupId"],"members":{"BackupId":{}}},"output":{"type":"structure","members":{"Backup":{"shape":"S13"}}}},"TagResource":{"input":{"type":"structure","required":["ResourceId","TagList"],"members":{"ResourceId":{},"TagList":{"shape":"S4"}}},"output":{"type":"structure","members":{}}},"UntagResource":{"input":{"type":"structure","required":["ResourceId","TagKeyList"],"members":{"ResourceId":{},"TagKeyList":{"type":"list","member":{}}}},"output":{"type":"structure","members":{}}}},"shapes":{"S4":{"type":"list","member":{"type":"structure","required":["Key","Value"],"members":{"Key":{},"Value":{}}}},"Sh":{"type":"structure","members":{"BackupPolicy":{},"ClusterId":{},"CreateTimestamp":{"type":"timestamp"},"Hsms":{"type":"list","member":{"shape":"Sk"}},"HsmType":{},"PreCoPassword":{},"SecurityGroup":{},"SourceBackupId":{},"State":{},"StateMessage":{},"SubnetMapping":{"type":"map","key":{},"value":{}},"VpcId":{},"Certificates":{"type":"structure","members":{"ClusterCsr":{},"HsmCertificate":{},"AwsHardwareCertificate":{},"ManufacturerHardwareCertificate":{},"ClusterCertificate":{}}},"TagList":{"shape":"S4"}}},"Sk":{"type":"structure","required":["HsmId"],"members":{"AvailabilityZone":{},"ClusterId":{},"SubnetId":{},"EniId":{},"EniIp":{},"HsmId":{},"State":{},"StateMessage":{}}},"S13":{"type":"structure","required":["BackupId"],"members":{"BackupId":{},"BackupState":{},"ClusterId":{},"CreateTimestamp":{"type":"timestamp"},"CopyTimestamp":{"type":"timestamp"},"SourceRegion":{},"SourceBackup":{},"SourceCluster":{},"DeleteTimestamp":{"type":"timestamp"},"TagList":{"shape":"S4"}}},"S1c":{"type":"map","key":{},"value":{"type":"list","member":{}}}}}; - -/***/ }), + if (state.result) { + return true; + } -/***/ 3042: -/***/ (function(module, __unusedexports, __webpack_require__) { + state.kind = _kind; + state.result = _result; + return false; +} -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +function readSingleQuotedScalar(state, nodeIndent) { + var ch, + captureStart, captureEnd; -apiLoader.services['support'] = {}; -AWS.Support = Service.defineService('support', ['2013-04-15']); -Object.defineProperty(apiLoader.services['support'], '2013-04-15', { - get: function get() { - var model = __webpack_require__(1010); - model.paginators = __webpack_require__(32).pagination; - return model; - }, - enumerable: true, - configurable: true -}); + ch = state.input.charCodeAt(state.position); -module.exports = AWS.Support; + if (ch !== 0x27/* ' */) { + return false; + } + state.kind = 'scalar'; + state.result = ''; + state.position++; + captureStart = captureEnd = state.position; -/***/ }), + while ((ch = state.input.charCodeAt(state.position)) !== 0) { + if (ch === 0x27/* ' */) { + captureSegment(state, captureStart, state.position, true); + ch = state.input.charCodeAt(++state.position); -/***/ 3043: -/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) { + if (ch === 0x27/* ' */) { + captureStart = state.position; + state.position++; + captureEnd = state.position; + } else { + return true; + } -var AWS = __webpack_require__(395); -var STS = __webpack_require__(1733); + } else if (is_EOL(ch)) { + captureSegment(state, captureStart, captureEnd, true); + writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent)); + captureStart = captureEnd = state.position; -/** - * Represents temporary credentials retrieved from {AWS.STS}. Without any - * extra parameters, credentials will be fetched from the - * {AWS.STS.getSessionToken} operation. If an IAM role is provided, the - * {AWS.STS.assumeRole} operation will be used to fetch credentials for the - * role instead. - * - * @note AWS.TemporaryCredentials is deprecated, but remains available for - * backwards compatibility. {AWS.ChainableTemporaryCredentials} is the - * preferred class for temporary credentials. - * - * To setup temporary credentials, configure a set of master credentials - * using the standard credentials providers (environment, EC2 instance metadata, - * or from the filesystem), then set the global credentials to a new - * temporary credentials object: - * - * ```javascript - * // Note that environment credentials are loaded by default, - * // the following line is shown for clarity: - * AWS.config.credentials = new AWS.EnvironmentCredentials('AWS'); - * - * // Now set temporary credentials seeded from the master credentials - * AWS.config.credentials = new AWS.TemporaryCredentials(); - * - * // subsequent requests will now use temporary credentials from AWS STS. - * new AWS.S3().listBucket(function(err, data) { ... }); - * ``` - * - * @!attribute masterCredentials - * @return [AWS.Credentials] the master (non-temporary) credentials used to - * get and refresh temporary credentials from AWS STS. - * @note (see constructor) - */ -AWS.TemporaryCredentials = AWS.util.inherit(AWS.Credentials, { - /** - * Creates a new temporary credentials object. - * - * @note In order to create temporary credentials, you first need to have - * "master" credentials configured in {AWS.Config.credentials}. These - * master credentials are necessary to retrieve the temporary credentials, - * as well as refresh the credentials when they expire. - * @param params [map] a map of options that are passed to the - * {AWS.STS.assumeRole} or {AWS.STS.getSessionToken} operations. - * If a `RoleArn` parameter is passed in, credentials will be based on the - * IAM role. - * @param masterCredentials [AWS.Credentials] the master (non-temporary) credentials - * used to get and refresh temporary credentials from AWS STS. - * @example Creating a new credentials object for generic temporary credentials - * AWS.config.credentials = new AWS.TemporaryCredentials(); - * @example Creating a new credentials object for an IAM role - * AWS.config.credentials = new AWS.TemporaryCredentials({ - * RoleArn: 'arn:aws:iam::1234567890:role/TemporaryCredentials', - * }); - * @see AWS.STS.assumeRole - * @see AWS.STS.getSessionToken - */ - constructor: function TemporaryCredentials(params, masterCredentials) { - AWS.Credentials.call(this); - this.loadMasterCredentials(masterCredentials); - this.expired = true; + } else if (state.position === state.lineStart && testDocumentSeparator(state)) { + throwError(state, 'unexpected end of the document within a single quoted scalar'); - this.params = params || {}; - if (this.params.RoleArn) { - this.params.RoleSessionName = - this.params.RoleSessionName || 'temporary-credentials'; + } else { + state.position++; + captureEnd = state.position; } - }, - - /** - * Refreshes credentials using {AWS.STS.assumeRole} or - * {AWS.STS.getSessionToken}, depending on whether an IAM role ARN was passed - * to the credentials {constructor}. - * - * @callback callback function(err) - * Called when the STS service responds (or fails). When - * this callback is called with no error, it means that the credentials - * information has been loaded into the object (as the `accessKeyId`, - * `secretAccessKey`, and `sessionToken` properties). - * @param err [Error] if an error occurred, this value will be filled - * @see get - */ - refresh: function refresh (callback) { - this.coalesceRefresh(callback || AWS.util.fn.callback); - }, + } - /** - * @api private - */ - load: function load (callback) { - var self = this; - self.createClients(); - self.masterCredentials.get(function () { - self.service.config.credentials = self.masterCredentials; - var operation = self.params.RoleArn ? - self.service.assumeRole : self.service.getSessionToken; - operation.call(self.service, function (err, data) { - if (!err) { - self.service.credentialsFrom(data, self); - } - callback(err); - }); - }); - }, + throwError(state, 'unexpected end of the stream within a single quoted scalar'); +} - /** - * @api private - */ - loadMasterCredentials: function loadMasterCredentials (masterCredentials) { - this.masterCredentials = masterCredentials || AWS.config.credentials; - while (this.masterCredentials.masterCredentials) { - this.masterCredentials = this.masterCredentials.masterCredentials; - } +function readDoubleQuotedScalar(state, nodeIndent) { + var captureStart, + captureEnd, + hexLength, + hexResult, + tmp, + ch; - if (typeof this.masterCredentials.get !== 'function') { - this.masterCredentials = new AWS.Credentials(this.masterCredentials); - } - }, + ch = state.input.charCodeAt(state.position); - /** - * @api private - */ - createClients: function () { - this.service = this.service || new STS({params: this.params}); + if (ch !== 0x22/* " */) { + return false; } -}); + state.kind = 'scalar'; + state.result = ''; + state.position++; + captureStart = captureEnd = state.position; + while ((ch = state.input.charCodeAt(state.position)) !== 0) { + if (ch === 0x22/* " */) { + captureSegment(state, captureStart, state.position, true); + state.position++; + return true; -/***/ }), + } else if (ch === 0x5C/* \ */) { + captureSegment(state, captureStart, state.position, true); + ch = state.input.charCodeAt(++state.position); -/***/ 3080: -/***/ (function(module) { + if (is_EOL(ch)) { + skipSeparationSpace(state, false, nodeIndent); -module.exports = {"pagination":{"ListApplicationVersions":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxItems"},"ListApplications":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxItems"},"ListApplicationDependencies":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxItems"}}}; + // TODO: rework to inline fn with no type cast? + } else if (ch < 256 && simpleEscapeCheck[ch]) { + state.result += simpleEscapeMap[ch]; + state.position++; -/***/ }), + } else if ((tmp = escapedHexLen(ch)) > 0) { + hexLength = tmp; + hexResult = 0; -/***/ 3091: -/***/ (function(module) { + for (; hexLength > 0; hexLength--) { + ch = state.input.charCodeAt(++state.position); -module.exports = {"pagination":{"ListComplianceStatus":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"PolicyComplianceStatusList"},"ListMemberAccounts":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"MemberAccounts"},"ListPolicies":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"PolicyList"}}}; + if ((tmp = fromHexCode(ch)) >= 0) { + hexResult = (hexResult << 4) + tmp; -/***/ }), + } else { + throwError(state, 'expected hexadecimal character'); + } + } -/***/ 3099: -/***/ (function(module, __unusedexports, __webpack_require__) { + state.result += charFromCodepoint(hexResult); -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; + state.position++; -apiLoader.services['autoscalingplans'] = {}; -AWS.AutoScalingPlans = Service.defineService('autoscalingplans', ['2018-01-06']); -Object.defineProperty(apiLoader.services['autoscalingplans'], '2018-01-06', { - get: function get() { - var model = __webpack_require__(6631); - model.paginators = __webpack_require__(4344).pagination; - return model; - }, - enumerable: true, - configurable: true -}); + } else { + throwError(state, 'unknown escape sequence'); + } -module.exports = AWS.AutoScalingPlans; + captureStart = captureEnd = state.position; + } else if (is_EOL(ch)) { + captureSegment(state, captureStart, captureEnd, true); + writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent)); + captureStart = captureEnd = state.position; -/***/ }), + } else if (state.position === state.lineStart && testDocumentSeparator(state)) { + throwError(state, 'unexpected end of the document within a double quoted scalar'); -/***/ 3110: -/***/ (function(module, __unusedexports, __webpack_require__) { + } else { + state.position++; + captureEnd = state.position; + } + } -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; + throwError(state, 'unexpected end of the stream within a double quoted scalar'); +} -apiLoader.services['licensemanager'] = {}; -AWS.LicenseManager = Service.defineService('licensemanager', ['2018-08-01']); -Object.defineProperty(apiLoader.services['licensemanager'], '2018-08-01', { - get: function get() { - var model = __webpack_require__(3605); - model.paginators = __webpack_require__(3209).pagination; - return model; - }, - enumerable: true, - configurable: true -}); +function readFlowCollection(state, nodeIndent) { + var readNext = true, + _line, + _lineStart, + _pos, + _tag = state.tag, + _result, + _anchor = state.anchor, + following, + terminator, + isPair, + isExplicitPair, + isMapping, + overridableKeys = Object.create(null), + keyNode, + keyTag, + valueNode, + ch; -module.exports = AWS.LicenseManager; + ch = state.input.charCodeAt(state.position); + if (ch === 0x5B/* [ */) { + terminator = 0x5D;/* ] */ + isMapping = false; + _result = []; + } else if (ch === 0x7B/* { */) { + terminator = 0x7D;/* } */ + isMapping = true; + _result = {}; + } else { + return false; + } -/***/ }), + if (state.anchor !== null) { + state.anchorMap[state.anchor] = _result; + } -/***/ 3129: -/***/ (function(module) { + ch = state.input.charCodeAt(++state.position); -module.exports = require("child_process"); + while (ch !== 0) { + skipSeparationSpace(state, true, nodeIndent); -/***/ }), + ch = state.input.charCodeAt(state.position); -/***/ 3132: -/***/ (function(module) { + if (ch === terminator) { + state.position++; + state.tag = _tag; + state.anchor = _anchor; + state.kind = isMapping ? 'mapping' : 'sequence'; + state.result = _result; + return true; + } else if (!readNext) { + throwError(state, 'missed comma between flow collection entries'); + } else if (ch === 0x2C/* , */) { + // "flow collection entries can never be completely empty", as per YAML 1.2, section 7.4 + throwError(state, "expected the node content, but found ','"); + } -module.exports = {"version":"2.0","metadata":{"apiVersion":"2016-06-10","endpointPrefix":"polly","protocol":"rest-json","serviceFullName":"Amazon Polly","serviceId":"Polly","signatureVersion":"v4","uid":"polly-2016-06-10"},"operations":{"DeleteLexicon":{"http":{"method":"DELETE","requestUri":"/v1/lexicons/{LexiconName}","responseCode":200},"input":{"type":"structure","required":["Name"],"members":{"Name":{"shape":"S2","location":"uri","locationName":"LexiconName"}}},"output":{"type":"structure","members":{}}},"DescribeVoices":{"http":{"method":"GET","requestUri":"/v1/voices","responseCode":200},"input":{"type":"structure","members":{"Engine":{"location":"querystring","locationName":"Engine"},"LanguageCode":{"location":"querystring","locationName":"LanguageCode"},"IncludeAdditionalLanguageCodes":{"location":"querystring","locationName":"IncludeAdditionalLanguageCodes","type":"boolean"},"NextToken":{"location":"querystring","locationName":"NextToken"}}},"output":{"type":"structure","members":{"Voices":{"type":"list","member":{"type":"structure","members":{"Gender":{},"Id":{},"LanguageCode":{},"LanguageName":{},"Name":{},"AdditionalLanguageCodes":{"type":"list","member":{}},"SupportedEngines":{"type":"list","member":{}}}}},"NextToken":{}}}},"GetLexicon":{"http":{"method":"GET","requestUri":"/v1/lexicons/{LexiconName}","responseCode":200},"input":{"type":"structure","required":["Name"],"members":{"Name":{"shape":"S2","location":"uri","locationName":"LexiconName"}}},"output":{"type":"structure","members":{"Lexicon":{"type":"structure","members":{"Content":{},"Name":{"shape":"S2"}}},"LexiconAttributes":{"shape":"Sm"}}}},"GetSpeechSynthesisTask":{"http":{"method":"GET","requestUri":"/v1/synthesisTasks/{TaskId}","responseCode":200},"input":{"type":"structure","required":["TaskId"],"members":{"TaskId":{"location":"uri","locationName":"TaskId"}}},"output":{"type":"structure","members":{"SynthesisTask":{"shape":"Sv"}}}},"ListLexicons":{"http":{"method":"GET","requestUri":"/v1/lexicons","responseCode":200},"input":{"type":"structure","members":{"NextToken":{"location":"querystring","locationName":"NextToken"}}},"output":{"type":"structure","members":{"Lexicons":{"type":"list","member":{"type":"structure","members":{"Name":{"shape":"S2"},"Attributes":{"shape":"Sm"}}}},"NextToken":{}}}},"ListSpeechSynthesisTasks":{"http":{"method":"GET","requestUri":"/v1/synthesisTasks","responseCode":200},"input":{"type":"structure","members":{"MaxResults":{"location":"querystring","locationName":"MaxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"NextToken"},"Status":{"location":"querystring","locationName":"Status"}}},"output":{"type":"structure","members":{"NextToken":{},"SynthesisTasks":{"type":"list","member":{"shape":"Sv"}}}}},"PutLexicon":{"http":{"method":"PUT","requestUri":"/v1/lexicons/{LexiconName}","responseCode":200},"input":{"type":"structure","required":["Name","Content"],"members":{"Name":{"shape":"S2","location":"uri","locationName":"LexiconName"},"Content":{}}},"output":{"type":"structure","members":{}}},"StartSpeechSynthesisTask":{"http":{"requestUri":"/v1/synthesisTasks","responseCode":200},"input":{"type":"structure","required":["OutputFormat","OutputS3BucketName","Text","VoiceId"],"members":{"Engine":{},"LanguageCode":{},"LexiconNames":{"shape":"S12"},"OutputFormat":{},"OutputS3BucketName":{},"OutputS3KeyPrefix":{},"SampleRate":{},"SnsTopicArn":{},"SpeechMarkTypes":{"shape":"S15"},"Text":{},"TextType":{},"VoiceId":{}}},"output":{"type":"structure","members":{"SynthesisTask":{"shape":"Sv"}}}},"SynthesizeSpeech":{"http":{"requestUri":"/v1/speech","responseCode":200},"input":{"type":"structure","required":["OutputFormat","Text","VoiceId"],"members":{"Engine":{},"LanguageCode":{},"LexiconNames":{"shape":"S12"},"OutputFormat":{},"SampleRate":{},"SpeechMarkTypes":{"shape":"S15"},"Text":{},"TextType":{},"VoiceId":{}}},"output":{"type":"structure","members":{"AudioStream":{"type":"blob","streaming":true},"ContentType":{"location":"header","locationName":"Content-Type"},"RequestCharacters":{"location":"header","locationName":"x-amzn-RequestCharacters","type":"integer"}},"payload":"AudioStream"}}},"shapes":{"S2":{"type":"string","sensitive":true},"Sm":{"type":"structure","members":{"Alphabet":{},"LanguageCode":{},"LastModified":{"type":"timestamp"},"LexiconArn":{},"LexemesCount":{"type":"integer"},"Size":{"type":"integer"}}},"Sv":{"type":"structure","members":{"Engine":{},"TaskId":{},"TaskStatus":{},"TaskStatusReason":{},"OutputUri":{},"CreationTime":{"type":"timestamp"},"RequestCharacters":{"type":"integer"},"SnsTopicArn":{},"LexiconNames":{"shape":"S12"},"OutputFormat":{},"SampleRate":{},"SpeechMarkTypes":{"shape":"S15"},"TextType":{},"VoiceId":{},"LanguageCode":{}}},"S12":{"type":"list","member":{"shape":"S2"}},"S15":{"type":"list","member":{}}}}; + keyTag = keyNode = valueNode = null; + isPair = isExplicitPair = false; -/***/ }), + if (ch === 0x3F/* ? */) { + following = state.input.charCodeAt(state.position + 1); -/***/ 3137: -/***/ (function(module) { + if (is_WS_OR_EOL(following)) { + isPair = isExplicitPair = true; + state.position++; + skipSeparationSpace(state, true, nodeIndent); + } + } -module.exports = {"pagination":{"DescribeModelVersions":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"GetDetectors":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"GetEntityTypes":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"GetEventTypes":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"GetExternalModels":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"GetLabels":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"GetModels":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"GetOutcomes":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"GetRules":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"GetVariables":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"ListTagsForResource":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"}}}; + _line = state.line; // Save the current line. + _lineStart = state.lineStart; + _pos = state.position; + composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true); + keyTag = state.tag; + keyNode = state.result; + skipSeparationSpace(state, true, nodeIndent); -/***/ }), + ch = state.input.charCodeAt(state.position); -/***/ 3165: -/***/ (function(module) { + if ((isExplicitPair || state.line === _line) && ch === 0x3A/* : */) { + isPair = true; + ch = state.input.charCodeAt(++state.position); + skipSeparationSpace(state, true, nodeIndent); + composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true); + valueNode = state.result; + } -module.exports = {"version":"2.0","metadata":{"apiVersion":"2019-11-01","endpointPrefix":"compute-optimizer","jsonVersion":"1.0","protocol":"json","serviceFullName":"AWS Compute Optimizer","serviceId":"Compute Optimizer","signatureVersion":"v4","signingName":"compute-optimizer","targetPrefix":"ComputeOptimizerService","uid":"compute-optimizer-2019-11-01"},"operations":{"DescribeRecommendationExportJobs":{"input":{"type":"structure","members":{"jobIds":{"type":"list","member":{}},"filters":{"type":"list","member":{"type":"structure","members":{"name":{},"values":{"shape":"S7"}}}},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"recommendationExportJobs":{"type":"list","member":{"type":"structure","members":{"jobId":{},"destination":{"type":"structure","members":{"s3":{"shape":"Sf"}}},"resourceType":{},"status":{},"creationTimestamp":{"type":"timestamp"},"lastUpdatedTimestamp":{"type":"timestamp"},"failureReason":{}}}},"nextToken":{}}}},"ExportAutoScalingGroupRecommendations":{"input":{"type":"structure","required":["s3DestinationConfig"],"members":{"accountIds":{"shape":"Sp"},"filters":{"shape":"Sr"},"fieldsToExport":{"type":"list","member":{}},"s3DestinationConfig":{"shape":"Sw"},"fileFormat":{},"includeMemberAccounts":{"type":"boolean"}}},"output":{"type":"structure","members":{"jobId":{},"s3Destination":{"shape":"Sf"}}}},"ExportEC2InstanceRecommendations":{"input":{"type":"structure","required":["s3DestinationConfig"],"members":{"accountIds":{"shape":"Sp"},"filters":{"shape":"Sr"},"fieldsToExport":{"type":"list","member":{}},"s3DestinationConfig":{"shape":"Sw"},"fileFormat":{},"includeMemberAccounts":{"type":"boolean"}}},"output":{"type":"structure","members":{"jobId":{},"s3Destination":{"shape":"Sf"}}}},"GetAutoScalingGroupRecommendations":{"input":{"type":"structure","members":{"accountIds":{"shape":"Sp"},"autoScalingGroupArns":{"type":"list","member":{}},"nextToken":{},"maxResults":{"type":"integer"},"filters":{"shape":"Sr"}}},"output":{"type":"structure","members":{"nextToken":{},"autoScalingGroupRecommendations":{"type":"list","member":{"type":"structure","members":{"accountId":{},"autoScalingGroupArn":{},"autoScalingGroupName":{},"finding":{},"utilizationMetrics":{"shape":"S1d"},"lookBackPeriodInDays":{"type":"double"},"currentConfiguration":{"shape":"S1j"},"recommendationOptions":{"type":"list","member":{"type":"structure","members":{"configuration":{"shape":"S1j"},"projectedUtilizationMetrics":{"shape":"S1q"},"performanceRisk":{"type":"double"},"rank":{"type":"integer"}}}},"lastRefreshTimestamp":{"type":"timestamp"}}}},"errors":{"shape":"S1u"}}}},"GetEC2InstanceRecommendations":{"input":{"type":"structure","members":{"instanceArns":{"type":"list","member":{}},"nextToken":{},"maxResults":{"type":"integer"},"filters":{"shape":"Sr"},"accountIds":{"shape":"Sp"}}},"output":{"type":"structure","members":{"nextToken":{},"instanceRecommendations":{"type":"list","member":{"type":"structure","members":{"instanceArn":{},"accountId":{},"instanceName":{},"currentInstanceType":{},"finding":{},"utilizationMetrics":{"shape":"S1d"},"lookBackPeriodInDays":{"type":"double"},"recommendationOptions":{"type":"list","member":{"type":"structure","members":{"instanceType":{},"projectedUtilizationMetrics":{"shape":"S1q"},"performanceRisk":{"type":"double"},"rank":{"type":"integer"}}}},"recommendationSources":{"type":"list","member":{"type":"structure","members":{"recommendationSourceArn":{},"recommendationSourceType":{}}}},"lastRefreshTimestamp":{"type":"timestamp"}}}},"errors":{"shape":"S1u"}}}},"GetEC2RecommendationProjectedMetrics":{"input":{"type":"structure","required":["instanceArn","stat","period","startTime","endTime"],"members":{"instanceArn":{},"stat":{},"period":{"type":"integer"},"startTime":{"type":"timestamp"},"endTime":{"type":"timestamp"}}},"output":{"type":"structure","members":{"recommendedOptionProjectedMetrics":{"type":"list","member":{"type":"structure","members":{"recommendedInstanceType":{},"rank":{"type":"integer"},"projectedMetrics":{"type":"list","member":{"type":"structure","members":{"name":{},"timestamps":{"type":"list","member":{"type":"timestamp"}},"values":{"type":"list","member":{"type":"double"}}}}}}}}}}},"GetEnrollmentStatus":{"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"status":{},"statusReason":{},"memberAccountsEnrolled":{"type":"boolean"}}}},"GetRecommendationSummaries":{"input":{"type":"structure","members":{"accountIds":{"shape":"Sp"},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"nextToken":{},"recommendationSummaries":{"type":"list","member":{"type":"structure","members":{"summaries":{"type":"list","member":{"type":"structure","members":{"name":{},"value":{"type":"double"}}}},"recommendationResourceType":{},"accountId":{}}}}}}},"UpdateEnrollmentStatus":{"input":{"type":"structure","required":["status"],"members":{"status":{},"includeMemberAccounts":{"type":"boolean"}}},"output":{"type":"structure","members":{"status":{},"statusReason":{}}}}},"shapes":{"S7":{"type":"list","member":{}},"Sf":{"type":"structure","members":{"bucket":{},"key":{},"metadataKey":{}}},"Sp":{"type":"list","member":{}},"Sr":{"type":"list","member":{"type":"structure","members":{"name":{},"values":{"shape":"S7"}}}},"Sw":{"type":"structure","members":{"bucket":{},"keyPrefix":{}}},"S1d":{"type":"list","member":{"shape":"S1e"}},"S1e":{"type":"structure","members":{"name":{},"statistic":{},"value":{"type":"double"}}},"S1j":{"type":"structure","members":{"desiredCapacity":{"type":"integer"},"minSize":{"type":"integer"},"maxSize":{"type":"integer"},"instanceType":{}}},"S1q":{"type":"list","member":{"shape":"S1e"}},"S1u":{"type":"list","member":{"type":"structure","members":{"identifier":{},"code":{},"message":{}}}}}}; + if (isMapping) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos); + } else if (isPair) { + _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos)); + } else { + _result.push(keyNode); + } -/***/ }), + skipSeparationSpace(state, true, nodeIndent); -/***/ 3173: -/***/ (function(module) { + ch = state.input.charCodeAt(state.position); -module.exports = {"version":"2.0","metadata":{"apiVersion":"2017-11-27","endpointPrefix":"comprehend","jsonVersion":"1.1","protocol":"json","serviceFullName":"Amazon Comprehend","serviceId":"Comprehend","signatureVersion":"v4","signingName":"comprehend","targetPrefix":"Comprehend_20171127","uid":"comprehend-2017-11-27"},"operations":{"BatchDetectDominantLanguage":{"input":{"type":"structure","required":["TextList"],"members":{"TextList":{"shape":"S2"}}},"output":{"type":"structure","required":["ResultList","ErrorList"],"members":{"ResultList":{"type":"list","member":{"type":"structure","members":{"Index":{"type":"integer"},"Languages":{"shape":"S8"}}}},"ErrorList":{"shape":"Sc"}},"sensitive":true}},"BatchDetectEntities":{"input":{"type":"structure","required":["TextList","LanguageCode"],"members":{"TextList":{"shape":"S2"},"LanguageCode":{}}},"output":{"type":"structure","required":["ResultList","ErrorList"],"members":{"ResultList":{"type":"list","member":{"type":"structure","members":{"Index":{"type":"integer"},"Entities":{"shape":"Sj"}}}},"ErrorList":{"shape":"Sc"}},"sensitive":true}},"BatchDetectKeyPhrases":{"input":{"type":"structure","required":["TextList","LanguageCode"],"members":{"TextList":{"shape":"S2"},"LanguageCode":{}}},"output":{"type":"structure","required":["ResultList","ErrorList"],"members":{"ResultList":{"type":"list","member":{"type":"structure","members":{"Index":{"type":"integer"},"KeyPhrases":{"shape":"Sq"}}}},"ErrorList":{"shape":"Sc"}},"sensitive":true}},"BatchDetectSentiment":{"input":{"type":"structure","required":["TextList","LanguageCode"],"members":{"TextList":{"shape":"S2"},"LanguageCode":{}}},"output":{"type":"structure","required":["ResultList","ErrorList"],"members":{"ResultList":{"type":"list","member":{"type":"structure","members":{"Index":{"type":"integer"},"Sentiment":{},"SentimentScore":{"shape":"Sx"}}}},"ErrorList":{"shape":"Sc"}},"sensitive":true}},"BatchDetectSyntax":{"input":{"type":"structure","required":["TextList","LanguageCode"],"members":{"TextList":{"shape":"S2"},"LanguageCode":{}}},"output":{"type":"structure","required":["ResultList","ErrorList"],"members":{"ResultList":{"type":"list","member":{"type":"structure","members":{"Index":{"type":"integer"},"SyntaxTokens":{"shape":"S13"}}}},"ErrorList":{"shape":"Sc"}},"sensitive":true}},"ClassifyDocument":{"input":{"type":"structure","required":["Text","EndpointArn"],"members":{"Text":{"shape":"S3"},"EndpointArn":{}}},"output":{"type":"structure","members":{"Classes":{"type":"list","member":{"type":"structure","members":{"Name":{},"Score":{"type":"float"}}}},"Labels":{"type":"list","member":{"type":"structure","members":{"Name":{},"Score":{"type":"float"}}}}},"sensitive":true}},"CreateDocumentClassifier":{"input":{"type":"structure","required":["DocumentClassifierName","DataAccessRoleArn","InputDataConfig","LanguageCode"],"members":{"DocumentClassifierName":{},"DataAccessRoleArn":{},"Tags":{"shape":"S1h"},"InputDataConfig":{"shape":"S1l"},"OutputDataConfig":{"shape":"S1o"},"ClientRequestToken":{"idempotencyToken":true},"LanguageCode":{},"VolumeKmsKeyId":{},"VpcConfig":{"shape":"S1r"},"Mode":{}}},"output":{"type":"structure","members":{"DocumentClassifierArn":{}}}},"CreateEndpoint":{"input":{"type":"structure","required":["EndpointName","ModelArn","DesiredInferenceUnits"],"members":{"EndpointName":{},"ModelArn":{},"DesiredInferenceUnits":{"type":"integer"},"ClientRequestToken":{"idempotencyToken":true},"Tags":{"shape":"S1h"}}},"output":{"type":"structure","members":{"EndpointArn":{}}}},"CreateEntityRecognizer":{"input":{"type":"structure","required":["RecognizerName","DataAccessRoleArn","InputDataConfig","LanguageCode"],"members":{"RecognizerName":{},"DataAccessRoleArn":{},"Tags":{"shape":"S1h"},"InputDataConfig":{"shape":"S26"},"ClientRequestToken":{"idempotencyToken":true},"LanguageCode":{},"VolumeKmsKeyId":{},"VpcConfig":{"shape":"S1r"}}},"output":{"type":"structure","members":{"EntityRecognizerArn":{}}}},"DeleteDocumentClassifier":{"input":{"type":"structure","required":["DocumentClassifierArn"],"members":{"DocumentClassifierArn":{}}},"output":{"type":"structure","members":{}}},"DeleteEndpoint":{"input":{"type":"structure","required":["EndpointArn"],"members":{"EndpointArn":{}}},"output":{"type":"structure","members":{}}},"DeleteEntityRecognizer":{"input":{"type":"structure","required":["EntityRecognizerArn"],"members":{"EntityRecognizerArn":{}}},"output":{"type":"structure","members":{}}},"DescribeDocumentClassificationJob":{"input":{"type":"structure","required":["JobId"],"members":{"JobId":{}}},"output":{"type":"structure","members":{"DocumentClassificationJobProperties":{"shape":"S2o"}}}},"DescribeDocumentClassifier":{"input":{"type":"structure","required":["DocumentClassifierArn"],"members":{"DocumentClassifierArn":{}}},"output":{"type":"structure","members":{"DocumentClassifierProperties":{"shape":"S2y"}}}},"DescribeDominantLanguageDetectionJob":{"input":{"type":"structure","required":["JobId"],"members":{"JobId":{}}},"output":{"type":"structure","members":{"DominantLanguageDetectionJobProperties":{"shape":"S35"}}}},"DescribeEndpoint":{"input":{"type":"structure","required":["EndpointArn"],"members":{"EndpointArn":{}}},"output":{"type":"structure","members":{"EndpointProperties":{"shape":"S38"}}}},"DescribeEntitiesDetectionJob":{"input":{"type":"structure","required":["JobId"],"members":{"JobId":{}}},"output":{"type":"structure","members":{"EntitiesDetectionJobProperties":{"shape":"S3c"}}}},"DescribeEntityRecognizer":{"input":{"type":"structure","required":["EntityRecognizerArn"],"members":{"EntityRecognizerArn":{}}},"output":{"type":"structure","members":{"EntityRecognizerProperties":{"shape":"S3f"}}}},"DescribeKeyPhrasesDetectionJob":{"input":{"type":"structure","required":["JobId"],"members":{"JobId":{}}},"output":{"type":"structure","members":{"KeyPhrasesDetectionJobProperties":{"shape":"S3n"}}}},"DescribeSentimentDetectionJob":{"input":{"type":"structure","required":["JobId"],"members":{"JobId":{}}},"output":{"type":"structure","members":{"SentimentDetectionJobProperties":{"shape":"S3q"}}}},"DescribeTopicsDetectionJob":{"input":{"type":"structure","required":["JobId"],"members":{"JobId":{}}},"output":{"type":"structure","members":{"TopicsDetectionJobProperties":{"shape":"S3t"}}}},"DetectDominantLanguage":{"input":{"type":"structure","required":["Text"],"members":{"Text":{"shape":"S3"}}},"output":{"type":"structure","members":{"Languages":{"shape":"S8"}},"sensitive":true}},"DetectEntities":{"input":{"type":"structure","required":["Text"],"members":{"Text":{"shape":"S3"},"LanguageCode":{},"EndpointArn":{}}},"output":{"type":"structure","members":{"Entities":{"shape":"Sj"}},"sensitive":true}},"DetectKeyPhrases":{"input":{"type":"structure","required":["Text","LanguageCode"],"members":{"Text":{"shape":"S3"},"LanguageCode":{}}},"output":{"type":"structure","members":{"KeyPhrases":{"shape":"Sq"}},"sensitive":true}},"DetectSentiment":{"input":{"type":"structure","required":["Text","LanguageCode"],"members":{"Text":{"shape":"S3"},"LanguageCode":{}}},"output":{"type":"structure","members":{"Sentiment":{},"SentimentScore":{"shape":"Sx"}},"sensitive":true}},"DetectSyntax":{"input":{"type":"structure","required":["Text","LanguageCode"],"members":{"Text":{"shape":"S3"},"LanguageCode":{}}},"output":{"type":"structure","members":{"SyntaxTokens":{"shape":"S13"}},"sensitive":true}},"ListDocumentClassificationJobs":{"input":{"type":"structure","members":{"Filter":{"type":"structure","members":{"JobName":{},"JobStatus":{},"SubmitTimeBefore":{"type":"timestamp"},"SubmitTimeAfter":{"type":"timestamp"}}},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"DocumentClassificationJobPropertiesList":{"type":"list","member":{"shape":"S2o"}},"NextToken":{}}}},"ListDocumentClassifiers":{"input":{"type":"structure","members":{"Filter":{"type":"structure","members":{"Status":{},"SubmitTimeBefore":{"type":"timestamp"},"SubmitTimeAfter":{"type":"timestamp"}}},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"DocumentClassifierPropertiesList":{"type":"list","member":{"shape":"S2y"}},"NextToken":{}}}},"ListDominantLanguageDetectionJobs":{"input":{"type":"structure","members":{"Filter":{"type":"structure","members":{"JobName":{},"JobStatus":{},"SubmitTimeBefore":{"type":"timestamp"},"SubmitTimeAfter":{"type":"timestamp"}}},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"DominantLanguageDetectionJobPropertiesList":{"type":"list","member":{"shape":"S35"}},"NextToken":{}}}},"ListEndpoints":{"input":{"type":"structure","members":{"Filter":{"type":"structure","members":{"ModelArn":{},"Status":{},"CreationTimeBefore":{"type":"timestamp"},"CreationTimeAfter":{"type":"timestamp"}}},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"EndpointPropertiesList":{"type":"list","member":{"shape":"S38"}},"NextToken":{}}}},"ListEntitiesDetectionJobs":{"input":{"type":"structure","members":{"Filter":{"type":"structure","members":{"JobName":{},"JobStatus":{},"SubmitTimeBefore":{"type":"timestamp"},"SubmitTimeAfter":{"type":"timestamp"}}},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"EntitiesDetectionJobPropertiesList":{"type":"list","member":{"shape":"S3c"}},"NextToken":{}}}},"ListEntityRecognizers":{"input":{"type":"structure","members":{"Filter":{"type":"structure","members":{"Status":{},"SubmitTimeBefore":{"type":"timestamp"},"SubmitTimeAfter":{"type":"timestamp"}}},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"EntityRecognizerPropertiesList":{"type":"list","member":{"shape":"S3f"}},"NextToken":{}}}},"ListKeyPhrasesDetectionJobs":{"input":{"type":"structure","members":{"Filter":{"type":"structure","members":{"JobName":{},"JobStatus":{},"SubmitTimeBefore":{"type":"timestamp"},"SubmitTimeAfter":{"type":"timestamp"}}},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"KeyPhrasesDetectionJobPropertiesList":{"type":"list","member":{"shape":"S3n"}},"NextToken":{}}}},"ListSentimentDetectionJobs":{"input":{"type":"structure","members":{"Filter":{"type":"structure","members":{"JobName":{},"JobStatus":{},"SubmitTimeBefore":{"type":"timestamp"},"SubmitTimeAfter":{"type":"timestamp"}}},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"SentimentDetectionJobPropertiesList":{"type":"list","member":{"shape":"S3q"}},"NextToken":{}}}},"ListTagsForResource":{"input":{"type":"structure","required":["ResourceArn"],"members":{"ResourceArn":{}}},"output":{"type":"structure","members":{"ResourceArn":{},"Tags":{"shape":"S1h"}}}},"ListTopicsDetectionJobs":{"input":{"type":"structure","members":{"Filter":{"type":"structure","members":{"JobName":{},"JobStatus":{},"SubmitTimeBefore":{"type":"timestamp"},"SubmitTimeAfter":{"type":"timestamp"}}},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"TopicsDetectionJobPropertiesList":{"type":"list","member":{"shape":"S3t"}},"NextToken":{}}}},"StartDocumentClassificationJob":{"input":{"type":"structure","required":["DocumentClassifierArn","InputDataConfig","OutputDataConfig","DataAccessRoleArn"],"members":{"JobName":{},"DocumentClassifierArn":{},"InputDataConfig":{"shape":"S2t"},"OutputDataConfig":{"shape":"S2v"},"DataAccessRoleArn":{},"ClientRequestToken":{"idempotencyToken":true},"VolumeKmsKeyId":{},"VpcConfig":{"shape":"S1r"}}},"output":{"type":"structure","members":{"JobId":{},"JobStatus":{}}}},"StartDominantLanguageDetectionJob":{"input":{"type":"structure","required":["InputDataConfig","OutputDataConfig","DataAccessRoleArn"],"members":{"InputDataConfig":{"shape":"S2t"},"OutputDataConfig":{"shape":"S2v"},"DataAccessRoleArn":{},"JobName":{},"ClientRequestToken":{"idempotencyToken":true},"VolumeKmsKeyId":{},"VpcConfig":{"shape":"S1r"}}},"output":{"type":"structure","members":{"JobId":{},"JobStatus":{}}}},"StartEntitiesDetectionJob":{"input":{"type":"structure","required":["InputDataConfig","OutputDataConfig","DataAccessRoleArn","LanguageCode"],"members":{"InputDataConfig":{"shape":"S2t"},"OutputDataConfig":{"shape":"S2v"},"DataAccessRoleArn":{},"JobName":{},"EntityRecognizerArn":{},"LanguageCode":{},"ClientRequestToken":{"idempotencyToken":true},"VolumeKmsKeyId":{},"VpcConfig":{"shape":"S1r"}}},"output":{"type":"structure","members":{"JobId":{},"JobStatus":{}}}},"StartKeyPhrasesDetectionJob":{"input":{"type":"structure","required":["InputDataConfig","OutputDataConfig","DataAccessRoleArn","LanguageCode"],"members":{"InputDataConfig":{"shape":"S2t"},"OutputDataConfig":{"shape":"S2v"},"DataAccessRoleArn":{},"JobName":{},"LanguageCode":{},"ClientRequestToken":{"idempotencyToken":true},"VolumeKmsKeyId":{},"VpcConfig":{"shape":"S1r"}}},"output":{"type":"structure","members":{"JobId":{},"JobStatus":{}}}},"StartSentimentDetectionJob":{"input":{"type":"structure","required":["InputDataConfig","OutputDataConfig","DataAccessRoleArn","LanguageCode"],"members":{"InputDataConfig":{"shape":"S2t"},"OutputDataConfig":{"shape":"S2v"},"DataAccessRoleArn":{},"JobName":{},"LanguageCode":{},"ClientRequestToken":{"idempotencyToken":true},"VolumeKmsKeyId":{},"VpcConfig":{"shape":"S1r"}}},"output":{"type":"structure","members":{"JobId":{},"JobStatus":{}}}},"StartTopicsDetectionJob":{"input":{"type":"structure","required":["InputDataConfig","OutputDataConfig","DataAccessRoleArn"],"members":{"InputDataConfig":{"shape":"S2t"},"OutputDataConfig":{"shape":"S2v"},"DataAccessRoleArn":{},"JobName":{},"NumberOfTopics":{"type":"integer"},"ClientRequestToken":{"idempotencyToken":true},"VolumeKmsKeyId":{},"VpcConfig":{"shape":"S1r"}}},"output":{"type":"structure","members":{"JobId":{},"JobStatus":{}}}},"StopDominantLanguageDetectionJob":{"input":{"type":"structure","required":["JobId"],"members":{"JobId":{}}},"output":{"type":"structure","members":{"JobId":{},"JobStatus":{}}}},"StopEntitiesDetectionJob":{"input":{"type":"structure","required":["JobId"],"members":{"JobId":{}}},"output":{"type":"structure","members":{"JobId":{},"JobStatus":{}}}},"StopKeyPhrasesDetectionJob":{"input":{"type":"structure","required":["JobId"],"members":{"JobId":{}}},"output":{"type":"structure","members":{"JobId":{},"JobStatus":{}}}},"StopSentimentDetectionJob":{"input":{"type":"structure","required":["JobId"],"members":{"JobId":{}}},"output":{"type":"structure","members":{"JobId":{},"JobStatus":{}}}},"StopTrainingDocumentClassifier":{"input":{"type":"structure","required":["DocumentClassifierArn"],"members":{"DocumentClassifierArn":{}}},"output":{"type":"structure","members":{}}},"StopTrainingEntityRecognizer":{"input":{"type":"structure","required":["EntityRecognizerArn"],"members":{"EntityRecognizerArn":{}}},"output":{"type":"structure","members":{}}},"TagResource":{"input":{"type":"structure","required":["ResourceArn","Tags"],"members":{"ResourceArn":{},"Tags":{"shape":"S1h"}}},"output":{"type":"structure","members":{}}},"UntagResource":{"input":{"type":"structure","required":["ResourceArn","TagKeys"],"members":{"ResourceArn":{},"TagKeys":{"type":"list","member":{}}}},"output":{"type":"structure","members":{}}},"UpdateEndpoint":{"input":{"type":"structure","required":["EndpointArn","DesiredInferenceUnits"],"members":{"EndpointArn":{},"DesiredInferenceUnits":{"type":"integer"}}},"output":{"type":"structure","members":{}}}},"shapes":{"S2":{"type":"list","member":{"shape":"S3"},"sensitive":true},"S3":{"type":"string","sensitive":true},"S8":{"type":"list","member":{"type":"structure","members":{"LanguageCode":{},"Score":{"type":"float"}}}},"Sc":{"type":"list","member":{"type":"structure","members":{"Index":{"type":"integer"},"ErrorCode":{},"ErrorMessage":{}}}},"Sj":{"type":"list","member":{"type":"structure","members":{"Score":{"type":"float"},"Type":{},"Text":{},"BeginOffset":{"type":"integer"},"EndOffset":{"type":"integer"}}}},"Sq":{"type":"list","member":{"type":"structure","members":{"Score":{"type":"float"},"Text":{},"BeginOffset":{"type":"integer"},"EndOffset":{"type":"integer"}}}},"Sx":{"type":"structure","members":{"Positive":{"type":"float"},"Negative":{"type":"float"},"Neutral":{"type":"float"},"Mixed":{"type":"float"}}},"S13":{"type":"list","member":{"type":"structure","members":{"TokenId":{"type":"integer"},"Text":{},"BeginOffset":{"type":"integer"},"EndOffset":{"type":"integer"},"PartOfSpeech":{"type":"structure","members":{"Tag":{},"Score":{"type":"float"}}}}}},"S1h":{"type":"list","member":{"type":"structure","required":["Key"],"members":{"Key":{},"Value":{}}}},"S1l":{"type":"structure","required":["S3Uri"],"members":{"S3Uri":{},"LabelDelimiter":{}}},"S1o":{"type":"structure","members":{"S3Uri":{},"KmsKeyId":{}}},"S1r":{"type":"structure","required":["SecurityGroupIds","Subnets"],"members":{"SecurityGroupIds":{"type":"list","member":{}},"Subnets":{"type":"list","member":{}}}},"S26":{"type":"structure","required":["EntityTypes","Documents"],"members":{"EntityTypes":{"type":"list","member":{"type":"structure","required":["Type"],"members":{"Type":{}}}},"Documents":{"type":"structure","required":["S3Uri"],"members":{"S3Uri":{}}},"Annotations":{"type":"structure","required":["S3Uri"],"members":{"S3Uri":{}}},"EntityList":{"type":"structure","required":["S3Uri"],"members":{"S3Uri":{}}}}},"S2o":{"type":"structure","members":{"JobId":{},"JobName":{},"JobStatus":{},"Message":{},"SubmitTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"DocumentClassifierArn":{},"InputDataConfig":{"shape":"S2t"},"OutputDataConfig":{"shape":"S2v"},"DataAccessRoleArn":{},"VolumeKmsKeyId":{},"VpcConfig":{"shape":"S1r"}}},"S2t":{"type":"structure","required":["S3Uri"],"members":{"S3Uri":{},"InputFormat":{}}},"S2v":{"type":"structure","required":["S3Uri"],"members":{"S3Uri":{},"KmsKeyId":{}}},"S2y":{"type":"structure","members":{"DocumentClassifierArn":{},"LanguageCode":{},"Status":{},"Message":{},"SubmitTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"TrainingStartTime":{"type":"timestamp"},"TrainingEndTime":{"type":"timestamp"},"InputDataConfig":{"shape":"S1l"},"OutputDataConfig":{"shape":"S1o"},"ClassifierMetadata":{"type":"structure","members":{"NumberOfLabels":{"type":"integer"},"NumberOfTrainedDocuments":{"type":"integer"},"NumberOfTestDocuments":{"type":"integer"},"EvaluationMetrics":{"type":"structure","members":{"Accuracy":{"type":"double"},"Precision":{"type":"double"},"Recall":{"type":"double"},"F1Score":{"type":"double"},"MicroPrecision":{"type":"double"},"MicroRecall":{"type":"double"},"MicroF1Score":{"type":"double"},"HammingLoss":{"type":"double"}}}},"sensitive":true},"DataAccessRoleArn":{},"VolumeKmsKeyId":{},"VpcConfig":{"shape":"S1r"},"Mode":{}}},"S35":{"type":"structure","members":{"JobId":{},"JobName":{},"JobStatus":{},"Message":{},"SubmitTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"InputDataConfig":{"shape":"S2t"},"OutputDataConfig":{"shape":"S2v"},"DataAccessRoleArn":{},"VolumeKmsKeyId":{},"VpcConfig":{"shape":"S1r"}}},"S38":{"type":"structure","members":{"EndpointArn":{},"Status":{},"Message":{},"ModelArn":{},"DesiredInferenceUnits":{"type":"integer"},"CurrentInferenceUnits":{"type":"integer"},"CreationTime":{"type":"timestamp"},"LastModifiedTime":{"type":"timestamp"}}},"S3c":{"type":"structure","members":{"JobId":{},"JobName":{},"JobStatus":{},"Message":{},"SubmitTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"EntityRecognizerArn":{},"InputDataConfig":{"shape":"S2t"},"OutputDataConfig":{"shape":"S2v"},"LanguageCode":{},"DataAccessRoleArn":{},"VolumeKmsKeyId":{},"VpcConfig":{"shape":"S1r"}}},"S3f":{"type":"structure","members":{"EntityRecognizerArn":{},"LanguageCode":{},"Status":{},"Message":{},"SubmitTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"TrainingStartTime":{"type":"timestamp"},"TrainingEndTime":{"type":"timestamp"},"InputDataConfig":{"shape":"S26"},"RecognizerMetadata":{"type":"structure","members":{"NumberOfTrainedDocuments":{"type":"integer"},"NumberOfTestDocuments":{"type":"integer"},"EvaluationMetrics":{"type":"structure","members":{"Precision":{"type":"double"},"Recall":{"type":"double"},"F1Score":{"type":"double"}}},"EntityTypes":{"type":"list","member":{"type":"structure","members":{"Type":{},"EvaluationMetrics":{"type":"structure","members":{"Precision":{"type":"double"},"Recall":{"type":"double"},"F1Score":{"type":"double"}}},"NumberOfTrainMentions":{"type":"integer"}}}}},"sensitive":true},"DataAccessRoleArn":{},"VolumeKmsKeyId":{},"VpcConfig":{"shape":"S1r"}}},"S3n":{"type":"structure","members":{"JobId":{},"JobName":{},"JobStatus":{},"Message":{},"SubmitTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"InputDataConfig":{"shape":"S2t"},"OutputDataConfig":{"shape":"S2v"},"LanguageCode":{},"DataAccessRoleArn":{},"VolumeKmsKeyId":{},"VpcConfig":{"shape":"S1r"}}},"S3q":{"type":"structure","members":{"JobId":{},"JobName":{},"JobStatus":{},"Message":{},"SubmitTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"InputDataConfig":{"shape":"S2t"},"OutputDataConfig":{"shape":"S2v"},"LanguageCode":{},"DataAccessRoleArn":{},"VolumeKmsKeyId":{},"VpcConfig":{"shape":"S1r"}}},"S3t":{"type":"structure","members":{"JobId":{},"JobName":{},"JobStatus":{},"Message":{},"SubmitTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"InputDataConfig":{"shape":"S2t"},"OutputDataConfig":{"shape":"S2v"},"NumberOfTopics":{"type":"integer"},"DataAccessRoleArn":{},"VolumeKmsKeyId":{},"VpcConfig":{"shape":"S1r"}}}}}; + if (ch === 0x2C/* , */) { + readNext = true; + ch = state.input.charCodeAt(++state.position); + } else { + readNext = false; + } + } -/***/ }), + throwError(state, 'unexpected end of the stream within a flow collection'); +} -/***/ 3187: -/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) { +function readBlockScalar(state, nodeIndent) { + var captureStart, + folding, + chomping = CHOMPING_CLIP, + didReadContent = false, + detectedIndent = false, + textIndent = nodeIndent, + emptyLines = 0, + atMoreIndented = false, + tmp, + ch; -var AWS = __webpack_require__(395); -__webpack_require__(4923); -__webpack_require__(4906); -var PromisesDependency; + ch = state.input.charCodeAt(state.position); -/** - * The main configuration class used by all service objects to set - * the region, credentials, and other options for requests. - * - * By default, credentials and region settings are left unconfigured. - * This should be configured by the application before using any - * AWS service APIs. - * - * In order to set global configuration options, properties should - * be assigned to the global {AWS.config} object. - * - * @see AWS.config - * - * @!group General Configuration Options - * - * @!attribute credentials - * @return [AWS.Credentials] the AWS credentials to sign requests with. - * - * @!attribute region - * @example Set the global region setting to us-west-2 - * AWS.config.update({region: 'us-west-2'}); - * @return [AWS.Credentials] The region to send service requests to. - * @see http://docs.amazonwebservices.com/general/latest/gr/rande.html - * A list of available endpoints for each AWS service - * - * @!attribute maxRetries - * @return [Integer] the maximum amount of retries to perform for a - * service request. By default this value is calculated by the specific - * service object that the request is being made to. - * - * @!attribute maxRedirects - * @return [Integer] the maximum amount of redirects to follow for a - * service request. Defaults to 10. - * - * @!attribute paramValidation - * @return [Boolean|map] whether input parameters should be validated against - * the operation description before sending the request. Defaults to true. - * Pass a map to enable any of the following specific validation features: - * - * * **min** [Boolean] — Validates that a value meets the min - * constraint. This is enabled by default when paramValidation is set - * to `true`. - * * **max** [Boolean] — Validates that a value meets the max - * constraint. - * * **pattern** [Boolean] — Validates that a string value matches a - * regular expression. - * * **enum** [Boolean] — Validates that a string value matches one - * of the allowable enum values. - * - * @!attribute computeChecksums - * @return [Boolean] whether to compute checksums for payload bodies when - * the service accepts it (currently supported in S3 only). - * - * @!attribute convertResponseTypes - * @return [Boolean] whether types are converted when parsing response data. - * Currently only supported for JSON based services. Turning this off may - * improve performance on large response payloads. Defaults to `true`. - * - * @!attribute correctClockSkew - * @return [Boolean] whether to apply a clock skew correction and retry - * requests that fail because of an skewed client clock. Defaults to - * `false`. - * - * @!attribute sslEnabled - * @return [Boolean] whether SSL is enabled for requests - * - * @!attribute s3ForcePathStyle - * @return [Boolean] whether to force path style URLs for S3 objects - * - * @!attribute s3BucketEndpoint - * @note Setting this configuration option requires an `endpoint` to be - * provided explicitly to the service constructor. - * @return [Boolean] whether the provided endpoint addresses an individual - * bucket (false if it addresses the root API endpoint). - * - * @!attribute s3DisableBodySigning - * @return [Boolean] whether to disable S3 body signing when using signature version `v4`. - * Body signing can only be disabled when using https. Defaults to `true`. - * - * @!attribute s3UsEast1RegionalEndpoint - * @return ['legacy'|'regional'] when region is set to 'us-east-1', whether to send s3 - * request to global endpoints or 'us-east-1' regional endpoints. This config is only - * applicable to S3 client; - * Defaults to 'legacy' - * @!attribute s3UseArnRegion - * @return [Boolean] whether to override the request region with the region inferred - * from requested resource's ARN. Only available for S3 buckets - * Defaults to `true` - * - * @!attribute useAccelerateEndpoint - * @note This configuration option is only compatible with S3 while accessing - * dns-compatible buckets. - * @return [Boolean] Whether to use the Accelerate endpoint with the S3 service. - * Defaults to `false`. - * - * @!attribute retryDelayOptions - * @example Set the base retry delay for all services to 300 ms - * AWS.config.update({retryDelayOptions: {base: 300}}); - * // Delays with maxRetries = 3: 300, 600, 1200 - * @example Set a custom backoff function to provide delay values on retries - * AWS.config.update({retryDelayOptions: {customBackoff: function(retryCount, err) { - * // returns delay in ms - * }}}); - * @return [map] A set of options to configure the retry delay on retryable errors. - * Currently supported options are: - * - * * **base** [Integer] — The base number of milliseconds to use in the - * exponential backoff for operation retries. Defaults to 100 ms for all services except - * DynamoDB, where it defaults to 50ms. - * - * * **customBackoff ** [function] — A custom function that accepts a - * retry count and error and returns the amount of time to delay in - * milliseconds. If the result is a non-zero negative value, no further - * retry attempts will be made. The `base` option will be ignored if this - * option is supplied. - * - * @!attribute httpOptions - * @return [map] A set of options to pass to the low-level HTTP request. - * Currently supported options are: - * - * * **proxy** [String] — the URL to proxy requests through - * * **agent** [http.Agent, https.Agent] — the Agent object to perform - * HTTP requests with. Used for connection pooling. Note that for - * SSL connections, a special Agent object is used in order to enable - * peer certificate verification. This feature is only supported in the - * Node.js environment. - * * **connectTimeout** [Integer] — Sets the socket to timeout after - * failing to establish a connection with the server after - * `connectTimeout` milliseconds. This timeout has no effect once a socket - * connection has been established. - * * **timeout** [Integer] — Sets the socket to timeout after timeout - * milliseconds of inactivity on the socket. Defaults to two minutes - * (120000) - * * **xhrAsync** [Boolean] — Whether the SDK will send asynchronous - * HTTP requests. Used in the browser environment only. Set to false to - * send requests synchronously. Defaults to true (async on). - * * **xhrWithCredentials** [Boolean] — Sets the "withCredentials" - * property of an XMLHttpRequest object. Used in the browser environment - * only. Defaults to false. - * @!attribute logger - * @return [#write,#log] an object that responds to .write() (like a stream) - * or .log() (like the console object) in order to log information about - * requests - * - * @!attribute systemClockOffset - * @return [Number] an offset value in milliseconds to apply to all signing - * times. Use this to compensate for clock skew when your system may be - * out of sync with the service time. Note that this configuration option - * can only be applied to the global `AWS.config` object and cannot be - * overridden in service-specific configuration. Defaults to 0 milliseconds. - * - * @!attribute signatureVersion - * @return [String] the signature version to sign requests with (overriding - * the API configuration). Possible values are: 'v2', 'v3', 'v4'. - * - * @!attribute signatureCache - * @return [Boolean] whether the signature to sign requests with (overriding - * the API configuration) is cached. Only applies to the signature version 'v4'. - * Defaults to `true`. - * - * @!attribute endpointDiscoveryEnabled - * @return [Boolean|undefined] whether to call operations with endpoints - * given by service dynamically. Setting this config to `true` will enable - * endpoint discovery for all applicable operations. Setting it to `false` - * will explicitly disable endpoint discovery even though operations that - * require endpoint discovery will presumably fail. Leaving it to - * `undefined` means SDK only do endpoint discovery when it's required. - * Defaults to `undefined` - * - * @!attribute endpointCacheSize - * @return [Number] the size of the global cache storing endpoints from endpoint - * discovery operations. Once endpoint cache is created, updating this setting - * cannot change existing cache size. - * Defaults to 1000 - * - * @!attribute hostPrefixEnabled - * @return [Boolean] whether to marshal request parameters to the prefix of - * hostname. Defaults to `true`. - * - * @!attribute stsRegionalEndpoints - * @return ['legacy'|'regional'] whether to send sts request to global endpoints or - * regional endpoints. - * Defaults to 'legacy' - */ -AWS.Config = AWS.util.inherit({ - /** - * @!endgroup - */ + if (ch === 0x7C/* | */) { + folding = false; + } else if (ch === 0x3E/* > */) { + folding = true; + } else { + return false; + } - /** - * Creates a new configuration object. This is the object that passes - * option data along to service requests, including credentials, security, - * region information, and some service specific settings. - * - * @example Creating a new configuration object with credentials and region - * var config = new AWS.Config({ - * accessKeyId: 'AKID', secretAccessKey: 'SECRET', region: 'us-west-2' - * }); - * @option options accessKeyId [String] your AWS access key ID. - * @option options secretAccessKey [String] your AWS secret access key. - * @option options sessionToken [AWS.Credentials] the optional AWS - * session token to sign requests with. - * @option options credentials [AWS.Credentials] the AWS credentials - * to sign requests with. You can either specify this object, or - * specify the accessKeyId and secretAccessKey options directly. - * @option options credentialProvider [AWS.CredentialProviderChain] the - * provider chain used to resolve credentials if no static `credentials` - * property is set. - * @option options region [String] the region to send service requests to. - * See {region} for more information. - * @option options maxRetries [Integer] the maximum amount of retries to - * attempt with a request. See {maxRetries} for more information. - * @option options maxRedirects [Integer] the maximum amount of redirects to - * follow with a request. See {maxRedirects} for more information. - * @option options sslEnabled [Boolean] whether to enable SSL for - * requests. - * @option options paramValidation [Boolean|map] whether input parameters - * should be validated against the operation description before sending - * the request. Defaults to true. Pass a map to enable any of the - * following specific validation features: - * - * * **min** [Boolean] — Validates that a value meets the min - * constraint. This is enabled by default when paramValidation is set - * to `true`. - * * **max** [Boolean] — Validates that a value meets the max - * constraint. - * * **pattern** [Boolean] — Validates that a string value matches a - * regular expression. - * * **enum** [Boolean] — Validates that a string value matches one - * of the allowable enum values. - * @option options computeChecksums [Boolean] whether to compute checksums - * for payload bodies when the service accepts it (currently supported - * in S3 only) - * @option options convertResponseTypes [Boolean] whether types are converted - * when parsing response data. Currently only supported for JSON based - * services. Turning this off may improve performance on large response - * payloads. Defaults to `true`. - * @option options correctClockSkew [Boolean] whether to apply a clock skew - * correction and retry requests that fail because of an skewed client - * clock. Defaults to `false`. - * @option options s3ForcePathStyle [Boolean] whether to force path - * style URLs for S3 objects. - * @option options s3BucketEndpoint [Boolean] whether the provided endpoint - * addresses an individual bucket (false if it addresses the root API - * endpoint). Note that setting this configuration option requires an - * `endpoint` to be provided explicitly to the service constructor. - * @option options s3DisableBodySigning [Boolean] whether S3 body signing - * should be disabled when using signature version `v4`. Body signing - * can only be disabled when using https. Defaults to `true`. - * @option options s3UsEast1RegionalEndpoint ['legacy'|'regional'] when region - * is set to 'us-east-1', whether to send s3 request to global endpoints or - * 'us-east-1' regional endpoints. This config is only applicable to S3 client. - * Defaults to `legacy` - * @option options s3UseArnRegion [Boolean] whether to override the request region - * with the region inferred from requested resource's ARN. Only available for S3 buckets - * Defaults to `true` - * - * @option options retryDelayOptions [map] A set of options to configure - * the retry delay on retryable errors. Currently supported options are: - * - * * **base** [Integer] — The base number of milliseconds to use in the - * exponential backoff for operation retries. Defaults to 100 ms for all - * services except DynamoDB, where it defaults to 50ms. - * * **customBackoff ** [function] — A custom function that accepts a - * retry count and error and returns the amount of time to delay in - * milliseconds. If the result is a non-zero negative value, no further - * retry attempts will be made. The `base` option will be ignored if this - * option is supplied. - * @option options httpOptions [map] A set of options to pass to the low-level - * HTTP request. Currently supported options are: - * - * * **proxy** [String] — the URL to proxy requests through - * * **agent** [http.Agent, https.Agent] — the Agent object to perform - * HTTP requests with. Used for connection pooling. Defaults to the global - * agent (`http.globalAgent`) for non-SSL connections. Note that for - * SSL connections, a special Agent object is used in order to enable - * peer certificate verification. This feature is only available in the - * Node.js environment. - * * **connectTimeout** [Integer] — Sets the socket to timeout after - * failing to establish a connection with the server after - * `connectTimeout` milliseconds. This timeout has no effect once a socket - * connection has been established. - * * **timeout** [Integer] — Sets the socket to timeout after timeout - * milliseconds of inactivity on the socket. Defaults to two minutes - * (120000). - * * **xhrAsync** [Boolean] — Whether the SDK will send asynchronous - * HTTP requests. Used in the browser environment only. Set to false to - * send requests synchronously. Defaults to true (async on). - * * **xhrWithCredentials** [Boolean] — Sets the "withCredentials" - * property of an XMLHttpRequest object. Used in the browser environment - * only. Defaults to false. - * @option options apiVersion [String, Date] a String in YYYY-MM-DD format - * (or a date) that represents the latest possible API version that can be - * used in all services (unless overridden by `apiVersions`). Specify - * 'latest' to use the latest possible version. - * @option options apiVersions [map] a map of service - * identifiers (the lowercase service class name) with the API version to - * use when instantiating a service. Specify 'latest' for each individual - * that can use the latest available version. - * @option options logger [#write,#log] an object that responds to .write() - * (like a stream) or .log() (like the console object) in order to log - * information about requests - * @option options systemClockOffset [Number] an offset value in milliseconds - * to apply to all signing times. Use this to compensate for clock skew - * when your system may be out of sync with the service time. Note that - * this configuration option can only be applied to the global `AWS.config` - * object and cannot be overridden in service-specific configuration. - * Defaults to 0 milliseconds. - * @option options signatureVersion [String] the signature version to sign - * requests with (overriding the API configuration). Possible values are: - * 'v2', 'v3', 'v4'. - * @option options signatureCache [Boolean] whether the signature to sign - * requests with (overriding the API configuration) is cached. Only applies - * to the signature version 'v4'. Defaults to `true`. - * @option options dynamoDbCrc32 [Boolean] whether to validate the CRC32 - * checksum of HTTP response bodies returned by DynamoDB. Default: `true`. - * @option options useAccelerateEndpoint [Boolean] Whether to use the - * S3 Transfer Acceleration endpoint with the S3 service. Default: `false`. - * @option options clientSideMonitoring [Boolean] whether to collect and - * publish this client's performance metrics of all its API requests. - * @option options endpointDiscoveryEnabled [Boolean|undefined] whether to - * call operations with endpoints given by service dynamically. Setting this - * config to `true` will enable endpoint discovery for all applicable operations. - * Setting it to `false` will explicitly disable endpoint discovery even though - * operations that require endpoint discovery will presumably fail. Leaving it - * to `undefined` means SDK will only do endpoint discovery when it's required. - * Defaults to `undefined` - * @option options endpointCacheSize [Number] the size of the global cache storing - * endpoints from endpoint discovery operations. Once endpoint cache is created, - * updating this setting cannot change existing cache size. - * Defaults to 1000 - * @option options hostPrefixEnabled [Boolean] whether to marshal request - * parameters to the prefix of hostname. - * Defaults to `true`. - * @option options stsRegionalEndpoints ['legacy'|'regional'] whether to send sts request - * to global endpoints or regional endpoints. - * Defaults to 'legacy'. - */ - constructor: function Config(options) { - if (options === undefined) options = {}; - options = this.extractCredentials(options); + state.kind = 'scalar'; + state.result = ''; - AWS.util.each.call(this, this.keys, function (key, value) { - this.set(key, options[key], value); - }); - }, + while (ch !== 0) { + ch = state.input.charCodeAt(++state.position); - /** - * @!group Managing Credentials - */ + if (ch === 0x2B/* + */ || ch === 0x2D/* - */) { + if (CHOMPING_CLIP === chomping) { + chomping = (ch === 0x2B/* + */) ? CHOMPING_KEEP : CHOMPING_STRIP; + } else { + throwError(state, 'repeat of a chomping mode identifier'); + } - /** - * Loads credentials from the configuration object. This is used internally - * by the SDK to ensure that refreshable {Credentials} objects are properly - * refreshed and loaded when sending a request. If you want to ensure that - * your credentials are loaded prior to a request, you can use this method - * directly to provide accurate credential data stored in the object. - * - * @note If you configure the SDK with static or environment credentials, - * the credential data should already be present in {credentials} attribute. - * This method is primarily necessary to load credentials from asynchronous - * sources, or sources that can refresh credentials periodically. - * @example Getting your access key - * AWS.config.getCredentials(function(err) { - * if (err) console.log(err.stack); // credentials not loaded - * else console.log("Access Key:", AWS.config.credentials.accessKeyId); - * }) - * @callback callback function(err) - * Called when the {credentials} have been properly set on the configuration - * object. - * - * @param err [Error] if this is set, credentials were not successfully - * loaded and this error provides information why. - * @see credentials - * @see Credentials - */ - getCredentials: function getCredentials(callback) { - var self = this; + } else if ((tmp = fromDecimalCode(ch)) >= 0) { + if (tmp === 0) { + throwError(state, 'bad explicit indentation width of a block scalar; it cannot be less than one'); + } else if (!detectedIndent) { + textIndent = nodeIndent + tmp - 1; + detectedIndent = true; + } else { + throwError(state, 'repeat of an indentation width identifier'); + } - function finish(err) { - callback(err, err ? null : self.credentials); + } else { + break; } + } - function credError(msg, err) { - return new AWS.util.error(err || new Error(), { - code: 'CredentialsError', - message: msg, - name: 'CredentialsError' - }); + if (is_WHITE_SPACE(ch)) { + do { ch = state.input.charCodeAt(++state.position); } + while (is_WHITE_SPACE(ch)); + + if (ch === 0x23/* # */) { + do { ch = state.input.charCodeAt(++state.position); } + while (!is_EOL(ch) && (ch !== 0)); } + } - function getAsyncCredentials() { - self.credentials.get(function(err) { - if (err) { - var msg = 'Could not load credentials from ' + - self.credentials.constructor.name; - err = credError(msg, err); - } - finish(err); - }); + while (ch !== 0) { + readLineBreak(state); + state.lineIndent = 0; + + ch = state.input.charCodeAt(state.position); + + while ((!detectedIndent || state.lineIndent < textIndent) && + (ch === 0x20/* Space */)) { + state.lineIndent++; + ch = state.input.charCodeAt(++state.position); } - function getStaticCredentials() { - var err = null; - if (!self.credentials.accessKeyId || !self.credentials.secretAccessKey) { - err = credError('Missing credentials'); - } - finish(err); + if (!detectedIndent && state.lineIndent > textIndent) { + textIndent = state.lineIndent; } - if (self.credentials) { - if (typeof self.credentials.get === 'function') { - getAsyncCredentials(); - } else { // static credentials - getStaticCredentials(); - } - } else if (self.credentialProvider) { - self.credentialProvider.resolve(function(err, creds) { - if (err) { - err = credError('Could not load credentials from any providers', err); - } - self.credentials = creds; - finish(err); - }); - } else { - finish(credError('No credentials to load')); + if (is_EOL(ch)) { + emptyLines++; + continue; } - }, - /** - * @!group Loading and Setting Configuration Options - */ + // End of the scalar. + if (state.lineIndent < textIndent) { - /** - * @overload update(options, allowUnknownKeys = false) - * Updates the current configuration object with new options. - * - * @example Update maxRetries property of a configuration object - * config.update({maxRetries: 10}); - * @param [Object] options a map of option keys and values. - * @param [Boolean] allowUnknownKeys whether unknown keys can be set on - * the configuration object. Defaults to `false`. - * @see constructor - */ - update: function update(options, allowUnknownKeys) { - allowUnknownKeys = allowUnknownKeys || false; - options = this.extractCredentials(options); - AWS.util.each.call(this, options, function (key, value) { - if (allowUnknownKeys || Object.prototype.hasOwnProperty.call(this.keys, key) || - AWS.Service.hasService(key)) { - this.set(key, value); + // Perform the chomping. + if (chomping === CHOMPING_KEEP) { + state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines); + } else if (chomping === CHOMPING_CLIP) { + if (didReadContent) { // i.e. only if the scalar is not empty. + state.result += '\n'; + } } - }); - }, - /** - * Loads configuration data from a JSON file into this config object. - * @note Loading configuration will reset all existing configuration - * on the object. - * @!macro nobrowser - * @param path [String] the path relative to your process's current - * working directory to load configuration from. - * @return [AWS.Config] the same configuration object - */ - loadFromPath: function loadFromPath(path) { - this.clear(); - - var options = JSON.parse(AWS.util.readFileSync(path)); - var fileSystemCreds = new AWS.FileSystemCredentials(path); - var chain = new AWS.CredentialProviderChain(); - chain.providers.unshift(fileSystemCreds); - chain.resolve(function (err, creds) { - if (err) throw err; - else options.credentials = creds; - }); + // Break this `while` cycle and go to the funciton's epilogue. + break; + } - this.constructor(options); + // Folded style: use fancy rules to handle line breaks. + if (folding) { - return this; - }, + // Lines starting with white space characters (more-indented lines) are not folded. + if (is_WHITE_SPACE(ch)) { + atMoreIndented = true; + // except for the first content line (cf. Example 8.1) + state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines); - /** - * Clears configuration data on this object - * - * @api private - */ - clear: function clear() { - /*jshint forin:false */ - AWS.util.each.call(this, this.keys, function (key) { - delete this[key]; - }); + // End of more-indented block. + } else if (atMoreIndented) { + atMoreIndented = false; + state.result += common.repeat('\n', emptyLines + 1); - // reset credential provider - this.set('credentials', undefined); - this.set('credentialProvider', undefined); - }, + // Just one line break - perceive as the same line. + } else if (emptyLines === 0) { + if (didReadContent) { // i.e. only if we have already read some scalar content. + state.result += ' '; + } - /** - * Sets a property on the configuration object, allowing for a - * default value - * @api private - */ - set: function set(property, value, defaultValue) { - if (value === undefined) { - if (defaultValue === undefined) { - defaultValue = this.keys[property]; - } - if (typeof defaultValue === 'function') { - this[property] = defaultValue.call(this); + // Several line breaks - perceive as different lines. } else { - this[property] = defaultValue; + state.result += common.repeat('\n', emptyLines); } - } else if (property === 'httpOptions' && this[property]) { - // deep merge httpOptions - this[property] = AWS.util.merge(this[property], value); + + // Literal style: just add exact number of line breaks between content lines. } else { - this[property] = value; + // Keep all line breaks except the header line break. + state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines); } - }, - - /** - * All of the keys with their default values. - * - * @constant - * @api private - */ - keys: { - credentials: null, - credentialProvider: null, - region: null, - logger: null, - apiVersions: {}, - apiVersion: null, - endpoint: undefined, - httpOptions: { - timeout: 120000 - }, - maxRetries: undefined, - maxRedirects: 10, - paramValidation: true, - sslEnabled: true, - s3ForcePathStyle: false, - s3BucketEndpoint: false, - s3DisableBodySigning: true, - s3UsEast1RegionalEndpoint: 'legacy', - s3UseArnRegion: undefined, - computeChecksums: true, - convertResponseTypes: true, - correctClockSkew: false, - customUserAgent: null, - dynamoDbCrc32: true, - systemClockOffset: 0, - signatureVersion: null, - signatureCache: true, - retryDelayOptions: {}, - useAccelerateEndpoint: false, - clientSideMonitoring: false, - endpointDiscoveryEnabled: undefined, - endpointCacheSize: 1000, - hostPrefixEnabled: true, - stsRegionalEndpoints: 'legacy' - }, - /** - * Extracts accessKeyId, secretAccessKey and sessionToken - * from a configuration hash. - * - * @api private - */ - extractCredentials: function extractCredentials(options) { - if (options.accessKeyId && options.secretAccessKey) { - options = AWS.util.copy(options); - options.credentials = new AWS.Credentials(options); - } - return options; - }, + didReadContent = true; + detectedIndent = true; + emptyLines = 0; + captureStart = state.position; - /** - * Sets the promise dependency the SDK will use wherever Promises are returned. - * Passing `null` will force the SDK to use native Promises if they are available. - * If native Promises are not available, passing `null` will have no effect. - * @param [Constructor] dep A reference to a Promise constructor - */ - setPromisesDependency: function setPromisesDependency(dep) { - PromisesDependency = dep; - // if null was passed in, we should try to use native promises - if (dep === null && typeof Promise === 'function') { - PromisesDependency = Promise; - } - var constructors = [AWS.Request, AWS.Credentials, AWS.CredentialProviderChain]; - if (AWS.S3) { - constructors.push(AWS.S3); - if (AWS.S3.ManagedUpload) { - constructors.push(AWS.S3.ManagedUpload); - } + while (!is_EOL(ch) && (ch !== 0)) { + ch = state.input.charCodeAt(++state.position); } - AWS.util.addPromises(constructors, PromisesDependency); - }, - /** - * Gets the promise dependency set by `AWS.config.setPromisesDependency`. - */ - getPromisesDependency: function getPromisesDependency() { - return PromisesDependency; + captureSegment(state, captureStart, state.position, false); } -}); - -/** - * @return [AWS.Config] The global configuration object singleton instance - * @readonly - * @see AWS.Config - */ -AWS.config = new AWS.Config(); - - -/***/ }), - -/***/ 3206: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['route53domains'] = {}; -AWS.Route53Domains = Service.defineService('route53domains', ['2014-05-15']); -Object.defineProperty(apiLoader.services['route53domains'], '2014-05-15', { - get: function get() { - var model = __webpack_require__(7591); - model.paginators = __webpack_require__(9983).pagination; - return model; - }, - enumerable: true, - configurable: true -}); -module.exports = AWS.Route53Domains; + return true; +} +function readBlockSequence(state, nodeIndent) { + var _line, + _tag = state.tag, + _anchor = state.anchor, + _result = [], + following, + detected = false, + ch; -/***/ }), + // there is a leading tab before this token, so it can't be a block sequence/mapping; + // it can still be flow sequence/mapping or a scalar + if (state.firstTabInLine !== -1) return false; -/***/ 3209: -/***/ (function(module) { + if (state.anchor !== null) { + state.anchorMap[state.anchor] = _result; + } -module.exports = {"pagination":{}}; + ch = state.input.charCodeAt(state.position); -/***/ }), + while (ch !== 0) { + if (state.firstTabInLine !== -1) { + state.position = state.firstTabInLine; + throwError(state, 'tab characters must not be used in indentation'); + } -/***/ 3220: -/***/ (function(module, __unusedexports, __webpack_require__) { + if (ch !== 0x2D/* - */) { + break; + } -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; + following = state.input.charCodeAt(state.position + 1); -apiLoader.services['managedblockchain'] = {}; -AWS.ManagedBlockchain = Service.defineService('managedblockchain', ['2018-09-24']); -Object.defineProperty(apiLoader.services['managedblockchain'], '2018-09-24', { - get: function get() { - var model = __webpack_require__(3762); - model.paginators = __webpack_require__(2816).pagination; - return model; - }, - enumerable: true, - configurable: true -}); + if (!is_WS_OR_EOL(following)) { + break; + } -module.exports = AWS.ManagedBlockchain; + detected = true; + state.position++; + if (skipSeparationSpace(state, true, -1)) { + if (state.lineIndent <= nodeIndent) { + _result.push(null); + ch = state.input.charCodeAt(state.position); + continue; + } + } -/***/ }), + _line = state.line; + composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true); + _result.push(state.result); + skipSeparationSpace(state, true, -1); -/***/ 3222: -/***/ (function(module, __unusedexports, __webpack_require__) { + ch = state.input.charCodeAt(state.position); -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['iotevents'] = {}; -AWS.IoTEvents = Service.defineService('iotevents', ['2018-07-27']); -Object.defineProperty(apiLoader.services['iotevents'], '2018-07-27', { - get: function get() { - var model = __webpack_require__(7430); - model.paginators = __webpack_require__(3658).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.IoTEvents; + if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) { + throwError(state, 'bad indentation of a sequence entry'); + } else if (state.lineIndent < nodeIndent) { + break; + } + } + if (detected) { + state.tag = _tag; + state.anchor = _anchor; + state.kind = 'sequence'; + state.result = _result; + return true; + } + return false; +} -/***/ }), +function readBlockMapping(state, nodeIndent, flowIndent) { + var following, + allowCompact, + _line, + _keyLine, + _keyLineStart, + _keyPos, + _tag = state.tag, + _anchor = state.anchor, + _result = {}, + overridableKeys = Object.create(null), + keyTag = null, + keyNode = null, + valueNode = null, + atExplicitKey = false, + detected = false, + ch; -/***/ 3223: -/***/ (function(module, __unusedexports, __webpack_require__) { + // there is a leading tab before this token, so it can't be a block sequence/mapping; + // it can still be flow sequence/mapping or a scalar + if (state.firstTabInLine !== -1) return false; -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; + if (state.anchor !== null) { + state.anchorMap[state.anchor] = _result; + } -apiLoader.services['textract'] = {}; -AWS.Textract = Service.defineService('textract', ['2018-06-27']); -Object.defineProperty(apiLoader.services['textract'], '2018-06-27', { - get: function get() { - var model = __webpack_require__(918); - model.paginators = __webpack_require__(2449).pagination; - return model; - }, - enumerable: true, - configurable: true -}); + ch = state.input.charCodeAt(state.position); -module.exports = AWS.Textract; + while (ch !== 0) { + if (!atExplicitKey && state.firstTabInLine !== -1) { + state.position = state.firstTabInLine; + throwError(state, 'tab characters must not be used in indentation'); + } + following = state.input.charCodeAt(state.position + 1); + _line = state.line; // Save the current line. -/***/ }), + // + // Explicit notation case. There are two separate blocks: + // first for the key (denoted by "?") and second for the value (denoted by ":") + // + if ((ch === 0x3F/* ? */ || ch === 0x3A/* : */) && is_WS_OR_EOL(following)) { -/***/ 3224: -/***/ (function(module) { + if (ch === 0x3F/* ? */) { + if (atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos); + keyTag = keyNode = valueNode = null; + } -module.exports = {"version":"2.0","metadata":{"apiVersion":"2014-11-01","endpointPrefix":"kms","jsonVersion":"1.1","protocol":"json","serviceAbbreviation":"KMS","serviceFullName":"AWS Key Management Service","serviceId":"KMS","signatureVersion":"v4","targetPrefix":"TrentService","uid":"kms-2014-11-01"},"operations":{"CancelKeyDeletion":{"input":{"type":"structure","required":["KeyId"],"members":{"KeyId":{}}},"output":{"type":"structure","members":{"KeyId":{}}}},"ConnectCustomKeyStore":{"input":{"type":"structure","required":["CustomKeyStoreId"],"members":{"CustomKeyStoreId":{}}},"output":{"type":"structure","members":{}}},"CreateAlias":{"input":{"type":"structure","required":["AliasName","TargetKeyId"],"members":{"AliasName":{},"TargetKeyId":{}}}},"CreateCustomKeyStore":{"input":{"type":"structure","required":["CustomKeyStoreName","CloudHsmClusterId","TrustAnchorCertificate","KeyStorePassword"],"members":{"CustomKeyStoreName":{},"CloudHsmClusterId":{},"TrustAnchorCertificate":{},"KeyStorePassword":{"shape":"Sd"}}},"output":{"type":"structure","members":{"CustomKeyStoreId":{}}}},"CreateGrant":{"input":{"type":"structure","required":["KeyId","GranteePrincipal","Operations"],"members":{"KeyId":{},"GranteePrincipal":{},"RetiringPrincipal":{},"Operations":{"shape":"Sh"},"Constraints":{"shape":"Sj"},"GrantTokens":{"shape":"Sn"},"Name":{}}},"output":{"type":"structure","members":{"GrantToken":{},"GrantId":{}}}},"CreateKey":{"input":{"type":"structure","members":{"Policy":{},"Description":{},"KeyUsage":{},"CustomerMasterKeySpec":{},"Origin":{},"CustomKeyStoreId":{},"BypassPolicyLockoutSafetyCheck":{"type":"boolean"},"Tags":{"shape":"Sz"}}},"output":{"type":"structure","members":{"KeyMetadata":{"shape":"S14"}}}},"Decrypt":{"input":{"type":"structure","required":["CiphertextBlob"],"members":{"CiphertextBlob":{"type":"blob"},"EncryptionContext":{"shape":"Sk"},"GrantTokens":{"shape":"Sn"},"KeyId":{},"EncryptionAlgorithm":{}}},"output":{"type":"structure","members":{"KeyId":{},"Plaintext":{"shape":"S1i"},"EncryptionAlgorithm":{}}}},"DeleteAlias":{"input":{"type":"structure","required":["AliasName"],"members":{"AliasName":{}}}},"DeleteCustomKeyStore":{"input":{"type":"structure","required":["CustomKeyStoreId"],"members":{"CustomKeyStoreId":{}}},"output":{"type":"structure","members":{}}},"DeleteImportedKeyMaterial":{"input":{"type":"structure","required":["KeyId"],"members":{"KeyId":{}}}},"DescribeCustomKeyStores":{"input":{"type":"structure","members":{"CustomKeyStoreId":{},"CustomKeyStoreName":{},"Limit":{"type":"integer"},"Marker":{}}},"output":{"type":"structure","members":{"CustomKeyStores":{"type":"list","member":{"type":"structure","members":{"CustomKeyStoreId":{},"CustomKeyStoreName":{},"CloudHsmClusterId":{},"TrustAnchorCertificate":{},"ConnectionState":{},"ConnectionErrorCode":{},"CreationDate":{"type":"timestamp"}}}},"NextMarker":{},"Truncated":{"type":"boolean"}}}},"DescribeKey":{"input":{"type":"structure","required":["KeyId"],"members":{"KeyId":{},"GrantTokens":{"shape":"Sn"}}},"output":{"type":"structure","members":{"KeyMetadata":{"shape":"S14"}}}},"DisableKey":{"input":{"type":"structure","required":["KeyId"],"members":{"KeyId":{}}}},"DisableKeyRotation":{"input":{"type":"structure","required":["KeyId"],"members":{"KeyId":{}}}},"DisconnectCustomKeyStore":{"input":{"type":"structure","required":["CustomKeyStoreId"],"members":{"CustomKeyStoreId":{}}},"output":{"type":"structure","members":{}}},"EnableKey":{"input":{"type":"structure","required":["KeyId"],"members":{"KeyId":{}}}},"EnableKeyRotation":{"input":{"type":"structure","required":["KeyId"],"members":{"KeyId":{}}}},"Encrypt":{"input":{"type":"structure","required":["KeyId","Plaintext"],"members":{"KeyId":{},"Plaintext":{"shape":"S1i"},"EncryptionContext":{"shape":"Sk"},"GrantTokens":{"shape":"Sn"},"EncryptionAlgorithm":{}}},"output":{"type":"structure","members":{"CiphertextBlob":{"type":"blob"},"KeyId":{},"EncryptionAlgorithm":{}}}},"GenerateDataKey":{"input":{"type":"structure","required":["KeyId"],"members":{"KeyId":{},"EncryptionContext":{"shape":"Sk"},"NumberOfBytes":{"type":"integer"},"KeySpec":{},"GrantTokens":{"shape":"Sn"}}},"output":{"type":"structure","members":{"CiphertextBlob":{"type":"blob"},"Plaintext":{"shape":"S1i"},"KeyId":{}}}},"GenerateDataKeyPair":{"input":{"type":"structure","required":["KeyId","KeyPairSpec"],"members":{"EncryptionContext":{"shape":"Sk"},"KeyId":{},"KeyPairSpec":{},"GrantTokens":{"shape":"Sn"}}},"output":{"type":"structure","members":{"PrivateKeyCiphertextBlob":{"type":"blob"},"PrivateKeyPlaintext":{"shape":"S1i"},"PublicKey":{"type":"blob"},"KeyId":{},"KeyPairSpec":{}}}},"GenerateDataKeyPairWithoutPlaintext":{"input":{"type":"structure","required":["KeyId","KeyPairSpec"],"members":{"EncryptionContext":{"shape":"Sk"},"KeyId":{},"KeyPairSpec":{},"GrantTokens":{"shape":"Sn"}}},"output":{"type":"structure","members":{"PrivateKeyCiphertextBlob":{"type":"blob"},"PublicKey":{"type":"blob"},"KeyId":{},"KeyPairSpec":{}}}},"GenerateDataKeyWithoutPlaintext":{"input":{"type":"structure","required":["KeyId"],"members":{"KeyId":{},"EncryptionContext":{"shape":"Sk"},"KeySpec":{},"NumberOfBytes":{"type":"integer"},"GrantTokens":{"shape":"Sn"}}},"output":{"type":"structure","members":{"CiphertextBlob":{"type":"blob"},"KeyId":{}}}},"GenerateRandom":{"input":{"type":"structure","members":{"NumberOfBytes":{"type":"integer"},"CustomKeyStoreId":{}}},"output":{"type":"structure","members":{"Plaintext":{"shape":"S1i"}}}},"GetKeyPolicy":{"input":{"type":"structure","required":["KeyId","PolicyName"],"members":{"KeyId":{},"PolicyName":{}}},"output":{"type":"structure","members":{"Policy":{}}}},"GetKeyRotationStatus":{"input":{"type":"structure","required":["KeyId"],"members":{"KeyId":{}}},"output":{"type":"structure","members":{"KeyRotationEnabled":{"type":"boolean"}}}},"GetParametersForImport":{"input":{"type":"structure","required":["KeyId","WrappingAlgorithm","WrappingKeySpec"],"members":{"KeyId":{},"WrappingAlgorithm":{},"WrappingKeySpec":{}}},"output":{"type":"structure","members":{"KeyId":{},"ImportToken":{"type":"blob"},"PublicKey":{"shape":"S1i"},"ParametersValidTo":{"type":"timestamp"}}}},"GetPublicKey":{"input":{"type":"structure","required":["KeyId"],"members":{"KeyId":{},"GrantTokens":{"shape":"Sn"}}},"output":{"type":"structure","members":{"KeyId":{},"PublicKey":{"type":"blob"},"CustomerMasterKeySpec":{},"KeyUsage":{},"EncryptionAlgorithms":{"shape":"S1b"},"SigningAlgorithms":{"shape":"S1d"}}}},"ImportKeyMaterial":{"input":{"type":"structure","required":["KeyId","ImportToken","EncryptedKeyMaterial"],"members":{"KeyId":{},"ImportToken":{"type":"blob"},"EncryptedKeyMaterial":{"type":"blob"},"ValidTo":{"type":"timestamp"},"ExpirationModel":{}}},"output":{"type":"structure","members":{}}},"ListAliases":{"input":{"type":"structure","members":{"KeyId":{},"Limit":{"type":"integer"},"Marker":{}}},"output":{"type":"structure","members":{"Aliases":{"type":"list","member":{"type":"structure","members":{"AliasName":{},"AliasArn":{},"TargetKeyId":{}}}},"NextMarker":{},"Truncated":{"type":"boolean"}}}},"ListGrants":{"input":{"type":"structure","required":["KeyId"],"members":{"Limit":{"type":"integer"},"Marker":{},"KeyId":{}}},"output":{"shape":"S31"}},"ListKeyPolicies":{"input":{"type":"structure","required":["KeyId"],"members":{"KeyId":{},"Limit":{"type":"integer"},"Marker":{}}},"output":{"type":"structure","members":{"PolicyNames":{"type":"list","member":{}},"NextMarker":{},"Truncated":{"type":"boolean"}}}},"ListKeys":{"input":{"type":"structure","members":{"Limit":{"type":"integer"},"Marker":{}}},"output":{"type":"structure","members":{"Keys":{"type":"list","member":{"type":"structure","members":{"KeyId":{},"KeyArn":{}}}},"NextMarker":{},"Truncated":{"type":"boolean"}}}},"ListResourceTags":{"input":{"type":"structure","required":["KeyId"],"members":{"KeyId":{},"Limit":{"type":"integer"},"Marker":{}}},"output":{"type":"structure","members":{"Tags":{"shape":"Sz"},"NextMarker":{},"Truncated":{"type":"boolean"}}}},"ListRetirableGrants":{"input":{"type":"structure","required":["RetiringPrincipal"],"members":{"Limit":{"type":"integer"},"Marker":{},"RetiringPrincipal":{}}},"output":{"shape":"S31"}},"PutKeyPolicy":{"input":{"type":"structure","required":["KeyId","PolicyName","Policy"],"members":{"KeyId":{},"PolicyName":{},"Policy":{},"BypassPolicyLockoutSafetyCheck":{"type":"boolean"}}}},"ReEncrypt":{"input":{"type":"structure","required":["CiphertextBlob","DestinationKeyId"],"members":{"CiphertextBlob":{"type":"blob"},"SourceEncryptionContext":{"shape":"Sk"},"SourceKeyId":{},"DestinationKeyId":{},"DestinationEncryptionContext":{"shape":"Sk"},"SourceEncryptionAlgorithm":{},"DestinationEncryptionAlgorithm":{},"GrantTokens":{"shape":"Sn"}}},"output":{"type":"structure","members":{"CiphertextBlob":{"type":"blob"},"SourceKeyId":{},"KeyId":{},"SourceEncryptionAlgorithm":{},"DestinationEncryptionAlgorithm":{}}}},"RetireGrant":{"input":{"type":"structure","members":{"GrantToken":{},"KeyId":{},"GrantId":{}}}},"RevokeGrant":{"input":{"type":"structure","required":["KeyId","GrantId"],"members":{"KeyId":{},"GrantId":{}}}},"ScheduleKeyDeletion":{"input":{"type":"structure","required":["KeyId"],"members":{"KeyId":{},"PendingWindowInDays":{"type":"integer"}}},"output":{"type":"structure","members":{"KeyId":{},"DeletionDate":{"type":"timestamp"}}}},"Sign":{"input":{"type":"structure","required":["KeyId","Message","SigningAlgorithm"],"members":{"KeyId":{},"Message":{"shape":"S1i"},"MessageType":{},"GrantTokens":{"shape":"Sn"},"SigningAlgorithm":{}}},"output":{"type":"structure","members":{"KeyId":{},"Signature":{"type":"blob"},"SigningAlgorithm":{}}}},"TagResource":{"input":{"type":"structure","required":["KeyId","Tags"],"members":{"KeyId":{},"Tags":{"shape":"Sz"}}}},"UntagResource":{"input":{"type":"structure","required":["KeyId","TagKeys"],"members":{"KeyId":{},"TagKeys":{"type":"list","member":{}}}}},"UpdateAlias":{"input":{"type":"structure","required":["AliasName","TargetKeyId"],"members":{"AliasName":{},"TargetKeyId":{}}}},"UpdateCustomKeyStore":{"input":{"type":"structure","required":["CustomKeyStoreId"],"members":{"CustomKeyStoreId":{},"NewCustomKeyStoreName":{},"KeyStorePassword":{"shape":"Sd"},"CloudHsmClusterId":{}}},"output":{"type":"structure","members":{}}},"UpdateKeyDescription":{"input":{"type":"structure","required":["KeyId","Description"],"members":{"KeyId":{},"Description":{}}}},"Verify":{"input":{"type":"structure","required":["KeyId","Message","Signature","SigningAlgorithm"],"members":{"KeyId":{},"Message":{"shape":"S1i"},"MessageType":{},"Signature":{"type":"blob"},"SigningAlgorithm":{},"GrantTokens":{"shape":"Sn"}}},"output":{"type":"structure","members":{"KeyId":{},"SignatureValid":{"type":"boolean"},"SigningAlgorithm":{}}}}},"shapes":{"Sd":{"type":"string","sensitive":true},"Sh":{"type":"list","member":{}},"Sj":{"type":"structure","members":{"EncryptionContextSubset":{"shape":"Sk"},"EncryptionContextEquals":{"shape":"Sk"}}},"Sk":{"type":"map","key":{},"value":{}},"Sn":{"type":"list","member":{}},"Sz":{"type":"list","member":{"type":"structure","required":["TagKey","TagValue"],"members":{"TagKey":{},"TagValue":{}}}},"S14":{"type":"structure","required":["KeyId"],"members":{"AWSAccountId":{},"KeyId":{},"Arn":{},"CreationDate":{"type":"timestamp"},"Enabled":{"type":"boolean"},"Description":{},"KeyUsage":{},"KeyState":{},"DeletionDate":{"type":"timestamp"},"ValidTo":{"type":"timestamp"},"Origin":{},"CustomKeyStoreId":{},"CloudHsmClusterId":{},"ExpirationModel":{},"KeyManager":{},"CustomerMasterKeySpec":{},"EncryptionAlgorithms":{"shape":"S1b"},"SigningAlgorithms":{"shape":"S1d"}}},"S1b":{"type":"list","member":{}},"S1d":{"type":"list","member":{}},"S1i":{"type":"blob","sensitive":true},"S31":{"type":"structure","members":{"Grants":{"type":"list","member":{"type":"structure","members":{"KeyId":{},"GrantId":{},"Name":{},"CreationDate":{"type":"timestamp"},"GranteePrincipal":{},"RetiringPrincipal":{},"IssuingAccount":{},"Operations":{"shape":"Sh"},"Constraints":{"shape":"Sj"}}}},"NextMarker":{},"Truncated":{"type":"boolean"}}}}}; + detected = true; + atExplicitKey = true; + allowCompact = true; -/***/ }), + } else if (atExplicitKey) { + // i.e. 0x3A/* : */ === character after the explicit key. + atExplicitKey = false; + allowCompact = true; -/***/ 3229: -/***/ (function(module) { + } else { + throwError(state, 'incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line'); + } -module.exports = {"pagination":{"ListChannels":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"ListDatasetContents":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"ListDatasets":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"ListDatastores":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"ListPipelines":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"}}}; + state.position += 1; + ch = following; -/***/ }), + // + // Implicit notation case. Flow-style node as the key first, then ":", and the value. + // + } else { + _keyLine = state.line; + _keyLineStart = state.lineStart; + _keyPos = state.position; -/***/ 3234: -/***/ (function(module, __unusedexports, __webpack_require__) { + if (!composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) { + // Neither implicit nor explicit notation. + // Reading is done. Go to the epilogue. + break; + } -var util = __webpack_require__(153); + if (state.line === _line) { + ch = state.input.charCodeAt(state.position); -util.isBrowser = function() { return false; }; -util.isNode = function() { return true; }; + while (is_WHITE_SPACE(ch)) { + ch = state.input.charCodeAt(++state.position); + } -// node.js specific modules -util.crypto.lib = __webpack_require__(6417); -util.Buffer = __webpack_require__(4293).Buffer; -util.domain = __webpack_require__(5229); -util.stream = __webpack_require__(2413); -util.url = __webpack_require__(8835); -util.querystring = __webpack_require__(1191); -util.environment = 'nodejs'; -util.createEventStream = util.stream.Readable ? - __webpack_require__(445).createEventStream : __webpack_require__(1661).createEventStream; -util.realClock = __webpack_require__(6693); -util.clientSideMonitoring = { - Publisher: __webpack_require__(1701).Publisher, - configProvider: __webpack_require__(1762), -}; -util.iniLoader = __webpack_require__(5892).iniLoader; + if (ch === 0x3A/* : */) { + ch = state.input.charCodeAt(++state.position); -var AWS; + if (!is_WS_OR_EOL(ch)) { + throwError(state, 'a whitespace character is expected after the key-value separator within a block mapping'); + } -/** - * @api private - */ -module.exports = AWS = __webpack_require__(395); - -__webpack_require__(4923); -__webpack_require__(4906); -__webpack_require__(3043); -__webpack_require__(9543); -__webpack_require__(747); -__webpack_require__(7170); -__webpack_require__(2966); -__webpack_require__(2982); - -// Load the xml2js XML parser -AWS.XML.Parser = __webpack_require__(9810); - -// Load Node HTTP client -__webpack_require__(6888); - -__webpack_require__(1818); - -// Load custom credential providers -__webpack_require__(8868); -__webpack_require__(6103); -__webpack_require__(7426); -__webpack_require__(9316); -__webpack_require__(872); -__webpack_require__(634); -__webpack_require__(6431); -__webpack_require__(2982); - -// Setup default chain providers -// If this changes, please update documentation for -// AWS.CredentialProviderChain.defaultProviders in -// credentials/credential_provider_chain.js -AWS.CredentialProviderChain.defaultProviders = [ - function () { return new AWS.EnvironmentCredentials('AWS'); }, - function () { return new AWS.EnvironmentCredentials('AMAZON'); }, - function () { return new AWS.SharedIniFileCredentials(); }, - function () { return new AWS.ECSCredentials(); }, - function () { return new AWS.ProcessCredentials(); }, - function () { return new AWS.TokenFileWebIdentityCredentials(); }, - function () { return new AWS.EC2MetadataCredentials(); } -]; + if (atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos); + keyTag = keyNode = valueNode = null; + } -// Update configuration keys -AWS.util.update(AWS.Config.prototype.keys, { - credentials: function () { - var credentials = null; - new AWS.CredentialProviderChain([ - function () { return new AWS.EnvironmentCredentials('AWS'); }, - function () { return new AWS.EnvironmentCredentials('AMAZON'); }, - function () { return new AWS.SharedIniFileCredentials({ disableAssumeRole: true }); } - ]).resolve(function(err, creds) { - if (!err) credentials = creds; - }); - return credentials; - }, - credentialProvider: function() { - return new AWS.CredentialProviderChain(); - }, - logger: function () { - return process.env.AWSJS_DEBUG ? console : null; - }, - region: function() { - var env = process.env; - var region = env.AWS_REGION || env.AMAZON_REGION; - if (env[AWS.util.configOptInEnv]) { - var toCheck = [ - {filename: env[AWS.util.sharedCredentialsFileEnv]}, - {isConfig: true, filename: env[AWS.util.sharedConfigFileEnv]} - ]; - var iniLoader = AWS.util.iniLoader; - while (!region && toCheck.length) { - var configFile = iniLoader.loadFrom(toCheck.shift()); - var profile = configFile[env.AWS_PROFILE || AWS.util.defaultProfile]; - region = profile && profile.region; - } - } - return region; - } -}); + detected = true; + atExplicitKey = false; + allowCompact = false; + keyTag = state.tag; + keyNode = state.result; -// Reset configuration -AWS.config = new AWS.Config(); + } else if (detected) { + throwError(state, 'can not read an implicit mapping pair; a colon is missed'); + } else { + state.tag = _tag; + state.anchor = _anchor; + return true; // Keep the result of `composeNode`. + } -/***/ }), + } else if (detected) { + throwError(state, 'can not read a block mapping entry; a multiline key may not be an implicit key'); -/***/ 3252: -/***/ (function(module) { + } else { + state.tag = _tag; + state.anchor = _anchor; + return true; // Keep the result of `composeNode`. + } + } -module.exports = {"metadata":{"apiVersion":"2017-09-08","endpointPrefix":"serverlessrepo","signingName":"serverlessrepo","serviceFullName":"AWSServerlessApplicationRepository","serviceId":"ServerlessApplicationRepository","protocol":"rest-json","jsonVersion":"1.1","uid":"serverlessrepo-2017-09-08","signatureVersion":"v4"},"operations":{"CreateApplication":{"http":{"requestUri":"/applications","responseCode":201},"input":{"type":"structure","members":{"Author":{"locationName":"author"},"Description":{"locationName":"description"},"HomePageUrl":{"locationName":"homePageUrl"},"Labels":{"shape":"S3","locationName":"labels"},"LicenseBody":{"locationName":"licenseBody"},"LicenseUrl":{"locationName":"licenseUrl"},"Name":{"locationName":"name"},"ReadmeBody":{"locationName":"readmeBody"},"ReadmeUrl":{"locationName":"readmeUrl"},"SemanticVersion":{"locationName":"semanticVersion"},"SourceCodeArchiveUrl":{"locationName":"sourceCodeArchiveUrl"},"SourceCodeUrl":{"locationName":"sourceCodeUrl"},"SpdxLicenseId":{"locationName":"spdxLicenseId"},"TemplateBody":{"locationName":"templateBody"},"TemplateUrl":{"locationName":"templateUrl"}},"required":["Description","Name","Author"]},"output":{"type":"structure","members":{"ApplicationId":{"locationName":"applicationId"},"Author":{"locationName":"author"},"CreationTime":{"locationName":"creationTime"},"Description":{"locationName":"description"},"HomePageUrl":{"locationName":"homePageUrl"},"IsVerifiedAuthor":{"locationName":"isVerifiedAuthor","type":"boolean"},"Labels":{"shape":"S3","locationName":"labels"},"LicenseUrl":{"locationName":"licenseUrl"},"Name":{"locationName":"name"},"ReadmeUrl":{"locationName":"readmeUrl"},"SpdxLicenseId":{"locationName":"spdxLicenseId"},"VerifiedAuthorUrl":{"locationName":"verifiedAuthorUrl"},"Version":{"shape":"S6","locationName":"version"}}}},"CreateApplicationVersion":{"http":{"method":"PUT","requestUri":"/applications/{applicationId}/versions/{semanticVersion}","responseCode":201},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"applicationId"},"SemanticVersion":{"location":"uri","locationName":"semanticVersion"},"SourceCodeArchiveUrl":{"locationName":"sourceCodeArchiveUrl"},"SourceCodeUrl":{"locationName":"sourceCodeUrl"},"TemplateBody":{"locationName":"templateBody"},"TemplateUrl":{"locationName":"templateUrl"}},"required":["ApplicationId","SemanticVersion"]},"output":{"type":"structure","members":{"ApplicationId":{"locationName":"applicationId"},"CreationTime":{"locationName":"creationTime"},"ParameterDefinitions":{"shape":"S7","locationName":"parameterDefinitions"},"RequiredCapabilities":{"shape":"Sa","locationName":"requiredCapabilities"},"ResourcesSupported":{"locationName":"resourcesSupported","type":"boolean"},"SemanticVersion":{"locationName":"semanticVersion"},"SourceCodeArchiveUrl":{"locationName":"sourceCodeArchiveUrl"},"SourceCodeUrl":{"locationName":"sourceCodeUrl"},"TemplateUrl":{"locationName":"templateUrl"}}}},"CreateCloudFormationChangeSet":{"http":{"requestUri":"/applications/{applicationId}/changesets","responseCode":201},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"applicationId"},"Capabilities":{"shape":"S3","locationName":"capabilities"},"ChangeSetName":{"locationName":"changeSetName"},"ClientToken":{"locationName":"clientToken"},"Description":{"locationName":"description"},"NotificationArns":{"shape":"S3","locationName":"notificationArns"},"ParameterOverrides":{"locationName":"parameterOverrides","type":"list","member":{"type":"structure","members":{"Name":{"locationName":"name"},"Value":{"locationName":"value"}},"required":["Value","Name"]}},"ResourceTypes":{"shape":"S3","locationName":"resourceTypes"},"RollbackConfiguration":{"locationName":"rollbackConfiguration","type":"structure","members":{"MonitoringTimeInMinutes":{"locationName":"monitoringTimeInMinutes","type":"integer"},"RollbackTriggers":{"locationName":"rollbackTriggers","type":"list","member":{"type":"structure","members":{"Arn":{"locationName":"arn"},"Type":{"locationName":"type"}},"required":["Type","Arn"]}}}},"SemanticVersion":{"locationName":"semanticVersion"},"StackName":{"locationName":"stackName"},"Tags":{"locationName":"tags","type":"list","member":{"type":"structure","members":{"Key":{"locationName":"key"},"Value":{"locationName":"value"}},"required":["Value","Key"]}},"TemplateId":{"locationName":"templateId"}},"required":["ApplicationId","StackName"]},"output":{"type":"structure","members":{"ApplicationId":{"locationName":"applicationId"},"ChangeSetId":{"locationName":"changeSetId"},"SemanticVersion":{"locationName":"semanticVersion"},"StackId":{"locationName":"stackId"}}}},"CreateCloudFormationTemplate":{"http":{"requestUri":"/applications/{applicationId}/templates","responseCode":201},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"applicationId"},"SemanticVersion":{"locationName":"semanticVersion"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"ApplicationId":{"locationName":"applicationId"},"CreationTime":{"locationName":"creationTime"},"ExpirationTime":{"locationName":"expirationTime"},"SemanticVersion":{"locationName":"semanticVersion"},"Status":{"locationName":"status"},"TemplateId":{"locationName":"templateId"},"TemplateUrl":{"locationName":"templateUrl"}}}},"DeleteApplication":{"http":{"method":"DELETE","requestUri":"/applications/{applicationId}","responseCode":204},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"applicationId"}},"required":["ApplicationId"]}},"GetApplication":{"http":{"method":"GET","requestUri":"/applications/{applicationId}","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"applicationId"},"SemanticVersion":{"location":"querystring","locationName":"semanticVersion"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"ApplicationId":{"locationName":"applicationId"},"Author":{"locationName":"author"},"CreationTime":{"locationName":"creationTime"},"Description":{"locationName":"description"},"HomePageUrl":{"locationName":"homePageUrl"},"IsVerifiedAuthor":{"locationName":"isVerifiedAuthor","type":"boolean"},"Labels":{"shape":"S3","locationName":"labels"},"LicenseUrl":{"locationName":"licenseUrl"},"Name":{"locationName":"name"},"ReadmeUrl":{"locationName":"readmeUrl"},"SpdxLicenseId":{"locationName":"spdxLicenseId"},"VerifiedAuthorUrl":{"locationName":"verifiedAuthorUrl"},"Version":{"shape":"S6","locationName":"version"}}}},"GetApplicationPolicy":{"http":{"method":"GET","requestUri":"/applications/{applicationId}/policy","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"applicationId"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"Statements":{"shape":"Sv","locationName":"statements"}}}},"GetCloudFormationTemplate":{"http":{"method":"GET","requestUri":"/applications/{applicationId}/templates/{templateId}","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"applicationId"},"TemplateId":{"location":"uri","locationName":"templateId"}},"required":["ApplicationId","TemplateId"]},"output":{"type":"structure","members":{"ApplicationId":{"locationName":"applicationId"},"CreationTime":{"locationName":"creationTime"},"ExpirationTime":{"locationName":"expirationTime"},"SemanticVersion":{"locationName":"semanticVersion"},"Status":{"locationName":"status"},"TemplateId":{"locationName":"templateId"},"TemplateUrl":{"locationName":"templateUrl"}}}},"ListApplicationDependencies":{"http":{"method":"GET","requestUri":"/applications/{applicationId}/dependencies","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"applicationId"},"MaxItems":{"location":"querystring","locationName":"maxItems","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"},"SemanticVersion":{"location":"querystring","locationName":"semanticVersion"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"Dependencies":{"locationName":"dependencies","type":"list","member":{"type":"structure","members":{"ApplicationId":{"locationName":"applicationId"},"SemanticVersion":{"locationName":"semanticVersion"}},"required":["ApplicationId","SemanticVersion"]}},"NextToken":{"locationName":"nextToken"}}}},"ListApplicationVersions":{"http":{"method":"GET","requestUri":"/applications/{applicationId}/versions","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"applicationId"},"MaxItems":{"location":"querystring","locationName":"maxItems","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"NextToken":{"locationName":"nextToken"},"Versions":{"locationName":"versions","type":"list","member":{"type":"structure","members":{"ApplicationId":{"locationName":"applicationId"},"CreationTime":{"locationName":"creationTime"},"SemanticVersion":{"locationName":"semanticVersion"},"SourceCodeUrl":{"locationName":"sourceCodeUrl"}},"required":["CreationTime","ApplicationId","SemanticVersion"]}}}}},"ListApplications":{"http":{"method":"GET","requestUri":"/applications","responseCode":200},"input":{"type":"structure","members":{"MaxItems":{"location":"querystring","locationName":"maxItems","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"Applications":{"locationName":"applications","type":"list","member":{"type":"structure","members":{"ApplicationId":{"locationName":"applicationId"},"Author":{"locationName":"author"},"CreationTime":{"locationName":"creationTime"},"Description":{"locationName":"description"},"HomePageUrl":{"locationName":"homePageUrl"},"Labels":{"shape":"S3","locationName":"labels"},"Name":{"locationName":"name"},"SpdxLicenseId":{"locationName":"spdxLicenseId"}},"required":["Description","Author","ApplicationId","Name"]}},"NextToken":{"locationName":"nextToken"}}}},"PutApplicationPolicy":{"http":{"method":"PUT","requestUri":"/applications/{applicationId}/policy","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"applicationId"},"Statements":{"shape":"Sv","locationName":"statements"}},"required":["ApplicationId","Statements"]},"output":{"type":"structure","members":{"Statements":{"shape":"Sv","locationName":"statements"}}}},"UnshareApplication":{"http":{"requestUri":"/applications/{applicationId}/unshare","responseCode":204},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"applicationId"},"OrganizationId":{"locationName":"organizationId"}},"required":["ApplicationId","OrganizationId"]}},"UpdateApplication":{"http":{"method":"PATCH","requestUri":"/applications/{applicationId}","responseCode":200},"input":{"type":"structure","members":{"ApplicationId":{"location":"uri","locationName":"applicationId"},"Author":{"locationName":"author"},"Description":{"locationName":"description"},"HomePageUrl":{"locationName":"homePageUrl"},"Labels":{"shape":"S3","locationName":"labels"},"ReadmeBody":{"locationName":"readmeBody"},"ReadmeUrl":{"locationName":"readmeUrl"}},"required":["ApplicationId"]},"output":{"type":"structure","members":{"ApplicationId":{"locationName":"applicationId"},"Author":{"locationName":"author"},"CreationTime":{"locationName":"creationTime"},"Description":{"locationName":"description"},"HomePageUrl":{"locationName":"homePageUrl"},"IsVerifiedAuthor":{"locationName":"isVerifiedAuthor","type":"boolean"},"Labels":{"shape":"S3","locationName":"labels"},"LicenseUrl":{"locationName":"licenseUrl"},"Name":{"locationName":"name"},"ReadmeUrl":{"locationName":"readmeUrl"},"SpdxLicenseId":{"locationName":"spdxLicenseId"},"VerifiedAuthorUrl":{"locationName":"verifiedAuthorUrl"},"Version":{"shape":"S6","locationName":"version"}}}}},"shapes":{"S3":{"type":"list","member":{}},"S6":{"type":"structure","members":{"ApplicationId":{"locationName":"applicationId"},"CreationTime":{"locationName":"creationTime"},"ParameterDefinitions":{"shape":"S7","locationName":"parameterDefinitions"},"RequiredCapabilities":{"shape":"Sa","locationName":"requiredCapabilities"},"ResourcesSupported":{"locationName":"resourcesSupported","type":"boolean"},"SemanticVersion":{"locationName":"semanticVersion"},"SourceCodeArchiveUrl":{"locationName":"sourceCodeArchiveUrl"},"SourceCodeUrl":{"locationName":"sourceCodeUrl"},"TemplateUrl":{"locationName":"templateUrl"}},"required":["TemplateUrl","ParameterDefinitions","ResourcesSupported","CreationTime","RequiredCapabilities","ApplicationId","SemanticVersion"]},"S7":{"type":"list","member":{"type":"structure","members":{"AllowedPattern":{"locationName":"allowedPattern"},"AllowedValues":{"shape":"S3","locationName":"allowedValues"},"ConstraintDescription":{"locationName":"constraintDescription"},"DefaultValue":{"locationName":"defaultValue"},"Description":{"locationName":"description"},"MaxLength":{"locationName":"maxLength","type":"integer"},"MaxValue":{"locationName":"maxValue","type":"integer"},"MinLength":{"locationName":"minLength","type":"integer"},"MinValue":{"locationName":"minValue","type":"integer"},"Name":{"locationName":"name"},"NoEcho":{"locationName":"noEcho","type":"boolean"},"ReferencedByResources":{"shape":"S3","locationName":"referencedByResources"},"Type":{"locationName":"type"}},"required":["ReferencedByResources","Name"]}},"Sa":{"type":"list","member":{}},"Sv":{"type":"list","member":{"type":"structure","members":{"Actions":{"shape":"S3","locationName":"actions"},"PrincipalOrgIDs":{"shape":"S3","locationName":"principalOrgIDs"},"Principals":{"shape":"S3","locationName":"principals"},"StatementId":{"locationName":"statementId"}},"required":["Principals","Actions"]}}}}; + // + // Common reading code for both explicit and implicit notations. + // + if (state.line === _line || state.lineIndent > nodeIndent) { + if (atExplicitKey) { + _keyLine = state.line; + _keyLineStart = state.lineStart; + _keyPos = state.position; + } -/***/ }), + if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) { + if (atExplicitKey) { + keyNode = state.result; + } else { + valueNode = state.result; + } + } -/***/ 3253: -/***/ (function(module) { + if (!atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _keyLine, _keyLineStart, _keyPos); + keyTag = keyNode = valueNode = null; + } -module.exports = {"version":2,"waiters":{"DistributionDeployed":{"delay":60,"operation":"GetDistribution","maxAttempts":25,"description":"Wait until a distribution is deployed.","acceptors":[{"expected":"Deployed","matcher":"path","state":"success","argument":"Distribution.Status"}]},"InvalidationCompleted":{"delay":20,"operation":"GetInvalidation","maxAttempts":30,"description":"Wait until an invalidation has completed.","acceptors":[{"expected":"Completed","matcher":"path","state":"success","argument":"Invalidation.Status"}]},"StreamingDistributionDeployed":{"delay":60,"operation":"GetStreamingDistribution","maxAttempts":25,"description":"Wait until a streaming distribution is deployed.","acceptors":[{"expected":"Deployed","matcher":"path","state":"success","argument":"StreamingDistribution.Status"}]}}}; + skipSeparationSpace(state, true, -1); + ch = state.input.charCodeAt(state.position); + } -/***/ }), + if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) { + throwError(state, 'bad indentation of a mapping entry'); + } else if (state.lineIndent < nodeIndent) { + break; + } + } -/***/ 3260: -/***/ (function(module) { + // + // Epilogue. + // -module.exports = {"version":"2.0","metadata":{"apiVersion":"2018-04-01","endpointPrefix":"quicksight","jsonVersion":"1.0","protocol":"rest-json","serviceFullName":"Amazon QuickSight","serviceId":"QuickSight","signatureVersion":"v4","uid":"quicksight-2018-04-01"},"operations":{"CancelIngestion":{"http":{"method":"DELETE","requestUri":"/accounts/{AwsAccountId}/data-sets/{DataSetId}/ingestions/{IngestionId}"},"input":{"type":"structure","required":["AwsAccountId","DataSetId","IngestionId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"DataSetId":{"location":"uri","locationName":"DataSetId"},"IngestionId":{"location":"uri","locationName":"IngestionId"}}},"output":{"type":"structure","members":{"Arn":{},"IngestionId":{},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"CreateAccountCustomization":{"http":{"requestUri":"/accounts/{AwsAccountId}/customizations"},"input":{"type":"structure","required":["AwsAccountId","AccountCustomization"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"Namespace":{"location":"querystring","locationName":"namespace"},"AccountCustomization":{"shape":"Sa"}}},"output":{"type":"structure","members":{"AwsAccountId":{},"Namespace":{},"AccountCustomization":{"shape":"Sa"},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"CreateDashboard":{"http":{"requestUri":"/accounts/{AwsAccountId}/dashboards/{DashboardId}"},"input":{"type":"structure","required":["AwsAccountId","DashboardId","Name","SourceEntity"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"DashboardId":{"location":"uri","locationName":"DashboardId"},"Name":{},"Parameters":{"shape":"Sg"},"Permissions":{"shape":"Sx"},"SourceEntity":{"shape":"S11"},"Tags":{"shape":"S15"},"VersionDescription":{},"DashboardPublishOptions":{"shape":"S1a"},"ThemeArn":{}}},"output":{"type":"structure","members":{"Arn":{},"VersionArn":{},"DashboardId":{},"CreationStatus":{},"Status":{"location":"statusCode","type":"integer"},"RequestId":{}}}},"CreateDataSet":{"http":{"requestUri":"/accounts/{AwsAccountId}/data-sets"},"input":{"type":"structure","required":["AwsAccountId","DataSetId","Name","PhysicalTableMap","ImportMode"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"DataSetId":{},"Name":{},"PhysicalTableMap":{"shape":"S1l"},"LogicalTableMap":{"shape":"S25"},"ImportMode":{},"ColumnGroups":{"shape":"S2w"},"Permissions":{"shape":"Sx"},"RowLevelPermissionDataSet":{"shape":"S32"},"Tags":{"shape":"S15"}}},"output":{"type":"structure","members":{"Arn":{},"DataSetId":{},"IngestionArn":{},"IngestionId":{},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"CreateDataSource":{"http":{"requestUri":"/accounts/{AwsAccountId}/data-sources"},"input":{"type":"structure","required":["AwsAccountId","DataSourceId","Name","Type"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"DataSourceId":{},"Name":{},"Type":{},"DataSourceParameters":{"shape":"S37"},"Credentials":{"shape":"S47"},"Permissions":{"shape":"Sx"},"VpcConnectionProperties":{"shape":"S4d"},"SslProperties":{"shape":"S4e"},"Tags":{"shape":"S15"}}},"output":{"type":"structure","members":{"Arn":{},"DataSourceId":{},"CreationStatus":{},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"CreateGroup":{"http":{"requestUri":"/accounts/{AwsAccountId}/namespaces/{Namespace}/groups"},"input":{"type":"structure","required":["GroupName","AwsAccountId","Namespace"],"members":{"GroupName":{},"Description":{},"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"Namespace":{"location":"uri","locationName":"Namespace"}}},"output":{"type":"structure","members":{"Group":{"shape":"S4k"},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"CreateGroupMembership":{"http":{"method":"PUT","requestUri":"/accounts/{AwsAccountId}/namespaces/{Namespace}/groups/{GroupName}/members/{MemberName}"},"input":{"type":"structure","required":["MemberName","GroupName","AwsAccountId","Namespace"],"members":{"MemberName":{"location":"uri","locationName":"MemberName"},"GroupName":{"location":"uri","locationName":"GroupName"},"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"Namespace":{"location":"uri","locationName":"Namespace"}}},"output":{"type":"structure","members":{"GroupMember":{"shape":"S4o"},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"CreateIAMPolicyAssignment":{"http":{"requestUri":"/accounts/{AwsAccountId}/namespaces/{Namespace}/iam-policy-assignments/"},"input":{"type":"structure","required":["AwsAccountId","AssignmentName","AssignmentStatus","Namespace"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"AssignmentName":{},"AssignmentStatus":{},"PolicyArn":{},"Identities":{"shape":"S4s"},"Namespace":{"location":"uri","locationName":"Namespace"}}},"output":{"type":"structure","members":{"AssignmentName":{},"AssignmentId":{},"AssignmentStatus":{},"PolicyArn":{},"Identities":{"shape":"S4s"},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"CreateIngestion":{"http":{"method":"PUT","requestUri":"/accounts/{AwsAccountId}/data-sets/{DataSetId}/ingestions/{IngestionId}"},"input":{"type":"structure","required":["DataSetId","IngestionId","AwsAccountId"],"members":{"DataSetId":{"location":"uri","locationName":"DataSetId"},"IngestionId":{"location":"uri","locationName":"IngestionId"},"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"}}},"output":{"type":"structure","members":{"Arn":{},"IngestionId":{},"IngestionStatus":{},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"CreateNamespace":{"http":{"requestUri":"/accounts/{AwsAccountId}"},"input":{"type":"structure","required":["AwsAccountId","Namespace","IdentityStore"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"Namespace":{},"IdentityStore":{},"Tags":{"shape":"S15"}}},"output":{"type":"structure","members":{"Arn":{},"Name":{},"CapacityRegion":{},"CreationStatus":{},"IdentityStore":{},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"CreateTemplate":{"http":{"requestUri":"/accounts/{AwsAccountId}/templates/{TemplateId}"},"input":{"type":"structure","required":["AwsAccountId","TemplateId","SourceEntity"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"TemplateId":{"location":"uri","locationName":"TemplateId"},"Name":{},"Permissions":{"shape":"Sx"},"SourceEntity":{"shape":"S55"},"Tags":{"shape":"S15"},"VersionDescription":{}}},"output":{"type":"structure","members":{"Arn":{},"VersionArn":{},"TemplateId":{},"CreationStatus":{},"Status":{"location":"statusCode","type":"integer"},"RequestId":{}}}},"CreateTemplateAlias":{"http":{"requestUri":"/accounts/{AwsAccountId}/templates/{TemplateId}/aliases/{AliasName}"},"input":{"type":"structure","required":["AwsAccountId","TemplateId","AliasName","TemplateVersionNumber"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"TemplateId":{"location":"uri","locationName":"TemplateId"},"AliasName":{"location":"uri","locationName":"AliasName"},"TemplateVersionNumber":{"type":"long"}}},"output":{"type":"structure","members":{"TemplateAlias":{"shape":"S5d"},"Status":{"location":"statusCode","type":"integer"},"RequestId":{}}}},"CreateTheme":{"http":{"requestUri":"/accounts/{AwsAccountId}/themes/{ThemeId}"},"input":{"type":"structure","required":["AwsAccountId","ThemeId","Name","BaseThemeId","Configuration"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"ThemeId":{"location":"uri","locationName":"ThemeId"},"Name":{},"BaseThemeId":{},"VersionDescription":{},"Configuration":{"shape":"S5g"},"Permissions":{"shape":"Sx"},"Tags":{"shape":"S15"}}},"output":{"type":"structure","members":{"Arn":{},"VersionArn":{},"ThemeId":{},"CreationStatus":{},"Status":{"location":"statusCode","type":"integer"},"RequestId":{}}}},"CreateThemeAlias":{"http":{"requestUri":"/accounts/{AwsAccountId}/themes/{ThemeId}/aliases/{AliasName}"},"input":{"type":"structure","required":["AwsAccountId","ThemeId","AliasName","ThemeVersionNumber"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"ThemeId":{"location":"uri","locationName":"ThemeId"},"AliasName":{"location":"uri","locationName":"AliasName"},"ThemeVersionNumber":{"type":"long"}}},"output":{"type":"structure","members":{"ThemeAlias":{"shape":"S5v"},"Status":{"location":"statusCode","type":"integer"},"RequestId":{}}}},"DeleteAccountCustomization":{"http":{"method":"DELETE","requestUri":"/accounts/{AwsAccountId}/customizations"},"input":{"type":"structure","required":["AwsAccountId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"Namespace":{"location":"querystring","locationName":"namespace"}}},"output":{"type":"structure","members":{"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"DeleteDashboard":{"http":{"method":"DELETE","requestUri":"/accounts/{AwsAccountId}/dashboards/{DashboardId}"},"input":{"type":"structure","required":["AwsAccountId","DashboardId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"DashboardId":{"location":"uri","locationName":"DashboardId"},"VersionNumber":{"location":"querystring","locationName":"version-number","type":"long"}}},"output":{"type":"structure","members":{"Status":{"location":"statusCode","type":"integer"},"Arn":{},"DashboardId":{},"RequestId":{}}}},"DeleteDataSet":{"http":{"method":"DELETE","requestUri":"/accounts/{AwsAccountId}/data-sets/{DataSetId}"},"input":{"type":"structure","required":["AwsAccountId","DataSetId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"DataSetId":{"location":"uri","locationName":"DataSetId"}}},"output":{"type":"structure","members":{"Arn":{},"DataSetId":{},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"DeleteDataSource":{"http":{"method":"DELETE","requestUri":"/accounts/{AwsAccountId}/data-sources/{DataSourceId}"},"input":{"type":"structure","required":["AwsAccountId","DataSourceId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"DataSourceId":{"location":"uri","locationName":"DataSourceId"}}},"output":{"type":"structure","members":{"Arn":{},"DataSourceId":{},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"DeleteGroup":{"http":{"method":"DELETE","requestUri":"/accounts/{AwsAccountId}/namespaces/{Namespace}/groups/{GroupName}"},"input":{"type":"structure","required":["GroupName","AwsAccountId","Namespace"],"members":{"GroupName":{"location":"uri","locationName":"GroupName"},"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"Namespace":{"location":"uri","locationName":"Namespace"}}},"output":{"type":"structure","members":{"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"DeleteGroupMembership":{"http":{"method":"DELETE","requestUri":"/accounts/{AwsAccountId}/namespaces/{Namespace}/groups/{GroupName}/members/{MemberName}"},"input":{"type":"structure","required":["MemberName","GroupName","AwsAccountId","Namespace"],"members":{"MemberName":{"location":"uri","locationName":"MemberName"},"GroupName":{"location":"uri","locationName":"GroupName"},"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"Namespace":{"location":"uri","locationName":"Namespace"}}},"output":{"type":"structure","members":{"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"DeleteIAMPolicyAssignment":{"http":{"method":"DELETE","requestUri":"/accounts/{AwsAccountId}/namespace/{Namespace}/iam-policy-assignments/{AssignmentName}"},"input":{"type":"structure","required":["AwsAccountId","AssignmentName","Namespace"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"AssignmentName":{"location":"uri","locationName":"AssignmentName"},"Namespace":{"location":"uri","locationName":"Namespace"}}},"output":{"type":"structure","members":{"AssignmentName":{},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"DeleteNamespace":{"http":{"method":"DELETE","requestUri":"/accounts/{AwsAccountId}/namespaces/{Namespace}"},"input":{"type":"structure","required":["AwsAccountId","Namespace"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"Namespace":{"location":"uri","locationName":"Namespace"}}},"output":{"type":"structure","members":{"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"DeleteTemplate":{"http":{"method":"DELETE","requestUri":"/accounts/{AwsAccountId}/templates/{TemplateId}"},"input":{"type":"structure","required":["AwsAccountId","TemplateId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"TemplateId":{"location":"uri","locationName":"TemplateId"},"VersionNumber":{"location":"querystring","locationName":"version-number","type":"long"}}},"output":{"type":"structure","members":{"RequestId":{},"Arn":{},"TemplateId":{},"Status":{"location":"statusCode","type":"integer"}}}},"DeleteTemplateAlias":{"http":{"method":"DELETE","requestUri":"/accounts/{AwsAccountId}/templates/{TemplateId}/aliases/{AliasName}"},"input":{"type":"structure","required":["AwsAccountId","TemplateId","AliasName"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"TemplateId":{"location":"uri","locationName":"TemplateId"},"AliasName":{"location":"uri","locationName":"AliasName"}}},"output":{"type":"structure","members":{"Status":{"location":"statusCode","type":"integer"},"TemplateId":{},"AliasName":{},"Arn":{},"RequestId":{}}}},"DeleteTheme":{"http":{"method":"DELETE","requestUri":"/accounts/{AwsAccountId}/themes/{ThemeId}"},"input":{"type":"structure","required":["AwsAccountId","ThemeId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"ThemeId":{"location":"uri","locationName":"ThemeId"},"VersionNumber":{"location":"querystring","locationName":"version-number","type":"long"}}},"output":{"type":"structure","members":{"Arn":{},"RequestId":{},"Status":{"location":"statusCode","type":"integer"},"ThemeId":{}}}},"DeleteThemeAlias":{"http":{"method":"DELETE","requestUri":"/accounts/{AwsAccountId}/themes/{ThemeId}/aliases/{AliasName}"},"input":{"type":"structure","required":["AwsAccountId","ThemeId","AliasName"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"ThemeId":{"location":"uri","locationName":"ThemeId"},"AliasName":{"location":"uri","locationName":"AliasName"}}},"output":{"type":"structure","members":{"AliasName":{},"Arn":{},"RequestId":{},"Status":{"location":"statusCode","type":"integer"},"ThemeId":{}}}},"DeleteUser":{"http":{"method":"DELETE","requestUri":"/accounts/{AwsAccountId}/namespaces/{Namespace}/users/{UserName}"},"input":{"type":"structure","required":["UserName","AwsAccountId","Namespace"],"members":{"UserName":{"location":"uri","locationName":"UserName"},"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"Namespace":{"location":"uri","locationName":"Namespace"}}},"output":{"type":"structure","members":{"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"DeleteUserByPrincipalId":{"http":{"method":"DELETE","requestUri":"/accounts/{AwsAccountId}/namespaces/{Namespace}/user-principals/{PrincipalId}"},"input":{"type":"structure","required":["PrincipalId","AwsAccountId","Namespace"],"members":{"PrincipalId":{"location":"uri","locationName":"PrincipalId"},"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"Namespace":{"location":"uri","locationName":"Namespace"}}},"output":{"type":"structure","members":{"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"DescribeAccountCustomization":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/customizations"},"input":{"type":"structure","required":["AwsAccountId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"Namespace":{"location":"querystring","locationName":"namespace"},"Resolved":{"location":"querystring","locationName":"resolved","type":"boolean"}}},"output":{"type":"structure","members":{"AwsAccountId":{},"Namespace":{},"AccountCustomization":{"shape":"Sa"},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"DescribeAccountSettings":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/settings"},"input":{"type":"structure","required":["AwsAccountId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"}}},"output":{"type":"structure","members":{"AccountSettings":{"type":"structure","members":{"AccountName":{},"Edition":{},"DefaultNamespace":{},"NotificationEmail":{}}},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"DescribeDashboard":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/dashboards/{DashboardId}"},"input":{"type":"structure","required":["AwsAccountId","DashboardId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"DashboardId":{"location":"uri","locationName":"DashboardId"},"VersionNumber":{"location":"querystring","locationName":"version-number","type":"long"},"AliasName":{"location":"querystring","locationName":"alias-name"}}},"output":{"type":"structure","members":{"Dashboard":{"type":"structure","members":{"DashboardId":{},"Arn":{},"Name":{},"Version":{"type":"structure","members":{"CreatedTime":{"type":"timestamp"},"Errors":{"type":"list","member":{"type":"structure","members":{"Type":{},"Message":{}}}},"VersionNumber":{"type":"long"},"Status":{},"Arn":{},"SourceEntityArn":{},"DataSetArns":{"type":"list","member":{}},"Description":{}}},"CreatedTime":{"type":"timestamp"},"LastPublishedTime":{"type":"timestamp"},"LastUpdatedTime":{"type":"timestamp"}}},"Status":{"location":"statusCode","type":"integer"},"RequestId":{}}}},"DescribeDashboardPermissions":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/dashboards/{DashboardId}/permissions"},"input":{"type":"structure","required":["AwsAccountId","DashboardId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"DashboardId":{"location":"uri","locationName":"DashboardId"}}},"output":{"type":"structure","members":{"DashboardId":{},"DashboardArn":{},"Permissions":{"shape":"Sx"},"Status":{"location":"statusCode","type":"integer"},"RequestId":{}}}},"DescribeDataSet":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/data-sets/{DataSetId}"},"input":{"type":"structure","required":["AwsAccountId","DataSetId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"DataSetId":{"location":"uri","locationName":"DataSetId"}}},"output":{"type":"structure","members":{"DataSet":{"type":"structure","members":{"Arn":{},"DataSetId":{},"Name":{},"CreatedTime":{"type":"timestamp"},"LastUpdatedTime":{"type":"timestamp"},"PhysicalTableMap":{"shape":"S1l"},"LogicalTableMap":{"shape":"S25"},"OutputColumns":{"type":"list","member":{"type":"structure","members":{"Name":{},"Type":{}}}},"ImportMode":{},"ConsumedSpiceCapacityInBytes":{"type":"long"},"ColumnGroups":{"shape":"S2w"},"RowLevelPermissionDataSet":{"shape":"S32"}}},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"DescribeDataSetPermissions":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/data-sets/{DataSetId}/permissions"},"input":{"type":"structure","required":["AwsAccountId","DataSetId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"DataSetId":{"location":"uri","locationName":"DataSetId"}}},"output":{"type":"structure","members":{"DataSetArn":{},"DataSetId":{},"Permissions":{"shape":"Sx"},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"DescribeDataSource":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/data-sources/{DataSourceId}"},"input":{"type":"structure","required":["AwsAccountId","DataSourceId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"DataSourceId":{"location":"uri","locationName":"DataSourceId"}}},"output":{"type":"structure","members":{"DataSource":{"shape":"S7e"},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"DescribeDataSourcePermissions":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/data-sources/{DataSourceId}/permissions"},"input":{"type":"structure","required":["AwsAccountId","DataSourceId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"DataSourceId":{"location":"uri","locationName":"DataSourceId"}}},"output":{"type":"structure","members":{"DataSourceArn":{},"DataSourceId":{},"Permissions":{"shape":"Sx"},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"DescribeGroup":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/namespaces/{Namespace}/groups/{GroupName}"},"input":{"type":"structure","required":["GroupName","AwsAccountId","Namespace"],"members":{"GroupName":{"location":"uri","locationName":"GroupName"},"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"Namespace":{"location":"uri","locationName":"Namespace"}}},"output":{"type":"structure","members":{"Group":{"shape":"S4k"},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"DescribeIAMPolicyAssignment":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/namespaces/{Namespace}/iam-policy-assignments/{AssignmentName}"},"input":{"type":"structure","required":["AwsAccountId","AssignmentName","Namespace"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"AssignmentName":{"location":"uri","locationName":"AssignmentName"},"Namespace":{"location":"uri","locationName":"Namespace"}}},"output":{"type":"structure","members":{"IAMPolicyAssignment":{"type":"structure","members":{"AwsAccountId":{},"AssignmentId":{},"AssignmentName":{},"PolicyArn":{},"Identities":{"shape":"S4s"},"AssignmentStatus":{}}},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"DescribeIngestion":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/data-sets/{DataSetId}/ingestions/{IngestionId}"},"input":{"type":"structure","required":["AwsAccountId","DataSetId","IngestionId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"DataSetId":{"location":"uri","locationName":"DataSetId"},"IngestionId":{"location":"uri","locationName":"IngestionId"}}},"output":{"type":"structure","members":{"Ingestion":{"shape":"S7q"},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"DescribeNamespace":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/namespaces/{Namespace}"},"input":{"type":"structure","required":["AwsAccountId","Namespace"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"Namespace":{"location":"uri","locationName":"Namespace"}}},"output":{"type":"structure","members":{"Namespace":{"shape":"S81"},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"DescribeTemplate":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/templates/{TemplateId}"},"input":{"type":"structure","required":["AwsAccountId","TemplateId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"TemplateId":{"location":"uri","locationName":"TemplateId"},"VersionNumber":{"location":"querystring","locationName":"version-number","type":"long"},"AliasName":{"location":"querystring","locationName":"alias-name"}}},"output":{"type":"structure","members":{"Template":{"type":"structure","members":{"Arn":{},"Name":{},"Version":{"type":"structure","members":{"CreatedTime":{"type":"timestamp"},"Errors":{"type":"list","member":{"type":"structure","members":{"Type":{},"Message":{}}}},"VersionNumber":{"type":"long"},"Status":{},"DataSetConfigurations":{"type":"list","member":{"type":"structure","members":{"Placeholder":{},"DataSetSchema":{"type":"structure","members":{"ColumnSchemaList":{"type":"list","member":{"type":"structure","members":{"Name":{},"DataType":{},"GeographicRole":{}}}}}},"ColumnGroupSchemaList":{"type":"list","member":{"type":"structure","members":{"Name":{},"ColumnGroupColumnSchemaList":{"type":"list","member":{"type":"structure","members":{"Name":{}}}}}}}}}},"Description":{},"SourceEntityArn":{}}},"TemplateId":{},"LastUpdatedTime":{"type":"timestamp"},"CreatedTime":{"type":"timestamp"}}},"Status":{"location":"statusCode","type":"integer"},"RequestId":{}}}},"DescribeTemplateAlias":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/templates/{TemplateId}/aliases/{AliasName}"},"input":{"type":"structure","required":["AwsAccountId","TemplateId","AliasName"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"TemplateId":{"location":"uri","locationName":"TemplateId"},"AliasName":{"location":"uri","locationName":"AliasName"}}},"output":{"type":"structure","members":{"TemplateAlias":{"shape":"S5d"},"Status":{"location":"statusCode","type":"integer"},"RequestId":{}}}},"DescribeTemplatePermissions":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/templates/{TemplateId}/permissions"},"input":{"type":"structure","required":["AwsAccountId","TemplateId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"TemplateId":{"location":"uri","locationName":"TemplateId"}}},"output":{"type":"structure","members":{"TemplateId":{},"TemplateArn":{},"Permissions":{"shape":"Sx"},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"DescribeTheme":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/themes/{ThemeId}"},"input":{"type":"structure","required":["AwsAccountId","ThemeId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"ThemeId":{"location":"uri","locationName":"ThemeId"},"VersionNumber":{"location":"querystring","locationName":"version-number","type":"long"},"AliasName":{"location":"querystring","locationName":"alias-name"}}},"output":{"type":"structure","members":{"Theme":{"type":"structure","members":{"Arn":{},"Name":{},"ThemeId":{},"Version":{"type":"structure","members":{"VersionNumber":{"type":"long"},"Arn":{},"Description":{},"BaseThemeId":{},"CreatedTime":{"type":"timestamp"},"Configuration":{"shape":"S5g"},"Errors":{"type":"list","member":{"type":"structure","members":{"Type":{},"Message":{}}}},"Status":{}}},"CreatedTime":{"type":"timestamp"},"LastUpdatedTime":{"type":"timestamp"},"Type":{}}},"Status":{"location":"statusCode","type":"integer"},"RequestId":{}}}},"DescribeThemeAlias":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/themes/{ThemeId}/aliases/{AliasName}"},"input":{"type":"structure","required":["AwsAccountId","ThemeId","AliasName"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"ThemeId":{"location":"uri","locationName":"ThemeId"},"AliasName":{"location":"uri","locationName":"AliasName"}}},"output":{"type":"structure","members":{"ThemeAlias":{"shape":"S5v"},"Status":{"location":"statusCode","type":"integer"},"RequestId":{}}}},"DescribeThemePermissions":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/themes/{ThemeId}/permissions"},"input":{"type":"structure","required":["AwsAccountId","ThemeId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"ThemeId":{"location":"uri","locationName":"ThemeId"}}},"output":{"type":"structure","members":{"ThemeId":{},"ThemeArn":{},"Permissions":{"shape":"Sx"},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"DescribeUser":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/namespaces/{Namespace}/users/{UserName}"},"input":{"type":"structure","required":["UserName","AwsAccountId","Namespace"],"members":{"UserName":{"location":"uri","locationName":"UserName"},"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"Namespace":{"location":"uri","locationName":"Namespace"}}},"output":{"type":"structure","members":{"User":{"shape":"S93"},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"GetDashboardEmbedUrl":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/dashboards/{DashboardId}/embed-url"},"input":{"type":"structure","required":["AwsAccountId","DashboardId","IdentityType"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"DashboardId":{"location":"uri","locationName":"DashboardId"},"IdentityType":{"location":"querystring","locationName":"creds-type"},"SessionLifetimeInMinutes":{"location":"querystring","locationName":"session-lifetime","type":"long"},"UndoRedoDisabled":{"location":"querystring","locationName":"undo-redo-disabled","type":"boolean"},"ResetDisabled":{"location":"querystring","locationName":"reset-disabled","type":"boolean"},"UserArn":{"location":"querystring","locationName":"user-arn"}}},"output":{"type":"structure","members":{"EmbedUrl":{"shape":"S9a"},"Status":{"location":"statusCode","type":"integer"},"RequestId":{}}}},"GetSessionEmbedUrl":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/session-embed-url"},"input":{"type":"structure","required":["AwsAccountId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"EntryPoint":{"location":"querystring","locationName":"entry-point"},"SessionLifetimeInMinutes":{"location":"querystring","locationName":"session-lifetime","type":"long"},"UserArn":{"location":"querystring","locationName":"user-arn"}}},"output":{"type":"structure","members":{"EmbedUrl":{"shape":"S9a"},"Status":{"location":"statusCode","type":"integer"},"RequestId":{}}}},"ListDashboardVersions":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/dashboards/{DashboardId}/versions"},"input":{"type":"structure","required":["AwsAccountId","DashboardId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"DashboardId":{"location":"uri","locationName":"DashboardId"},"NextToken":{"location":"querystring","locationName":"next-token"},"MaxResults":{"location":"querystring","locationName":"max-results","type":"integer"}}},"output":{"type":"structure","members":{"DashboardVersionSummaryList":{"type":"list","member":{"type":"structure","members":{"Arn":{},"CreatedTime":{"type":"timestamp"},"VersionNumber":{"type":"long"},"Status":{},"SourceEntityArn":{},"Description":{}}}},"NextToken":{},"Status":{"location":"statusCode","type":"integer"},"RequestId":{}}}},"ListDashboards":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/dashboards"},"input":{"type":"structure","required":["AwsAccountId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"NextToken":{"location":"querystring","locationName":"next-token"},"MaxResults":{"location":"querystring","locationName":"max-results","type":"integer"}}},"output":{"type":"structure","members":{"DashboardSummaryList":{"shape":"S9l"},"NextToken":{},"Status":{"location":"statusCode","type":"integer"},"RequestId":{}}}},"ListDataSets":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/data-sets"},"input":{"type":"structure","required":["AwsAccountId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"NextToken":{"location":"querystring","locationName":"next-token"},"MaxResults":{"location":"querystring","locationName":"max-results","type":"integer"}}},"output":{"type":"structure","members":{"DataSetSummaries":{"type":"list","member":{"type":"structure","members":{"Arn":{},"DataSetId":{},"Name":{},"CreatedTime":{"type":"timestamp"},"LastUpdatedTime":{"type":"timestamp"},"ImportMode":{},"RowLevelPermissionDataSet":{"shape":"S32"}}}},"NextToken":{},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"ListDataSources":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/data-sources"},"input":{"type":"structure","required":["AwsAccountId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"NextToken":{"location":"querystring","locationName":"next-token"},"MaxResults":{"location":"querystring","locationName":"max-results","type":"integer"}}},"output":{"type":"structure","members":{"DataSources":{"type":"list","member":{"shape":"S7e"}},"NextToken":{},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"ListGroupMemberships":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/namespaces/{Namespace}/groups/{GroupName}/members"},"input":{"type":"structure","required":["GroupName","AwsAccountId","Namespace"],"members":{"GroupName":{"location":"uri","locationName":"GroupName"},"NextToken":{"location":"querystring","locationName":"next-token"},"MaxResults":{"location":"querystring","locationName":"max-results","type":"integer"},"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"Namespace":{"location":"uri","locationName":"Namespace"}}},"output":{"type":"structure","members":{"GroupMemberList":{"type":"list","member":{"shape":"S4o"}},"NextToken":{},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"ListGroups":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/namespaces/{Namespace}/groups"},"input":{"type":"structure","required":["AwsAccountId","Namespace"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"NextToken":{"location":"querystring","locationName":"next-token"},"MaxResults":{"location":"querystring","locationName":"max-results","type":"integer"},"Namespace":{"location":"uri","locationName":"Namespace"}}},"output":{"type":"structure","members":{"GroupList":{"shape":"S9z"},"NextToken":{},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"ListIAMPolicyAssignments":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/namespaces/{Namespace}/iam-policy-assignments"},"input":{"type":"structure","required":["AwsAccountId","Namespace"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"AssignmentStatus":{},"Namespace":{"location":"uri","locationName":"Namespace"},"NextToken":{"location":"querystring","locationName":"next-token"},"MaxResults":{"location":"querystring","locationName":"max-results","type":"integer"}}},"output":{"type":"structure","members":{"IAMPolicyAssignments":{"type":"list","member":{"type":"structure","members":{"AssignmentName":{},"AssignmentStatus":{}}}},"NextToken":{},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"ListIAMPolicyAssignmentsForUser":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/namespaces/{Namespace}/users/{UserName}/iam-policy-assignments"},"input":{"type":"structure","required":["AwsAccountId","UserName","Namespace"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"UserName":{"location":"uri","locationName":"UserName"},"NextToken":{"location":"querystring","locationName":"next-token"},"MaxResults":{"location":"querystring","locationName":"max-results","type":"integer"},"Namespace":{"location":"uri","locationName":"Namespace"}}},"output":{"type":"structure","members":{"ActiveAssignments":{"type":"list","member":{"type":"structure","members":{"AssignmentName":{},"PolicyArn":{}}}},"RequestId":{},"NextToken":{},"Status":{"location":"statusCode","type":"integer"}}}},"ListIngestions":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/data-sets/{DataSetId}/ingestions"},"input":{"type":"structure","required":["DataSetId","AwsAccountId"],"members":{"DataSetId":{"location":"uri","locationName":"DataSetId"},"NextToken":{"location":"querystring","locationName":"next-token"},"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"MaxResults":{"location":"querystring","locationName":"max-results","type":"integer"}}},"output":{"type":"structure","members":{"Ingestions":{"type":"list","member":{"shape":"S7q"}},"NextToken":{},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"ListNamespaces":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/namespaces"},"input":{"type":"structure","required":["AwsAccountId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"NextToken":{"location":"querystring","locationName":"next-token"},"MaxResults":{"location":"querystring","locationName":"max-results","type":"integer"}}},"output":{"type":"structure","members":{"Namespaces":{"type":"list","member":{"shape":"S81"}},"NextToken":{},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"ListTagsForResource":{"http":{"method":"GET","requestUri":"/resources/{ResourceArn}/tags"},"input":{"type":"structure","required":["ResourceArn"],"members":{"ResourceArn":{"location":"uri","locationName":"ResourceArn"}}},"output":{"type":"structure","members":{"Tags":{"shape":"S15"},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"ListTemplateAliases":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/templates/{TemplateId}/aliases"},"input":{"type":"structure","required":["AwsAccountId","TemplateId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"TemplateId":{"location":"uri","locationName":"TemplateId"},"NextToken":{"location":"querystring","locationName":"next-token"},"MaxResults":{"location":"querystring","locationName":"max-result","type":"integer"}}},"output":{"type":"structure","members":{"TemplateAliasList":{"type":"list","member":{"shape":"S5d"}},"Status":{"location":"statusCode","type":"integer"},"RequestId":{},"NextToken":{}}}},"ListTemplateVersions":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/templates/{TemplateId}/versions"},"input":{"type":"structure","required":["AwsAccountId","TemplateId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"TemplateId":{"location":"uri","locationName":"TemplateId"},"NextToken":{"location":"querystring","locationName":"next-token"},"MaxResults":{"location":"querystring","locationName":"max-results","type":"integer"}}},"output":{"type":"structure","members":{"TemplateVersionSummaryList":{"type":"list","member":{"type":"structure","members":{"Arn":{},"VersionNumber":{"type":"long"},"CreatedTime":{"type":"timestamp"},"Status":{},"Description":{}}}},"NextToken":{},"Status":{"location":"statusCode","type":"integer"},"RequestId":{}}}},"ListTemplates":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/templates"},"input":{"type":"structure","required":["AwsAccountId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"NextToken":{"location":"querystring","locationName":"next-token"},"MaxResults":{"location":"querystring","locationName":"max-result","type":"integer"}}},"output":{"type":"structure","members":{"TemplateSummaryList":{"type":"list","member":{"type":"structure","members":{"Arn":{},"TemplateId":{},"Name":{},"LatestVersionNumber":{"type":"long"},"CreatedTime":{"type":"timestamp"},"LastUpdatedTime":{"type":"timestamp"}}}},"NextToken":{},"Status":{"location":"statusCode","type":"integer"},"RequestId":{}}}},"ListThemeAliases":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/themes/{ThemeId}/aliases"},"input":{"type":"structure","required":["AwsAccountId","ThemeId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"ThemeId":{"location":"uri","locationName":"ThemeId"},"NextToken":{"location":"querystring","locationName":"next-token"},"MaxResults":{"location":"querystring","locationName":"max-result","type":"integer"}}},"output":{"type":"structure","members":{"ThemeAliasList":{"type":"list","member":{"shape":"S5v"}},"Status":{"location":"statusCode","type":"integer"},"RequestId":{},"NextToken":{}}}},"ListThemeVersions":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/themes/{ThemeId}/versions"},"input":{"type":"structure","required":["AwsAccountId","ThemeId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"ThemeId":{"location":"uri","locationName":"ThemeId"},"NextToken":{"location":"querystring","locationName":"next-token"},"MaxResults":{"location":"querystring","locationName":"max-results","type":"integer"}}},"output":{"type":"structure","members":{"ThemeVersionSummaryList":{"type":"list","member":{"type":"structure","members":{"VersionNumber":{"type":"long"},"Arn":{},"Description":{},"CreatedTime":{"type":"timestamp"},"Status":{}}}},"NextToken":{},"Status":{"location":"statusCode","type":"integer"},"RequestId":{}}}},"ListThemes":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/themes"},"input":{"type":"structure","required":["AwsAccountId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"NextToken":{"location":"querystring","locationName":"next-token"},"MaxResults":{"location":"querystring","locationName":"max-results","type":"integer"},"Type":{"location":"querystring","locationName":"type"}}},"output":{"type":"structure","members":{"ThemeSummaryList":{"type":"list","member":{"type":"structure","members":{"Arn":{},"Name":{},"ThemeId":{},"LatestVersionNumber":{"type":"long"},"CreatedTime":{"type":"timestamp"},"LastUpdatedTime":{"type":"timestamp"}}}},"NextToken":{},"Status":{"location":"statusCode","type":"integer"},"RequestId":{}}}},"ListUserGroups":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/namespaces/{Namespace}/users/{UserName}/groups"},"input":{"type":"structure","required":["UserName","AwsAccountId","Namespace"],"members":{"UserName":{"location":"uri","locationName":"UserName"},"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"Namespace":{"location":"uri","locationName":"Namespace"},"NextToken":{"location":"querystring","locationName":"next-token"},"MaxResults":{"location":"querystring","locationName":"max-results","type":"integer"}}},"output":{"type":"structure","members":{"GroupList":{"shape":"S9z"},"NextToken":{},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"ListUsers":{"http":{"method":"GET","requestUri":"/accounts/{AwsAccountId}/namespaces/{Namespace}/users"},"input":{"type":"structure","required":["AwsAccountId","Namespace"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"NextToken":{"location":"querystring","locationName":"next-token"},"MaxResults":{"location":"querystring","locationName":"max-results","type":"integer"},"Namespace":{"location":"uri","locationName":"Namespace"}}},"output":{"type":"structure","members":{"UserList":{"type":"list","member":{"shape":"S93"}},"NextToken":{},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"RegisterUser":{"http":{"requestUri":"/accounts/{AwsAccountId}/namespaces/{Namespace}/users"},"input":{"type":"structure","required":["IdentityType","Email","UserRole","AwsAccountId","Namespace"],"members":{"IdentityType":{},"Email":{},"UserRole":{},"IamArn":{},"SessionName":{},"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"Namespace":{"location":"uri","locationName":"Namespace"},"UserName":{},"CustomPermissionsName":{}}},"output":{"type":"structure","members":{"User":{"shape":"S93"},"UserInvitationUrl":{},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"SearchDashboards":{"http":{"requestUri":"/accounts/{AwsAccountId}/search/dashboards"},"input":{"type":"structure","required":["AwsAccountId","Filters"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"Filters":{"type":"list","member":{"type":"structure","required":["Operator"],"members":{"Operator":{},"Name":{},"Value":{}}}},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"DashboardSummaryList":{"shape":"S9l"},"NextToken":{},"Status":{"location":"statusCode","type":"integer"},"RequestId":{}}}},"TagResource":{"http":{"requestUri":"/resources/{ResourceArn}/tags"},"input":{"type":"structure","required":["ResourceArn","Tags"],"members":{"ResourceArn":{"location":"uri","locationName":"ResourceArn"},"Tags":{"shape":"S15"}}},"output":{"type":"structure","members":{"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"UntagResource":{"http":{"method":"DELETE","requestUri":"/resources/{ResourceArn}/tags"},"input":{"type":"structure","required":["ResourceArn","TagKeys"],"members":{"ResourceArn":{"location":"uri","locationName":"ResourceArn"},"TagKeys":{"location":"querystring","locationName":"keys","type":"list","member":{}}}},"output":{"type":"structure","members":{"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"UpdateAccountCustomization":{"http":{"method":"PUT","requestUri":"/accounts/{AwsAccountId}/customizations"},"input":{"type":"structure","required":["AwsAccountId","AccountCustomization"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"Namespace":{"location":"querystring","locationName":"namespace"},"AccountCustomization":{"shape":"Sa"}}},"output":{"type":"structure","members":{"AwsAccountId":{},"Namespace":{},"AccountCustomization":{"shape":"Sa"},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"UpdateAccountSettings":{"http":{"method":"PUT","requestUri":"/accounts/{AwsAccountId}/settings"},"input":{"type":"structure","required":["AwsAccountId","DefaultNamespace"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"DefaultNamespace":{},"NotificationEmail":{}}},"output":{"type":"structure","members":{"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"UpdateDashboard":{"http":{"method":"PUT","requestUri":"/accounts/{AwsAccountId}/dashboards/{DashboardId}"},"input":{"type":"structure","required":["AwsAccountId","DashboardId","Name","SourceEntity"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"DashboardId":{"location":"uri","locationName":"DashboardId"},"Name":{},"SourceEntity":{"shape":"S11"},"Parameters":{"shape":"Sg"},"VersionDescription":{},"DashboardPublishOptions":{"shape":"S1a"},"ThemeArn":{}}},"output":{"type":"structure","members":{"Arn":{},"VersionArn":{},"DashboardId":{},"CreationStatus":{},"Status":{"type":"integer"},"RequestId":{}}}},"UpdateDashboardPermissions":{"http":{"method":"PUT","requestUri":"/accounts/{AwsAccountId}/dashboards/{DashboardId}/permissions"},"input":{"type":"structure","required":["AwsAccountId","DashboardId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"DashboardId":{"location":"uri","locationName":"DashboardId"},"GrantPermissions":{"shape":"Sbt"},"RevokePermissions":{"shape":"Sbt"}}},"output":{"type":"structure","members":{"DashboardArn":{},"DashboardId":{},"Permissions":{"shape":"Sx"},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"UpdateDashboardPublishedVersion":{"http":{"method":"PUT","requestUri":"/accounts/{AwsAccountId}/dashboards/{DashboardId}/versions/{VersionNumber}"},"input":{"type":"structure","required":["AwsAccountId","DashboardId","VersionNumber"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"DashboardId":{"location":"uri","locationName":"DashboardId"},"VersionNumber":{"location":"uri","locationName":"VersionNumber","type":"long"}}},"output":{"type":"structure","members":{"DashboardId":{},"DashboardArn":{},"Status":{"location":"statusCode","type":"integer"},"RequestId":{}}}},"UpdateDataSet":{"http":{"method":"PUT","requestUri":"/accounts/{AwsAccountId}/data-sets/{DataSetId}"},"input":{"type":"structure","required":["AwsAccountId","DataSetId","Name","PhysicalTableMap","ImportMode"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"DataSetId":{"location":"uri","locationName":"DataSetId"},"Name":{},"PhysicalTableMap":{"shape":"S1l"},"LogicalTableMap":{"shape":"S25"},"ImportMode":{},"ColumnGroups":{"shape":"S2w"},"RowLevelPermissionDataSet":{"shape":"S32"}}},"output":{"type":"structure","members":{"Arn":{},"DataSetId":{},"IngestionArn":{},"IngestionId":{},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"UpdateDataSetPermissions":{"http":{"requestUri":"/accounts/{AwsAccountId}/data-sets/{DataSetId}/permissions"},"input":{"type":"structure","required":["AwsAccountId","DataSetId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"DataSetId":{"location":"uri","locationName":"DataSetId"},"GrantPermissions":{"shape":"Sx"},"RevokePermissions":{"shape":"Sx"}}},"output":{"type":"structure","members":{"DataSetArn":{},"DataSetId":{},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"UpdateDataSource":{"http":{"method":"PUT","requestUri":"/accounts/{AwsAccountId}/data-sources/{DataSourceId}"},"input":{"type":"structure","required":["AwsAccountId","DataSourceId","Name"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"DataSourceId":{"location":"uri","locationName":"DataSourceId"},"Name":{},"DataSourceParameters":{"shape":"S37"},"Credentials":{"shape":"S47"},"VpcConnectionProperties":{"shape":"S4d"},"SslProperties":{"shape":"S4e"}}},"output":{"type":"structure","members":{"Arn":{},"DataSourceId":{},"UpdateStatus":{},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"UpdateDataSourcePermissions":{"http":{"requestUri":"/accounts/{AwsAccountId}/data-sources/{DataSourceId}/permissions"},"input":{"type":"structure","required":["AwsAccountId","DataSourceId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"DataSourceId":{"location":"uri","locationName":"DataSourceId"},"GrantPermissions":{"shape":"Sx"},"RevokePermissions":{"shape":"Sx"}}},"output":{"type":"structure","members":{"DataSourceArn":{},"DataSourceId":{},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"UpdateGroup":{"http":{"method":"PUT","requestUri":"/accounts/{AwsAccountId}/namespaces/{Namespace}/groups/{GroupName}"},"input":{"type":"structure","required":["GroupName","AwsAccountId","Namespace"],"members":{"GroupName":{"location":"uri","locationName":"GroupName"},"Description":{},"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"Namespace":{"location":"uri","locationName":"Namespace"}}},"output":{"type":"structure","members":{"Group":{"shape":"S4k"},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"UpdateIAMPolicyAssignment":{"http":{"method":"PUT","requestUri":"/accounts/{AwsAccountId}/namespaces/{Namespace}/iam-policy-assignments/{AssignmentName}"},"input":{"type":"structure","required":["AwsAccountId","AssignmentName","Namespace"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"AssignmentName":{"location":"uri","locationName":"AssignmentName"},"Namespace":{"location":"uri","locationName":"Namespace"},"AssignmentStatus":{},"PolicyArn":{},"Identities":{"shape":"S4s"}}},"output":{"type":"structure","members":{"AssignmentName":{},"AssignmentId":{},"PolicyArn":{},"Identities":{"shape":"S4s"},"AssignmentStatus":{},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"UpdateTemplate":{"http":{"method":"PUT","requestUri":"/accounts/{AwsAccountId}/templates/{TemplateId}"},"input":{"type":"structure","required":["AwsAccountId","TemplateId","SourceEntity"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"TemplateId":{"location":"uri","locationName":"TemplateId"},"SourceEntity":{"shape":"S55"},"VersionDescription":{},"Name":{}}},"output":{"type":"structure","members":{"TemplateId":{},"Arn":{},"VersionArn":{},"CreationStatus":{},"Status":{"location":"statusCode","type":"integer"},"RequestId":{}}}},"UpdateTemplateAlias":{"http":{"method":"PUT","requestUri":"/accounts/{AwsAccountId}/templates/{TemplateId}/aliases/{AliasName}"},"input":{"type":"structure","required":["AwsAccountId","TemplateId","AliasName","TemplateVersionNumber"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"TemplateId":{"location":"uri","locationName":"TemplateId"},"AliasName":{"location":"uri","locationName":"AliasName"},"TemplateVersionNumber":{"type":"long"}}},"output":{"type":"structure","members":{"TemplateAlias":{"shape":"S5d"},"Status":{"location":"statusCode","type":"integer"},"RequestId":{}}}},"UpdateTemplatePermissions":{"http":{"method":"PUT","requestUri":"/accounts/{AwsAccountId}/templates/{TemplateId}/permissions"},"input":{"type":"structure","required":["AwsAccountId","TemplateId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"TemplateId":{"location":"uri","locationName":"TemplateId"},"GrantPermissions":{"shape":"Sbt"},"RevokePermissions":{"shape":"Sbt"}}},"output":{"type":"structure","members":{"TemplateId":{},"TemplateArn":{},"Permissions":{"shape":"Sx"},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"UpdateTheme":{"http":{"method":"PUT","requestUri":"/accounts/{AwsAccountId}/themes/{ThemeId}"},"input":{"type":"structure","required":["AwsAccountId","ThemeId","BaseThemeId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"ThemeId":{"location":"uri","locationName":"ThemeId"},"Name":{},"BaseThemeId":{},"VersionDescription":{},"Configuration":{"shape":"S5g"}}},"output":{"type":"structure","members":{"ThemeId":{},"Arn":{},"VersionArn":{},"CreationStatus":{},"Status":{"location":"statusCode","type":"integer"},"RequestId":{}}}},"UpdateThemeAlias":{"http":{"method":"PUT","requestUri":"/accounts/{AwsAccountId}/themes/{ThemeId}/aliases/{AliasName}"},"input":{"type":"structure","required":["AwsAccountId","ThemeId","AliasName","ThemeVersionNumber"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"ThemeId":{"location":"uri","locationName":"ThemeId"},"AliasName":{"location":"uri","locationName":"AliasName"},"ThemeVersionNumber":{"type":"long"}}},"output":{"type":"structure","members":{"ThemeAlias":{"shape":"S5v"},"Status":{"location":"statusCode","type":"integer"},"RequestId":{}}}},"UpdateThemePermissions":{"http":{"method":"PUT","requestUri":"/accounts/{AwsAccountId}/themes/{ThemeId}/permissions"},"input":{"type":"structure","required":["AwsAccountId","ThemeId"],"members":{"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"ThemeId":{"location":"uri","locationName":"ThemeId"},"GrantPermissions":{"shape":"Sbt"},"RevokePermissions":{"shape":"Sbt"}}},"output":{"type":"structure","members":{"ThemeId":{},"ThemeArn":{},"Permissions":{"shape":"Sx"},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}},"UpdateUser":{"http":{"method":"PUT","requestUri":"/accounts/{AwsAccountId}/namespaces/{Namespace}/users/{UserName}"},"input":{"type":"structure","required":["UserName","AwsAccountId","Namespace","Email","Role"],"members":{"UserName":{"location":"uri","locationName":"UserName"},"AwsAccountId":{"location":"uri","locationName":"AwsAccountId"},"Namespace":{"location":"uri","locationName":"Namespace"},"Email":{},"Role":{},"CustomPermissionsName":{},"UnapplyCustomPermissions":{"type":"boolean"}}},"output":{"type":"structure","members":{"User":{"shape":"S93"},"RequestId":{},"Status":{"location":"statusCode","type":"integer"}}}}},"shapes":{"Sa":{"type":"structure","members":{"DefaultTheme":{}}},"Sg":{"type":"structure","members":{"StringParameters":{"type":"list","member":{"type":"structure","required":["Name","Values"],"members":{"Name":{},"Values":{"type":"list","member":{}}}}},"IntegerParameters":{"type":"list","member":{"type":"structure","required":["Name","Values"],"members":{"Name":{},"Values":{"type":"list","member":{"type":"long"}}}}},"DecimalParameters":{"type":"list","member":{"type":"structure","required":["Name","Values"],"members":{"Name":{},"Values":{"type":"list","member":{"type":"double"}}}}},"DateTimeParameters":{"type":"list","member":{"type":"structure","required":["Name","Values"],"members":{"Name":{},"Values":{"type":"list","member":{"type":"timestamp"}}}}}}},"Sx":{"type":"list","member":{"shape":"Sy"}},"Sy":{"type":"structure","required":["Principal","Actions"],"members":{"Principal":{},"Actions":{"type":"list","member":{}}}},"S11":{"type":"structure","members":{"SourceTemplate":{"type":"structure","required":["DataSetReferences","Arn"],"members":{"DataSetReferences":{"shape":"S13"},"Arn":{}}}}},"S13":{"type":"list","member":{"type":"structure","required":["DataSetPlaceholder","DataSetArn"],"members":{"DataSetPlaceholder":{},"DataSetArn":{}}}},"S15":{"type":"list","member":{"type":"structure","required":["Key","Value"],"members":{"Key":{},"Value":{}}}},"S1a":{"type":"structure","members":{"AdHocFilteringOption":{"type":"structure","members":{"AvailabilityStatus":{}}},"ExportToCSVOption":{"type":"structure","members":{"AvailabilityStatus":{}}},"SheetControlsOption":{"type":"structure","members":{"VisibilityState":{}}}}},"S1l":{"type":"map","key":{},"value":{"type":"structure","members":{"RelationalTable":{"type":"structure","required":["DataSourceArn","Name","InputColumns"],"members":{"DataSourceArn":{},"Schema":{},"Name":{},"InputColumns":{"shape":"S1r"}}},"CustomSql":{"type":"structure","required":["DataSourceArn","Name","SqlQuery"],"members":{"DataSourceArn":{},"Name":{},"SqlQuery":{},"Columns":{"shape":"S1r"}}},"S3Source":{"type":"structure","required":["DataSourceArn","InputColumns"],"members":{"DataSourceArn":{},"UploadSettings":{"type":"structure","members":{"Format":{},"StartFromRow":{"type":"integer"},"ContainsHeader":{"type":"boolean"},"TextQualifier":{},"Delimiter":{}}},"InputColumns":{"shape":"S1r"}}}}}},"S1r":{"type":"list","member":{"type":"structure","required":["Name","Type"],"members":{"Name":{},"Type":{}}}},"S25":{"type":"map","key":{},"value":{"type":"structure","required":["Alias","Source"],"members":{"Alias":{},"DataTransforms":{"type":"list","member":{"type":"structure","members":{"ProjectOperation":{"type":"structure","required":["ProjectedColumns"],"members":{"ProjectedColumns":{"type":"list","member":{}}}},"FilterOperation":{"type":"structure","required":["ConditionExpression"],"members":{"ConditionExpression":{}}},"CreateColumnsOperation":{"type":"structure","required":["Columns"],"members":{"Columns":{"type":"list","member":{"type":"structure","required":["ColumnName","ColumnId","Expression"],"members":{"ColumnName":{},"ColumnId":{},"Expression":{}}}}}},"RenameColumnOperation":{"type":"structure","required":["ColumnName","NewColumnName"],"members":{"ColumnName":{},"NewColumnName":{}}},"CastColumnTypeOperation":{"type":"structure","required":["ColumnName","NewColumnType"],"members":{"ColumnName":{},"NewColumnType":{},"Format":{}}},"TagColumnOperation":{"type":"structure","required":["ColumnName","Tags"],"members":{"ColumnName":{},"Tags":{"type":"list","member":{"type":"structure","members":{"ColumnGeographicRole":{}}}}}}}}},"Source":{"type":"structure","members":{"JoinInstruction":{"type":"structure","required":["LeftOperand","RightOperand","Type","OnClause"],"members":{"LeftOperand":{},"RightOperand":{},"Type":{},"OnClause":{}}},"PhysicalTableId":{}}}}}},"S2w":{"type":"list","member":{"type":"structure","members":{"GeoSpatialColumnGroup":{"type":"structure","required":["Name","CountryCode","Columns"],"members":{"Name":{},"CountryCode":{},"Columns":{"type":"list","member":{}}}}}}},"S32":{"type":"structure","required":["Arn","PermissionPolicy"],"members":{"Namespace":{},"Arn":{},"PermissionPolicy":{}}},"S37":{"type":"structure","members":{"AmazonElasticsearchParameters":{"type":"structure","required":["Domain"],"members":{"Domain":{}}},"AthenaParameters":{"type":"structure","members":{"WorkGroup":{}}},"AuroraParameters":{"type":"structure","required":["Host","Port","Database"],"members":{"Host":{},"Port":{"type":"integer"},"Database":{}}},"AuroraPostgreSqlParameters":{"type":"structure","required":["Host","Port","Database"],"members":{"Host":{},"Port":{"type":"integer"},"Database":{}}},"AwsIotAnalyticsParameters":{"type":"structure","required":["DataSetName"],"members":{"DataSetName":{}}},"JiraParameters":{"type":"structure","required":["SiteBaseUrl"],"members":{"SiteBaseUrl":{}}},"MariaDbParameters":{"type":"structure","required":["Host","Port","Database"],"members":{"Host":{},"Port":{"type":"integer"},"Database":{}}},"MySqlParameters":{"type":"structure","required":["Host","Port","Database"],"members":{"Host":{},"Port":{"type":"integer"},"Database":{}}},"PostgreSqlParameters":{"type":"structure","required":["Host","Port","Database"],"members":{"Host":{},"Port":{"type":"integer"},"Database":{}}},"PrestoParameters":{"type":"structure","required":["Host","Port","Catalog"],"members":{"Host":{},"Port":{"type":"integer"},"Catalog":{}}},"RdsParameters":{"type":"structure","required":["InstanceId","Database"],"members":{"InstanceId":{},"Database":{}}},"RedshiftParameters":{"type":"structure","required":["Database"],"members":{"Host":{},"Port":{"type":"integer"},"Database":{},"ClusterId":{}}},"S3Parameters":{"type":"structure","required":["ManifestFileLocation"],"members":{"ManifestFileLocation":{"type":"structure","required":["Bucket","Key"],"members":{"Bucket":{},"Key":{}}}}},"ServiceNowParameters":{"type":"structure","required":["SiteBaseUrl"],"members":{"SiteBaseUrl":{}}},"SnowflakeParameters":{"type":"structure","required":["Host","Database","Warehouse"],"members":{"Host":{},"Database":{},"Warehouse":{}}},"SparkParameters":{"type":"structure","required":["Host","Port"],"members":{"Host":{},"Port":{"type":"integer"}}},"SqlServerParameters":{"type":"structure","required":["Host","Port","Database"],"members":{"Host":{},"Port":{"type":"integer"},"Database":{}}},"TeradataParameters":{"type":"structure","required":["Host","Port","Database"],"members":{"Host":{},"Port":{"type":"integer"},"Database":{}}},"TwitterParameters":{"type":"structure","required":["Query","MaxRows"],"members":{"Query":{},"MaxRows":{"type":"integer"}}}}},"S47":{"type":"structure","members":{"CredentialPair":{"type":"structure","required":["Username","Password"],"members":{"Username":{},"Password":{},"AlternateDataSourceParameters":{"shape":"S4b"}}},"CopySourceArn":{}},"sensitive":true},"S4b":{"type":"list","member":{"shape":"S37"}},"S4d":{"type":"structure","required":["VpcConnectionArn"],"members":{"VpcConnectionArn":{}}},"S4e":{"type":"structure","members":{"DisableSsl":{"type":"boolean"}}},"S4k":{"type":"structure","members":{"Arn":{},"GroupName":{},"Description":{},"PrincipalId":{}}},"S4o":{"type":"structure","members":{"Arn":{},"MemberName":{}}},"S4s":{"type":"map","key":{},"value":{"type":"list","member":{}}},"S55":{"type":"structure","members":{"SourceAnalysis":{"type":"structure","required":["Arn","DataSetReferences"],"members":{"Arn":{},"DataSetReferences":{"shape":"S13"}}},"SourceTemplate":{"type":"structure","required":["Arn"],"members":{"Arn":{}}}}},"S5d":{"type":"structure","members":{"AliasName":{},"Arn":{},"TemplateVersionNumber":{"type":"long"}}},"S5g":{"type":"structure","members":{"DataColorPalette":{"type":"structure","members":{"Colors":{"shape":"S5i"},"MinMaxGradient":{"shape":"S5i"},"EmptyFillColor":{}}},"UIColorPalette":{"type":"structure","members":{"PrimaryForeground":{},"PrimaryBackground":{},"SecondaryForeground":{},"SecondaryBackground":{},"Accent":{},"AccentForeground":{},"Danger":{},"DangerForeground":{},"Warning":{},"WarningForeground":{},"Success":{},"SuccessForeground":{},"Dimension":{},"DimensionForeground":{},"Measure":{},"MeasureForeground":{}}},"Sheet":{"type":"structure","members":{"Tile":{"type":"structure","members":{"Border":{"type":"structure","members":{"Show":{"type":"boolean"}}}}},"TileLayout":{"type":"structure","members":{"Gutter":{"type":"structure","members":{"Show":{"type":"boolean"}}},"Margin":{"type":"structure","members":{"Show":{"type":"boolean"}}}}}}}}},"S5i":{"type":"list","member":{}},"S5v":{"type":"structure","members":{"Arn":{},"AliasName":{},"ThemeVersionNumber":{"type":"long"}}},"S7e":{"type":"structure","members":{"Arn":{},"DataSourceId":{},"Name":{},"Type":{},"Status":{},"CreatedTime":{"type":"timestamp"},"LastUpdatedTime":{"type":"timestamp"},"DataSourceParameters":{"shape":"S37"},"AlternateDataSourceParameters":{"shape":"S4b"},"VpcConnectionProperties":{"shape":"S4d"},"SslProperties":{"shape":"S4e"},"ErrorInfo":{"type":"structure","members":{"Type":{},"Message":{}}}}},"S7q":{"type":"structure","required":["Arn","IngestionStatus","CreatedTime"],"members":{"Arn":{},"IngestionId":{},"IngestionStatus":{},"ErrorInfo":{"type":"structure","members":{"Type":{},"Message":{}}},"RowInfo":{"type":"structure","members":{"RowsIngested":{"type":"long"},"RowsDropped":{"type":"long"}}},"QueueInfo":{"type":"structure","required":["WaitingOnIngestion","QueuedIngestion"],"members":{"WaitingOnIngestion":{},"QueuedIngestion":{}}},"CreatedTime":{"type":"timestamp"},"IngestionTimeInSeconds":{"type":"long"},"IngestionSizeInBytes":{"type":"long"},"RequestSource":{},"RequestType":{}}},"S81":{"type":"structure","members":{"Name":{},"Arn":{},"CapacityRegion":{},"CreationStatus":{},"IdentityStore":{},"NamespaceError":{"type":"structure","members":{"Type":{},"Message":{}}}}},"S93":{"type":"structure","members":{"Arn":{},"UserName":{},"Email":{},"Role":{},"IdentityType":{},"Active":{"type":"boolean"},"PrincipalId":{},"CustomPermissionsName":{}}},"S9a":{"type":"string","sensitive":true},"S9l":{"type":"list","member":{"type":"structure","members":{"Arn":{},"DashboardId":{},"Name":{},"CreatedTime":{"type":"timestamp"},"LastUpdatedTime":{"type":"timestamp"},"PublishedVersionNumber":{"type":"long"},"LastPublishedTime":{"type":"timestamp"}}}},"S9z":{"type":"list","member":{"shape":"S4k"}},"Sbt":{"type":"list","member":{"shape":"Sy"}}}}; + // Special case: last mapping's node contains only the key in explicit notation. + if (atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos); + } -/***/ }), + // Expose the resulting mapping. + if (detected) { + state.tag = _tag; + state.anchor = _anchor; + state.kind = 'mapping'; + state.result = _result; + } -/***/ 3315: -/***/ (function(module, __unusedexports, __webpack_require__) { + return detected; +} -var util = __webpack_require__(153); -var Rest = __webpack_require__(4618); -var Json = __webpack_require__(9912); -var JsonBuilder = __webpack_require__(337); -var JsonParser = __webpack_require__(9806); +function readTagProperty(state) { + var _position, + isVerbatim = false, + isNamed = false, + tagHandle, + tagName, + ch; -function populateBody(req) { - var builder = new JsonBuilder(); - var input = req.service.api.operations[req.operation].input; + ch = state.input.charCodeAt(state.position); - if (input.payload) { - var params = {}; - var payloadShape = input.members[input.payload]; - params = req.params[input.payload]; - if (params === undefined) return; + if (ch !== 0x21/* ! */) return false; - if (payloadShape.type === 'structure') { - req.httpRequest.body = builder.build(params, payloadShape); - applyContentTypeHeader(req); - } else { // non-JSON payload - req.httpRequest.body = params; - if (payloadShape.type === 'binary' || payloadShape.isStreaming) { - applyContentTypeHeader(req, true); - } - } - } else { - var body = builder.build(req.params, input); - if (body !== '{}' || req.httpRequest.method !== 'GET') { //don't send empty body for GET method - req.httpRequest.body = body; - } - applyContentTypeHeader(req); + if (state.tag !== null) { + throwError(state, 'duplication of a tag property'); } -} -function applyContentTypeHeader(req, isBinary) { - var operation = req.service.api.operations[req.operation]; - var input = operation.input; + ch = state.input.charCodeAt(++state.position); - if (!req.httpRequest.headers['Content-Type']) { - var type = isBinary ? 'binary/octet-stream' : 'application/json'; - req.httpRequest.headers['Content-Type'] = type; - } -} + if (ch === 0x3C/* < */) { + isVerbatim = true; + ch = state.input.charCodeAt(++state.position); -function buildRequest(req) { - Rest.buildRequest(req); + } else if (ch === 0x21/* ! */) { + isNamed = true; + tagHandle = '!!'; + ch = state.input.charCodeAt(++state.position); - // never send body payload on HEAD/DELETE - if (['HEAD', 'DELETE'].indexOf(req.httpRequest.method) < 0) { - populateBody(req); + } else { + tagHandle = '!'; } -} -function extractError(resp) { - Json.extractError(resp); -} - -function extractData(resp) { - Rest.extractData(resp); + _position = state.position; - var req = resp.request; - var operation = req.service.api.operations[req.operation]; - var rules = req.service.api.operations[req.operation].output || {}; - var parser; - var hasEventOutput = operation.hasEventOutput; + if (isVerbatim) { + do { ch = state.input.charCodeAt(++state.position); } + while (ch !== 0 && ch !== 0x3E/* > */); - if (rules.payload) { - var payloadMember = rules.members[rules.payload]; - var body = resp.httpResponse.body; - if (payloadMember.isEventStream) { - parser = new JsonParser(); - resp.data[payload] = util.createEventStream( - AWS.HttpClient.streamsApiVersion === 2 ? resp.httpResponse.stream : body, - parser, - payloadMember - ); - } else if (payloadMember.type === 'structure' || payloadMember.type === 'list') { - var parser = new JsonParser(); - resp.data[rules.payload] = parser.parse(body, payloadMember); - } else if (payloadMember.type === 'binary' || payloadMember.isStreaming) { - resp.data[rules.payload] = body; + if (state.position < state.length) { + tagName = state.input.slice(_position, state.position); + ch = state.input.charCodeAt(++state.position); } else { - resp.data[rules.payload] = payloadMember.toType(body); + throwError(state, 'unexpected end of the stream within a verbatim tag'); } } else { - var data = resp.data; - Json.extractData(resp); - resp.data = util.merge(data, resp.data); - } -} + while (ch !== 0 && !is_WS_OR_EOL(ch)) { -/** - * @api private - */ -module.exports = { - buildRequest: buildRequest, - extractError: extractError, - extractData: extractData -}; + if (ch === 0x21/* ! */) { + if (!isNamed) { + tagHandle = state.input.slice(_position - 1, state.position + 1); + if (!PATTERN_TAG_HANDLE.test(tagHandle)) { + throwError(state, 'named tag handle cannot contain such characters'); + } -/***/ }), + isNamed = true; + _position = state.position + 1; + } else { + throwError(state, 'tag suffix cannot contain exclamation marks'); + } + } -/***/ 3346: -/***/ (function(module, __unusedexports, __webpack_require__) { + ch = state.input.charCodeAt(++state.position); + } -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; + tagName = state.input.slice(_position, state.position); -apiLoader.services['mq'] = {}; -AWS.MQ = Service.defineService('mq', ['2017-11-27']); -Object.defineProperty(apiLoader.services['mq'], '2017-11-27', { - get: function get() { - var model = __webpack_require__(4074); - model.paginators = __webpack_require__(7571).pagination; - return model; - }, - enumerable: true, - configurable: true -}); + if (PATTERN_FLOW_INDICATORS.test(tagName)) { + throwError(state, 'tag suffix cannot contain flow indicator characters'); + } + } -module.exports = AWS.MQ; + if (tagName && !PATTERN_TAG_URI.test(tagName)) { + throwError(state, 'tag name cannot contain such characters: ' + tagName); + } + try { + tagName = decodeURIComponent(tagName); + } catch (err) { + throwError(state, 'tag name is malformed: ' + tagName); + } -/***/ }), + if (isVerbatim) { + state.tag = tagName; -/***/ 3370: -/***/ (function(module) { + } else if (_hasOwnProperty.call(state.tagMap, tagHandle)) { + state.tag = state.tagMap[tagHandle] + tagName; -module.exports = {"version":"2.0","metadata":{"apiVersion":"2017-11-01","endpointPrefix":"eks","jsonVersion":"1.1","protocol":"rest-json","serviceAbbreviation":"Amazon EKS","serviceFullName":"Amazon Elastic Kubernetes Service","serviceId":"EKS","signatureVersion":"v4","signingName":"eks","uid":"eks-2017-11-01"},"operations":{"CreateCluster":{"http":{"requestUri":"/clusters"},"input":{"type":"structure","required":["name","roleArn","resourcesVpcConfig"],"members":{"name":{},"version":{},"roleArn":{},"resourcesVpcConfig":{"shape":"S4"},"logging":{"shape":"S7"},"clientRequestToken":{"idempotencyToken":true},"tags":{"shape":"Sc"},"encryptionConfig":{"shape":"Sf"}}},"output":{"type":"structure","members":{"cluster":{"shape":"Sj"}}}},"CreateFargateProfile":{"http":{"requestUri":"/clusters/{name}/fargate-profiles"},"input":{"type":"structure","required":["fargateProfileName","clusterName","podExecutionRoleArn"],"members":{"fargateProfileName":{},"clusterName":{"location":"uri","locationName":"name"},"podExecutionRoleArn":{},"subnets":{"shape":"S5"},"selectors":{"shape":"Ss"},"clientRequestToken":{"idempotencyToken":true},"tags":{"shape":"Sc"}}},"output":{"type":"structure","members":{"fargateProfile":{"shape":"Sw"}}}},"CreateNodegroup":{"http":{"requestUri":"/clusters/{name}/node-groups"},"input":{"type":"structure","required":["clusterName","nodegroupName","subnets","nodeRole"],"members":{"clusterName":{"location":"uri","locationName":"name"},"nodegroupName":{},"scalingConfig":{"shape":"Sz"},"diskSize":{"type":"integer"},"subnets":{"shape":"S5"},"instanceTypes":{"shape":"S5"},"amiType":{},"remoteAccess":{"shape":"S13"},"nodeRole":{},"labels":{"shape":"S14"},"tags":{"shape":"Sc"},"clientRequestToken":{"idempotencyToken":true},"version":{},"releaseVersion":{}}},"output":{"type":"structure","members":{"nodegroup":{"shape":"S18"}}}},"DeleteCluster":{"http":{"method":"DELETE","requestUri":"/clusters/{name}"},"input":{"type":"structure","required":["name"],"members":{"name":{"location":"uri","locationName":"name"}}},"output":{"type":"structure","members":{"cluster":{"shape":"Sj"}}}},"DeleteFargateProfile":{"http":{"method":"DELETE","requestUri":"/clusters/{name}/fargate-profiles/{fargateProfileName}"},"input":{"type":"structure","required":["clusterName","fargateProfileName"],"members":{"clusterName":{"location":"uri","locationName":"name"},"fargateProfileName":{"location":"uri","locationName":"fargateProfileName"}}},"output":{"type":"structure","members":{"fargateProfile":{"shape":"Sw"}}}},"DeleteNodegroup":{"http":{"method":"DELETE","requestUri":"/clusters/{name}/node-groups/{nodegroupName}"},"input":{"type":"structure","required":["clusterName","nodegroupName"],"members":{"clusterName":{"location":"uri","locationName":"name"},"nodegroupName":{"location":"uri","locationName":"nodegroupName"}}},"output":{"type":"structure","members":{"nodegroup":{"shape":"S18"}}}},"DescribeCluster":{"http":{"method":"GET","requestUri":"/clusters/{name}"},"input":{"type":"structure","required":["name"],"members":{"name":{"location":"uri","locationName":"name"}}},"output":{"type":"structure","members":{"cluster":{"shape":"Sj"}}}},"DescribeFargateProfile":{"http":{"method":"GET","requestUri":"/clusters/{name}/fargate-profiles/{fargateProfileName}"},"input":{"type":"structure","required":["clusterName","fargateProfileName"],"members":{"clusterName":{"location":"uri","locationName":"name"},"fargateProfileName":{"location":"uri","locationName":"fargateProfileName"}}},"output":{"type":"structure","members":{"fargateProfile":{"shape":"Sw"}}}},"DescribeNodegroup":{"http":{"method":"GET","requestUri":"/clusters/{name}/node-groups/{nodegroupName}"},"input":{"type":"structure","required":["clusterName","nodegroupName"],"members":{"clusterName":{"location":"uri","locationName":"name"},"nodegroupName":{"location":"uri","locationName":"nodegroupName"}}},"output":{"type":"structure","members":{"nodegroup":{"shape":"S18"}}}},"DescribeUpdate":{"http":{"method":"GET","requestUri":"/clusters/{name}/updates/{updateId}"},"input":{"type":"structure","required":["name","updateId"],"members":{"name":{"location":"uri","locationName":"name"},"updateId":{"location":"uri","locationName":"updateId"},"nodegroupName":{"location":"querystring","locationName":"nodegroupName"}}},"output":{"type":"structure","members":{"update":{"shape":"S1v"}}}},"ListClusters":{"http":{"method":"GET","requestUri":"/clusters"},"input":{"type":"structure","members":{"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"nextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"clusters":{"shape":"S5"},"nextToken":{}}}},"ListFargateProfiles":{"http":{"method":"GET","requestUri":"/clusters/{name}/fargate-profiles"},"input":{"type":"structure","required":["clusterName"],"members":{"clusterName":{"location":"uri","locationName":"name"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"nextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"fargateProfileNames":{"shape":"S5"},"nextToken":{}}}},"ListNodegroups":{"http":{"method":"GET","requestUri":"/clusters/{name}/node-groups"},"input":{"type":"structure","required":["clusterName"],"members":{"clusterName":{"location":"uri","locationName":"name"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"nextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"nodegroups":{"shape":"S5"},"nextToken":{}}}},"ListTagsForResource":{"http":{"method":"GET","requestUri":"/tags/{resourceArn}"},"input":{"type":"structure","required":["resourceArn"],"members":{"resourceArn":{"location":"uri","locationName":"resourceArn"}}},"output":{"type":"structure","members":{"tags":{"shape":"Sc"}}}},"ListUpdates":{"http":{"method":"GET","requestUri":"/clusters/{name}/updates"},"input":{"type":"structure","required":["name"],"members":{"name":{"location":"uri","locationName":"name"},"nodegroupName":{"location":"querystring","locationName":"nodegroupName"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"updateIds":{"shape":"S5"},"nextToken":{}}}},"TagResource":{"http":{"requestUri":"/tags/{resourceArn}"},"input":{"type":"structure","required":["resourceArn","tags"],"members":{"resourceArn":{"location":"uri","locationName":"resourceArn"},"tags":{"shape":"Sc"}}},"output":{"type":"structure","members":{}}},"UntagResource":{"http":{"method":"DELETE","requestUri":"/tags/{resourceArn}"},"input":{"type":"structure","required":["resourceArn","tagKeys"],"members":{"resourceArn":{"location":"uri","locationName":"resourceArn"},"tagKeys":{"location":"querystring","locationName":"tagKeys","type":"list","member":{}}}},"output":{"type":"structure","members":{}}},"UpdateClusterConfig":{"http":{"requestUri":"/clusters/{name}/update-config"},"input":{"type":"structure","required":["name"],"members":{"name":{"location":"uri","locationName":"name"},"resourcesVpcConfig":{"shape":"S4"},"logging":{"shape":"S7"},"clientRequestToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"update":{"shape":"S1v"}}}},"UpdateClusterVersion":{"http":{"requestUri":"/clusters/{name}/updates"},"input":{"type":"structure","required":["name","version"],"members":{"name":{"location":"uri","locationName":"name"},"version":{},"clientRequestToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"update":{"shape":"S1v"}}}},"UpdateNodegroupConfig":{"http":{"requestUri":"/clusters/{name}/node-groups/{nodegroupName}/update-config"},"input":{"type":"structure","required":["clusterName","nodegroupName"],"members":{"clusterName":{"location":"uri","locationName":"name"},"nodegroupName":{"location":"uri","locationName":"nodegroupName"},"labels":{"type":"structure","members":{"addOrUpdateLabels":{"shape":"S14"},"removeLabels":{"type":"list","member":{}}}},"scalingConfig":{"shape":"Sz"},"clientRequestToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"update":{"shape":"S1v"}}}},"UpdateNodegroupVersion":{"http":{"requestUri":"/clusters/{name}/node-groups/{nodegroupName}/update-version"},"input":{"type":"structure","required":["clusterName","nodegroupName"],"members":{"clusterName":{"location":"uri","locationName":"name"},"nodegroupName":{"location":"uri","locationName":"nodegroupName"},"version":{},"releaseVersion":{},"force":{"type":"boolean"},"clientRequestToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"update":{"shape":"S1v"}}}}},"shapes":{"S4":{"type":"structure","members":{"subnetIds":{"shape":"S5"},"securityGroupIds":{"shape":"S5"},"endpointPublicAccess":{"type":"boolean"},"endpointPrivateAccess":{"type":"boolean"},"publicAccessCidrs":{"shape":"S5"}}},"S5":{"type":"list","member":{}},"S7":{"type":"structure","members":{"clusterLogging":{"type":"list","member":{"type":"structure","members":{"types":{"type":"list","member":{}},"enabled":{"type":"boolean"}}}}}},"Sc":{"type":"map","key":{},"value":{}},"Sf":{"type":"list","member":{"type":"structure","members":{"resources":{"shape":"S5"},"provider":{"type":"structure","members":{"keyArn":{}}}}}},"Sj":{"type":"structure","members":{"name":{},"arn":{},"createdAt":{"type":"timestamp"},"version":{},"endpoint":{},"roleArn":{},"resourcesVpcConfig":{"type":"structure","members":{"subnetIds":{"shape":"S5"},"securityGroupIds":{"shape":"S5"},"clusterSecurityGroupId":{},"vpcId":{},"endpointPublicAccess":{"type":"boolean"},"endpointPrivateAccess":{"type":"boolean"},"publicAccessCidrs":{"shape":"S5"}}},"logging":{"shape":"S7"},"identity":{"type":"structure","members":{"oidc":{"type":"structure","members":{"issuer":{}}}}},"status":{},"certificateAuthority":{"type":"structure","members":{"data":{}}},"clientRequestToken":{},"platformVersion":{},"tags":{"shape":"Sc"},"encryptionConfig":{"shape":"Sf"}}},"Ss":{"type":"list","member":{"type":"structure","members":{"namespace":{},"labels":{"type":"map","key":{},"value":{}}}}},"Sw":{"type":"structure","members":{"fargateProfileName":{},"fargateProfileArn":{},"clusterName":{},"createdAt":{"type":"timestamp"},"podExecutionRoleArn":{},"subnets":{"shape":"S5"},"selectors":{"shape":"Ss"},"status":{},"tags":{"shape":"Sc"}}},"Sz":{"type":"structure","members":{"minSize":{"type":"integer"},"maxSize":{"type":"integer"},"desiredSize":{"type":"integer"}}},"S13":{"type":"structure","members":{"ec2SshKey":{},"sourceSecurityGroups":{"shape":"S5"}}},"S14":{"type":"map","key":{},"value":{}},"S18":{"type":"structure","members":{"nodegroupName":{},"nodegroupArn":{},"clusterName":{},"version":{},"releaseVersion":{},"createdAt":{"type":"timestamp"},"modifiedAt":{"type":"timestamp"},"status":{},"scalingConfig":{"shape":"Sz"},"instanceTypes":{"shape":"S5"},"subnets":{"shape":"S5"},"remoteAccess":{"shape":"S13"},"amiType":{},"nodeRole":{},"labels":{"shape":"S14"},"resources":{"type":"structure","members":{"autoScalingGroups":{"type":"list","member":{"type":"structure","members":{"name":{}}}},"remoteAccessSecurityGroup":{}}},"diskSize":{"type":"integer"},"health":{"type":"structure","members":{"issues":{"type":"list","member":{"type":"structure","members":{"code":{},"message":{},"resourceIds":{"shape":"S5"}}}}}},"tags":{"shape":"Sc"}}},"S1v":{"type":"structure","members":{"id":{},"status":{},"type":{},"params":{"type":"list","member":{"type":"structure","members":{"type":{},"value":{}}}},"createdAt":{"type":"timestamp"},"errors":{"type":"list","member":{"type":"structure","members":{"errorCode":{},"errorMessage":{},"resourceIds":{"shape":"S5"}}}}}}}}; + } else if (tagHandle === '!') { + state.tag = '!' + tagName; -/***/ }), + } else if (tagHandle === '!!') { + state.tag = 'tag:yaml.org,2002:' + tagName; -/***/ 3387: -/***/ (function(module) { + } else { + throwError(state, 'undeclared tag handle "' + tagHandle + '"'); + } -module.exports = {"version":"2.0","metadata":{"apiVersion":"2017-05-13","endpointPrefix":"runtime.sagemaker","jsonVersion":"1.1","protocol":"rest-json","serviceFullName":"Amazon SageMaker Runtime","serviceId":"SageMaker Runtime","signatureVersion":"v4","signingName":"sagemaker","uid":"runtime.sagemaker-2017-05-13"},"operations":{"InvokeEndpoint":{"http":{"requestUri":"/endpoints/{EndpointName}/invocations"},"input":{"type":"structure","required":["EndpointName","Body"],"members":{"EndpointName":{"location":"uri","locationName":"EndpointName"},"Body":{"shape":"S3"},"ContentType":{"location":"header","locationName":"Content-Type"},"Accept":{"location":"header","locationName":"Accept"},"CustomAttributes":{"shape":"S5","location":"header","locationName":"X-Amzn-SageMaker-Custom-Attributes"},"TargetModel":{"location":"header","locationName":"X-Amzn-SageMaker-Target-Model"},"TargetVariant":{"location":"header","locationName":"X-Amzn-SageMaker-Target-Variant"}},"payload":"Body"},"output":{"type":"structure","required":["Body"],"members":{"Body":{"shape":"S3"},"ContentType":{"location":"header","locationName":"Content-Type"},"InvokedProductionVariant":{"location":"header","locationName":"x-Amzn-Invoked-Production-Variant"},"CustomAttributes":{"shape":"S5","location":"header","locationName":"X-Amzn-SageMaker-Custom-Attributes"}},"payload":"Body"}}},"shapes":{"S3":{"type":"blob","sensitive":true},"S5":{"type":"string","sensitive":true}}}; + return true; +} -/***/ }), +function readAnchorProperty(state) { + var _position, + ch; -/***/ 3393: -/***/ (function(module) { + ch = state.input.charCodeAt(state.position); -module.exports = {"version":"2.0","metadata":{"apiVersion":"2013-01-01","endpointPrefix":"cloudsearch","protocol":"query","serviceFullName":"Amazon CloudSearch","serviceId":"CloudSearch","signatureVersion":"v4","uid":"cloudsearch-2013-01-01","xmlNamespace":"http://cloudsearch.amazonaws.com/doc/2013-01-01/"},"operations":{"BuildSuggesters":{"input":{"type":"structure","required":["DomainName"],"members":{"DomainName":{}}},"output":{"resultWrapper":"BuildSuggestersResult","type":"structure","members":{"FieldNames":{"shape":"S4"}}}},"CreateDomain":{"input":{"type":"structure","required":["DomainName"],"members":{"DomainName":{}}},"output":{"resultWrapper":"CreateDomainResult","type":"structure","members":{"DomainStatus":{"shape":"S8"}}}},"DefineAnalysisScheme":{"input":{"type":"structure","required":["DomainName","AnalysisScheme"],"members":{"DomainName":{},"AnalysisScheme":{"shape":"Sl"}}},"output":{"resultWrapper":"DefineAnalysisSchemeResult","type":"structure","required":["AnalysisScheme"],"members":{"AnalysisScheme":{"shape":"Ss"}}}},"DefineExpression":{"input":{"type":"structure","required":["DomainName","Expression"],"members":{"DomainName":{},"Expression":{"shape":"Sy"}}},"output":{"resultWrapper":"DefineExpressionResult","type":"structure","required":["Expression"],"members":{"Expression":{"shape":"S11"}}}},"DefineIndexField":{"input":{"type":"structure","required":["DomainName","IndexField"],"members":{"DomainName":{},"IndexField":{"shape":"S13"}}},"output":{"resultWrapper":"DefineIndexFieldResult","type":"structure","required":["IndexField"],"members":{"IndexField":{"shape":"S1n"}}}},"DefineSuggester":{"input":{"type":"structure","required":["DomainName","Suggester"],"members":{"DomainName":{},"Suggester":{"shape":"S1p"}}},"output":{"resultWrapper":"DefineSuggesterResult","type":"structure","required":["Suggester"],"members":{"Suggester":{"shape":"S1t"}}}},"DeleteAnalysisScheme":{"input":{"type":"structure","required":["DomainName","AnalysisSchemeName"],"members":{"DomainName":{},"AnalysisSchemeName":{}}},"output":{"resultWrapper":"DeleteAnalysisSchemeResult","type":"structure","required":["AnalysisScheme"],"members":{"AnalysisScheme":{"shape":"Ss"}}}},"DeleteDomain":{"input":{"type":"structure","required":["DomainName"],"members":{"DomainName":{}}},"output":{"resultWrapper":"DeleteDomainResult","type":"structure","members":{"DomainStatus":{"shape":"S8"}}}},"DeleteExpression":{"input":{"type":"structure","required":["DomainName","ExpressionName"],"members":{"DomainName":{},"ExpressionName":{}}},"output":{"resultWrapper":"DeleteExpressionResult","type":"structure","required":["Expression"],"members":{"Expression":{"shape":"S11"}}}},"DeleteIndexField":{"input":{"type":"structure","required":["DomainName","IndexFieldName"],"members":{"DomainName":{},"IndexFieldName":{}}},"output":{"resultWrapper":"DeleteIndexFieldResult","type":"structure","required":["IndexField"],"members":{"IndexField":{"shape":"S1n"}}}},"DeleteSuggester":{"input":{"type":"structure","required":["DomainName","SuggesterName"],"members":{"DomainName":{},"SuggesterName":{}}},"output":{"resultWrapper":"DeleteSuggesterResult","type":"structure","required":["Suggester"],"members":{"Suggester":{"shape":"S1t"}}}},"DescribeAnalysisSchemes":{"input":{"type":"structure","required":["DomainName"],"members":{"DomainName":{},"AnalysisSchemeNames":{"shape":"S25"},"Deployed":{"type":"boolean"}}},"output":{"resultWrapper":"DescribeAnalysisSchemesResult","type":"structure","required":["AnalysisSchemes"],"members":{"AnalysisSchemes":{"type":"list","member":{"shape":"Ss"}}}}},"DescribeAvailabilityOptions":{"input":{"type":"structure","required":["DomainName"],"members":{"DomainName":{},"Deployed":{"type":"boolean"}}},"output":{"resultWrapper":"DescribeAvailabilityOptionsResult","type":"structure","members":{"AvailabilityOptions":{"shape":"S2a"}}}},"DescribeDomainEndpointOptions":{"input":{"type":"structure","required":["DomainName"],"members":{"DomainName":{},"Deployed":{"type":"boolean"}}},"output":{"resultWrapper":"DescribeDomainEndpointOptionsResult","type":"structure","members":{"DomainEndpointOptions":{"shape":"S2e"}}}},"DescribeDomains":{"input":{"type":"structure","members":{"DomainNames":{"type":"list","member":{}}}},"output":{"resultWrapper":"DescribeDomainsResult","type":"structure","required":["DomainStatusList"],"members":{"DomainStatusList":{"type":"list","member":{"shape":"S8"}}}}},"DescribeExpressions":{"input":{"type":"structure","required":["DomainName"],"members":{"DomainName":{},"ExpressionNames":{"shape":"S25"},"Deployed":{"type":"boolean"}}},"output":{"resultWrapper":"DescribeExpressionsResult","type":"structure","required":["Expressions"],"members":{"Expressions":{"type":"list","member":{"shape":"S11"}}}}},"DescribeIndexFields":{"input":{"type":"structure","required":["DomainName"],"members":{"DomainName":{},"FieldNames":{"type":"list","member":{}},"Deployed":{"type":"boolean"}}},"output":{"resultWrapper":"DescribeIndexFieldsResult","type":"structure","required":["IndexFields"],"members":{"IndexFields":{"type":"list","member":{"shape":"S1n"}}}}},"DescribeScalingParameters":{"input":{"type":"structure","required":["DomainName"],"members":{"DomainName":{}}},"output":{"resultWrapper":"DescribeScalingParametersResult","type":"structure","required":["ScalingParameters"],"members":{"ScalingParameters":{"shape":"S2u"}}}},"DescribeServiceAccessPolicies":{"input":{"type":"structure","required":["DomainName"],"members":{"DomainName":{},"Deployed":{"type":"boolean"}}},"output":{"resultWrapper":"DescribeServiceAccessPoliciesResult","type":"structure","required":["AccessPolicies"],"members":{"AccessPolicies":{"shape":"S2z"}}}},"DescribeSuggesters":{"input":{"type":"structure","required":["DomainName"],"members":{"DomainName":{},"SuggesterNames":{"shape":"S25"},"Deployed":{"type":"boolean"}}},"output":{"resultWrapper":"DescribeSuggestersResult","type":"structure","required":["Suggesters"],"members":{"Suggesters":{"type":"list","member":{"shape":"S1t"}}}}},"IndexDocuments":{"input":{"type":"structure","required":["DomainName"],"members":{"DomainName":{}}},"output":{"resultWrapper":"IndexDocumentsResult","type":"structure","members":{"FieldNames":{"shape":"S4"}}}},"ListDomainNames":{"output":{"resultWrapper":"ListDomainNamesResult","type":"structure","members":{"DomainNames":{"type":"map","key":{},"value":{}}}}},"UpdateAvailabilityOptions":{"input":{"type":"structure","required":["DomainName","MultiAZ"],"members":{"DomainName":{},"MultiAZ":{"type":"boolean"}}},"output":{"resultWrapper":"UpdateAvailabilityOptionsResult","type":"structure","members":{"AvailabilityOptions":{"shape":"S2a"}}}},"UpdateDomainEndpointOptions":{"input":{"type":"structure","required":["DomainName","DomainEndpointOptions"],"members":{"DomainName":{},"DomainEndpointOptions":{"shape":"S2f"}}},"output":{"resultWrapper":"UpdateDomainEndpointOptionsResult","type":"structure","members":{"DomainEndpointOptions":{"shape":"S2e"}}}},"UpdateScalingParameters":{"input":{"type":"structure","required":["DomainName","ScalingParameters"],"members":{"DomainName":{},"ScalingParameters":{"shape":"S2v"}}},"output":{"resultWrapper":"UpdateScalingParametersResult","type":"structure","required":["ScalingParameters"],"members":{"ScalingParameters":{"shape":"S2u"}}}},"UpdateServiceAccessPolicies":{"input":{"type":"structure","required":["DomainName","AccessPolicies"],"members":{"DomainName":{},"AccessPolicies":{}}},"output":{"resultWrapper":"UpdateServiceAccessPoliciesResult","type":"structure","required":["AccessPolicies"],"members":{"AccessPolicies":{"shape":"S2z"}}}}},"shapes":{"S4":{"type":"list","member":{}},"S8":{"type":"structure","required":["DomainId","DomainName","RequiresIndexDocuments"],"members":{"DomainId":{},"DomainName":{},"ARN":{},"Created":{"type":"boolean"},"Deleted":{"type":"boolean"},"DocService":{"shape":"Sc"},"SearchService":{"shape":"Sc"},"RequiresIndexDocuments":{"type":"boolean"},"Processing":{"type":"boolean"},"SearchInstanceType":{},"SearchPartitionCount":{"type":"integer"},"SearchInstanceCount":{"type":"integer"},"Limits":{"type":"structure","required":["MaximumReplicationCount","MaximumPartitionCount"],"members":{"MaximumReplicationCount":{"type":"integer"},"MaximumPartitionCount":{"type":"integer"}}}}},"Sc":{"type":"structure","members":{"Endpoint":{}}},"Sl":{"type":"structure","required":["AnalysisSchemeName","AnalysisSchemeLanguage"],"members":{"AnalysisSchemeName":{},"AnalysisSchemeLanguage":{},"AnalysisOptions":{"type":"structure","members":{"Synonyms":{},"Stopwords":{},"StemmingDictionary":{},"JapaneseTokenizationDictionary":{},"AlgorithmicStemming":{}}}}},"Ss":{"type":"structure","required":["Options","Status"],"members":{"Options":{"shape":"Sl"},"Status":{"shape":"St"}}},"St":{"type":"structure","required":["CreationDate","UpdateDate","State"],"members":{"CreationDate":{"type":"timestamp"},"UpdateDate":{"type":"timestamp"},"UpdateVersion":{"type":"integer"},"State":{},"PendingDeletion":{"type":"boolean"}}},"Sy":{"type":"structure","required":["ExpressionName","ExpressionValue"],"members":{"ExpressionName":{},"ExpressionValue":{}}},"S11":{"type":"structure","required":["Options","Status"],"members":{"Options":{"shape":"Sy"},"Status":{"shape":"St"}}},"S13":{"type":"structure","required":["IndexFieldName","IndexFieldType"],"members":{"IndexFieldName":{},"IndexFieldType":{},"IntOptions":{"type":"structure","members":{"DefaultValue":{"type":"long"},"SourceField":{},"FacetEnabled":{"type":"boolean"},"SearchEnabled":{"type":"boolean"},"ReturnEnabled":{"type":"boolean"},"SortEnabled":{"type":"boolean"}}},"DoubleOptions":{"type":"structure","members":{"DefaultValue":{"type":"double"},"SourceField":{},"FacetEnabled":{"type":"boolean"},"SearchEnabled":{"type":"boolean"},"ReturnEnabled":{"type":"boolean"},"SortEnabled":{"type":"boolean"}}},"LiteralOptions":{"type":"structure","members":{"DefaultValue":{},"SourceField":{},"FacetEnabled":{"type":"boolean"},"SearchEnabled":{"type":"boolean"},"ReturnEnabled":{"type":"boolean"},"SortEnabled":{"type":"boolean"}}},"TextOptions":{"type":"structure","members":{"DefaultValue":{},"SourceField":{},"ReturnEnabled":{"type":"boolean"},"SortEnabled":{"type":"boolean"},"HighlightEnabled":{"type":"boolean"},"AnalysisScheme":{}}},"DateOptions":{"type":"structure","members":{"DefaultValue":{},"SourceField":{},"FacetEnabled":{"type":"boolean"},"SearchEnabled":{"type":"boolean"},"ReturnEnabled":{"type":"boolean"},"SortEnabled":{"type":"boolean"}}},"LatLonOptions":{"type":"structure","members":{"DefaultValue":{},"SourceField":{},"FacetEnabled":{"type":"boolean"},"SearchEnabled":{"type":"boolean"},"ReturnEnabled":{"type":"boolean"},"SortEnabled":{"type":"boolean"}}},"IntArrayOptions":{"type":"structure","members":{"DefaultValue":{"type":"long"},"SourceFields":{},"FacetEnabled":{"type":"boolean"},"SearchEnabled":{"type":"boolean"},"ReturnEnabled":{"type":"boolean"}}},"DoubleArrayOptions":{"type":"structure","members":{"DefaultValue":{"type":"double"},"SourceFields":{},"FacetEnabled":{"type":"boolean"},"SearchEnabled":{"type":"boolean"},"ReturnEnabled":{"type":"boolean"}}},"LiteralArrayOptions":{"type":"structure","members":{"DefaultValue":{},"SourceFields":{},"FacetEnabled":{"type":"boolean"},"SearchEnabled":{"type":"boolean"},"ReturnEnabled":{"type":"boolean"}}},"TextArrayOptions":{"type":"structure","members":{"DefaultValue":{},"SourceFields":{},"ReturnEnabled":{"type":"boolean"},"HighlightEnabled":{"type":"boolean"},"AnalysisScheme":{}}},"DateArrayOptions":{"type":"structure","members":{"DefaultValue":{},"SourceFields":{},"FacetEnabled":{"type":"boolean"},"SearchEnabled":{"type":"boolean"},"ReturnEnabled":{"type":"boolean"}}}}},"S1n":{"type":"structure","required":["Options","Status"],"members":{"Options":{"shape":"S13"},"Status":{"shape":"St"}}},"S1p":{"type":"structure","required":["SuggesterName","DocumentSuggesterOptions"],"members":{"SuggesterName":{},"DocumentSuggesterOptions":{"type":"structure","required":["SourceField"],"members":{"SourceField":{},"FuzzyMatching":{},"SortExpression":{}}}}},"S1t":{"type":"structure","required":["Options","Status"],"members":{"Options":{"shape":"S1p"},"Status":{"shape":"St"}}},"S25":{"type":"list","member":{}},"S2a":{"type":"structure","required":["Options","Status"],"members":{"Options":{"type":"boolean"},"Status":{"shape":"St"}}},"S2e":{"type":"structure","required":["Options","Status"],"members":{"Options":{"shape":"S2f"},"Status":{"shape":"St"}}},"S2f":{"type":"structure","members":{"EnforceHTTPS":{"type":"boolean"},"TLSSecurityPolicy":{}}},"S2u":{"type":"structure","required":["Options","Status"],"members":{"Options":{"shape":"S2v"},"Status":{"shape":"St"}}},"S2v":{"type":"structure","members":{"DesiredInstanceType":{},"DesiredReplicationCount":{"type":"integer"},"DesiredPartitionCount":{"type":"integer"}}},"S2z":{"type":"structure","required":["Options","Status"],"members":{"Options":{},"Status":{"shape":"St"}}}}}; + if (ch !== 0x26/* & */) return false; -/***/ }), - -/***/ 3396: -/***/ (function(module) { - -module.exports = {"pagination":{}}; - -/***/ }), - -/***/ 3405: -/***/ (function(module) { + if (state.anchor !== null) { + throwError(state, 'duplication of an anchor property'); + } -module.exports = {"pagination":{"ListAliases":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListGroupMembers":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListGroups":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListMailboxPermissions":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListOrganizations":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListResourceDelegates":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListResources":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListUsers":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"}}}; + ch = state.input.charCodeAt(++state.position); + _position = state.position; -/***/ }), + while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) { + ch = state.input.charCodeAt(++state.position); + } -/***/ 3410: -/***/ (function(module) { + if (state.position === _position) { + throwError(state, 'name of an anchor node must contain at least one character'); + } -module.exports = {"pagination":{"ListBundles":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"ListProjects":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"}}}; + state.anchor = state.input.slice(_position, state.position); + return true; +} -/***/ }), +function readAlias(state) { + var _position, alias, + ch; -/***/ 3413: -/***/ (function(module) { + ch = state.input.charCodeAt(state.position); -module.exports = {"pagination":{"ListDevices":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListDomains":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListFleets":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListWebsiteAuthorizationProviders":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListWebsiteCertificateAuthorities":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"}}}; + if (ch !== 0x2A/* * */) return false; -/***/ }), + ch = state.input.charCodeAt(++state.position); + _position = state.position; -/***/ 3421: -/***/ (function(module) { + while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) { + ch = state.input.charCodeAt(++state.position); + } -module.exports = {"pagination":{}}; + if (state.position === _position) { + throwError(state, 'name of an alias node must contain at least one character'); + } -/***/ }), + alias = state.input.slice(_position, state.position); -/***/ 3458: -/***/ (function(module, __unusedexports, __webpack_require__) { + if (!_hasOwnProperty.call(state.anchorMap, alias)) { + throwError(state, 'unidentified alias "' + alias + '"'); + } -// Generated by CoffeeScript 1.12.7 -(function() { - var XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLElement, XMLProcessingInstruction, XMLRaw, XMLStreamWriter, XMLText, XMLWriterBase, - extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, - hasProp = {}.hasOwnProperty; + state.result = state.anchorMap[alias]; + skipSeparationSpace(state, true, -1); + return true; +} - XMLDeclaration = __webpack_require__(7738); +function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) { + var allowBlockStyles, + allowBlockScalars, + allowBlockCollections, + indentStatus = 1, // 1: this>parent, 0: this=parent, -1: this parentIndent) { + indentStatus = 1; + } else if (state.lineIndent === parentIndent) { + indentStatus = 0; + } else if (state.lineIndent < parentIndent) { + indentStatus = -1; + } + } + } - XMLText = __webpack_require__(9708); + if (indentStatus === 1) { + while (readTagProperty(state) || readAnchorProperty(state)) { + if (skipSeparationSpace(state, true, -1)) { + atNewLine = true; + allowBlockCollections = allowBlockStyles; - XMLProcessingInstruction = __webpack_require__(2491); + if (state.lineIndent > parentIndent) { + indentStatus = 1; + } else if (state.lineIndent === parentIndent) { + indentStatus = 0; + } else if (state.lineIndent < parentIndent) { + indentStatus = -1; + } + } else { + allowBlockCollections = false; + } + } + } - XMLDTDAttList = __webpack_require__(3801); + if (allowBlockCollections) { + allowBlockCollections = atNewLine || allowCompact; + } - XMLDTDElement = __webpack_require__(9463); + if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) { + if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) { + flowIndent = parentIndent; + } else { + flowIndent = parentIndent + 1; + } - XMLDTDEntity = __webpack_require__(7661); + blockIndent = state.position - state.lineStart; - XMLDTDNotation = __webpack_require__(9019); + if (indentStatus === 1) { + if (allowBlockCollections && + (readBlockSequence(state, blockIndent) || + readBlockMapping(state, blockIndent, flowIndent)) || + readFlowCollection(state, flowIndent)) { + hasContent = true; + } else { + if ((allowBlockScalars && readBlockScalar(state, flowIndent)) || + readSingleQuotedScalar(state, flowIndent) || + readDoubleQuotedScalar(state, flowIndent)) { + hasContent = true; - XMLWriterBase = __webpack_require__(9423); + } else if (readAlias(state)) { + hasContent = true; - module.exports = XMLStreamWriter = (function(superClass) { - extend(XMLStreamWriter, superClass); + if (state.tag !== null || state.anchor !== null) { + throwError(state, 'alias node should not have any properties'); + } - function XMLStreamWriter(stream, options) { - XMLStreamWriter.__super__.constructor.call(this, options); - this.stream = stream; - } + } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) { + hasContent = true; - XMLStreamWriter.prototype.document = function(doc) { - var child, i, j, len, len1, ref, ref1, results; - ref = doc.children; - for (i = 0, len = ref.length; i < len; i++) { - child = ref[i]; - child.isLastRootNode = false; - } - doc.children[doc.children.length - 1].isLastRootNode = true; - ref1 = doc.children; - results = []; - for (j = 0, len1 = ref1.length; j < len1; j++) { - child = ref1[j]; - switch (false) { - case !(child instanceof XMLDeclaration): - results.push(this.declaration(child)); - break; - case !(child instanceof XMLDocType): - results.push(this.docType(child)); - break; - case !(child instanceof XMLComment): - results.push(this.comment(child)); - break; - case !(child instanceof XMLProcessingInstruction): - results.push(this.processingInstruction(child)); - break; - default: - results.push(this.element(child)); - } - } - return results; - }; - - XMLStreamWriter.prototype.attribute = function(att) { - return this.stream.write(' ' + att.name + '="' + att.value + '"'); - }; - - XMLStreamWriter.prototype.cdata = function(node, level) { - return this.stream.write(this.space(level) + '' + this.endline(node)); - }; - - XMLStreamWriter.prototype.comment = function(node, level) { - return this.stream.write(this.space(level) + '' + this.endline(node)); - }; - - XMLStreamWriter.prototype.declaration = function(node, level) { - this.stream.write(this.space(level)); - this.stream.write(''); - return this.stream.write(this.endline(node)); - }; - - XMLStreamWriter.prototype.docType = function(node, level) { - var child, i, len, ref; - level || (level = 0); - this.stream.write(this.space(level)); - this.stream.write(' 0) { - this.stream.write(' ['); - this.stream.write(this.endline(node)); - ref = node.children; - for (i = 0, len = ref.length; i < len; i++) { - child = ref[i]; - switch (false) { - case !(child instanceof XMLDTDAttList): - this.dtdAttList(child, level + 1); - break; - case !(child instanceof XMLDTDElement): - this.dtdElement(child, level + 1); - break; - case !(child instanceof XMLDTDEntity): - this.dtdEntity(child, level + 1); - break; - case !(child instanceof XMLDTDNotation): - this.dtdNotation(child, level + 1); - break; - case !(child instanceof XMLCData): - this.cdata(child, level + 1); - break; - case !(child instanceof XMLComment): - this.comment(child, level + 1); - break; - case !(child instanceof XMLProcessingInstruction): - this.processingInstruction(child, level + 1); - break; - default: - throw new Error("Unknown DTD node type: " + child.constructor.name); + if (state.tag === null) { + state.tag = '?'; } } - this.stream.write(']'); - } - this.stream.write(this.spacebeforeslash + '>'); - return this.stream.write(this.endline(node)); - }; - XMLStreamWriter.prototype.element = function(node, level) { - var att, child, i, len, name, ref, ref1, space; - level || (level = 0); - space = this.space(level); - this.stream.write(space + '<' + node.name); - ref = node.attributes; - for (name in ref) { - if (!hasProp.call(ref, name)) continue; - att = ref[name]; - this.attribute(att); - } - if (node.children.length === 0 || node.children.every(function(e) { - return e.value === ''; - })) { - if (this.allowEmpty) { - this.stream.write('>'); - } else { - this.stream.write(this.spacebeforeslash + '/>'); - } - } else if (this.pretty && node.children.length === 1 && (node.children[0].value != null)) { - this.stream.write('>'); - this.stream.write(node.children[0].value); - this.stream.write(''); - } else { - this.stream.write('>' + this.newline); - ref1 = node.children; - for (i = 0, len = ref1.length; i < len; i++) { - child = ref1[i]; - switch (false) { - case !(child instanceof XMLCData): - this.cdata(child, level + 1); - break; - case !(child instanceof XMLComment): - this.comment(child, level + 1); - break; - case !(child instanceof XMLElement): - this.element(child, level + 1); - break; - case !(child instanceof XMLRaw): - this.raw(child, level + 1); - break; - case !(child instanceof XMLText): - this.text(child, level + 1); - break; - case !(child instanceof XMLProcessingInstruction): - this.processingInstruction(child, level + 1); - break; - default: - throw new Error("Unknown XML node type: " + child.constructor.name); - } + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; } - this.stream.write(space + ''); } - return this.stream.write(this.endline(node)); - }; + } else if (indentStatus === 0) { + // Special case: block sequences are allowed to have same indentation level as the parent. + // http://www.yaml.org/spec/1.2/spec.html#id2799784 + hasContent = allowBlockCollections && readBlockSequence(state, blockIndent); + } + } - XMLStreamWriter.prototype.processingInstruction = function(node, level) { - this.stream.write(this.space(level) + '' + this.endline(node)); - }; + if (state.tag === null) { + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } - XMLStreamWriter.prototype.raw = function(node, level) { - return this.stream.write(this.space(level) + node.value + this.endline(node)); - }; + } else if (state.tag === '?') { + // Implicit resolving is not allowed for non-scalar types, and '?' + // non-specific tag is only automatically assigned to plain scalars. + // + // We only need to check kind conformity in case user explicitly assigns '?' + // tag, for example like this: "! [0]" + // + if (state.result !== null && state.kind !== 'scalar') { + throwError(state, 'unacceptable node kind for ! tag; it should be "scalar", not "' + state.kind + '"'); + } - XMLStreamWriter.prototype.text = function(node, level) { - return this.stream.write(this.space(level) + node.value + this.endline(node)); - }; + for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) { + type = state.implicitTypes[typeIndex]; - XMLStreamWriter.prototype.dtdAttList = function(node, level) { - this.stream.write(this.space(level) + '' + this.endline(node)); - }; - - XMLStreamWriter.prototype.dtdElement = function(node, level) { - this.stream.write(this.space(level) + '' + this.endline(node)); - }; + } + } else if (state.tag !== '!') { + if (_hasOwnProperty.call(state.typeMap[state.kind || 'fallback'], state.tag)) { + type = state.typeMap[state.kind || 'fallback'][state.tag]; + } else { + // looking for multi type + type = null; + typeList = state.typeMap.multi[state.kind || 'fallback']; - XMLStreamWriter.prototype.dtdEntity = function(node, level) { - this.stream.write(this.space(level) + '' + this.endline(node)); - }; + } - XMLStreamWriter.prototype.dtdNotation = function(node, level) { - this.stream.write(this.space(level) + '' + this.endline(node)); - }; + if (!type) { + throwError(state, 'unknown tag !<' + state.tag + '>'); + } - XMLStreamWriter.prototype.endline = function(node) { - if (!node.isLastRootNode) { - return this.newline; - } else { - return ''; + if (state.result !== null && type.kind !== state.kind) { + throwError(state, 'unacceptable node kind for !<' + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"'); + } + + if (!type.resolve(state.result, state.tag)) { // `state.result` updated in resolver if matched + throwError(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag'); + } else { + state.result = type.construct(state.result, state.tag); + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; } - }; + } + } - return XMLStreamWriter; + if (state.listener !== null) { + state.listener('close', state); + } + return state.tag !== null || state.anchor !== null || hasContent; +} - })(XMLWriterBase); +function readDocument(state) { + var documentStart = state.position, + _position, + directiveName, + directiveArgs, + hasDirectives = false, + ch; -}).call(this); + state.version = null; + state.checkLineBreaks = state.legacy; + state.tagMap = Object.create(null); + state.anchorMap = Object.create(null); + while ((ch = state.input.charCodeAt(state.position)) !== 0) { + skipSeparationSpace(state, true, -1); -/***/ }), + ch = state.input.charCodeAt(state.position); -/***/ 3494: -/***/ (function(module) { + if (state.lineIndent > 0 || ch !== 0x25/* % */) { + break; + } -module.exports = {"pagination":{"DescribeEndpoints":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults","result_key":"Endpoints"},"ListJobs":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults","result_key":"Jobs"},"ListPresets":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults","result_key":"Presets"},"ListJobTemplates":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults","result_key":"JobTemplates"},"ListQueues":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults","result_key":"Queues"}}}; + hasDirectives = true; + ch = state.input.charCodeAt(++state.position); + _position = state.position; -/***/ }), + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + ch = state.input.charCodeAt(++state.position); + } -/***/ 3501: -/***/ (function(module) { + directiveName = state.input.slice(_position, state.position); + directiveArgs = []; -module.exports = {"version":2,"waiters":{"TableExists":{"delay":20,"operation":"DescribeTable","maxAttempts":25,"acceptors":[{"expected":"ACTIVE","matcher":"path","state":"success","argument":"Table.TableStatus"},{"expected":"ResourceNotFoundException","matcher":"error","state":"retry"}]},"TableNotExists":{"delay":20,"operation":"DescribeTable","maxAttempts":25,"acceptors":[{"expected":"ResourceNotFoundException","matcher":"error","state":"success"}]}}}; + if (directiveName.length < 1) { + throwError(state, 'directive name must not be less than one character in length'); + } -/***/ }), + while (ch !== 0) { + while (is_WHITE_SPACE(ch)) { + ch = state.input.charCodeAt(++state.position); + } -/***/ 3503: -/***/ (function(module, __unusedexports, __webpack_require__) { + if (ch === 0x23/* # */) { + do { ch = state.input.charCodeAt(++state.position); } + while (ch !== 0 && !is_EOL(ch)); + break; + } -var AWS = __webpack_require__(395); -var Api = __webpack_require__(7788); -var regionConfig = __webpack_require__(3546); + if (is_EOL(ch)) break; -var inherit = AWS.util.inherit; -var clientCount = 0; + _position = state.position; -/** - * The service class representing an AWS service. - * - * @class_abstract This class is an abstract class. - * - * @!attribute apiVersions - * @return [Array] the list of API versions supported by this service. - * @readonly - */ -AWS.Service = inherit({ - /** - * Create a new service object with a configuration object - * - * @param config [map] a map of configuration options - */ - constructor: function Service(config) { - if (!this.loadServiceClass) { - throw AWS.util.error(new Error(), - 'Service must be constructed with `new\' operator'); - } - var ServiceClass = this.loadServiceClass(config || {}); - if (ServiceClass) { - var originalConfig = AWS.util.copy(config); - var svc = new ServiceClass(config); - Object.defineProperty(svc, '_originalConfig', { - get: function() { return originalConfig; }, - enumerable: false, - configurable: true - }); - svc._clientId = ++clientCount; - return svc; - } - this.initialize(config); - }, + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + ch = state.input.charCodeAt(++state.position); + } - /** - * @api private - */ - initialize: function initialize(config) { - var svcConfig = AWS.config[this.serviceIdentifier]; - this.config = new AWS.Config(AWS.config); - if (svcConfig) this.config.update(svcConfig, true); - if (config) this.config.update(config, true); - - this.validateService(); - if (!this.config.endpoint) regionConfig.configureEndpoint(this); - - this.config.endpoint = this.endpointFromTemplate(this.config.endpoint); - this.setEndpoint(this.config.endpoint); - //enable attaching listeners to service client - AWS.SequentialExecutor.call(this); - AWS.Service.addDefaultMonitoringListeners(this); - if ((this.config.clientSideMonitoring || AWS.Service._clientSideMonitoring) && this.publisher) { - var publisher = this.publisher; - this.addNamedListener('PUBLISH_API_CALL', 'apiCall', function PUBLISH_API_CALL(event) { - process.nextTick(function() {publisher.eventHandler(event);}); - }); - this.addNamedListener('PUBLISH_API_ATTEMPT', 'apiCallAttempt', function PUBLISH_API_ATTEMPT(event) { - process.nextTick(function() {publisher.eventHandler(event);}); - }); + directiveArgs.push(state.input.slice(_position, state.position)); } - }, - /** - * @api private - */ - validateService: function validateService() { - }, + if (ch !== 0) readLineBreak(state); - /** - * @api private - */ - loadServiceClass: function loadServiceClass(serviceConfig) { - var config = serviceConfig; - if (!AWS.util.isEmpty(this.api)) { - return null; - } else if (config.apiConfig) { - return AWS.Service.defineServiceApi(this.constructor, config.apiConfig); - } else if (!this.constructor.services) { - return null; + if (_hasOwnProperty.call(directiveHandlers, directiveName)) { + directiveHandlers[directiveName](state, directiveName, directiveArgs); } else { - config = new AWS.Config(AWS.config); - config.update(serviceConfig, true); - var version = config.apiVersions[this.constructor.serviceIdentifier]; - version = version || config.apiVersion; - return this.getLatestServiceClass(version); + throwWarning(state, 'unknown document directive "' + directiveName + '"'); } - }, + } - /** - * @api private - */ - getLatestServiceClass: function getLatestServiceClass(version) { - version = this.getLatestServiceVersion(version); - if (this.constructor.services[version] === null) { - AWS.Service.defineServiceApi(this.constructor, version); - } + skipSeparationSpace(state, true, -1); - return this.constructor.services[version]; - }, + if (state.lineIndent === 0 && + state.input.charCodeAt(state.position) === 0x2D/* - */ && + state.input.charCodeAt(state.position + 1) === 0x2D/* - */ && + state.input.charCodeAt(state.position + 2) === 0x2D/* - */) { + state.position += 3; + skipSeparationSpace(state, true, -1); - /** - * @api private - */ - getLatestServiceVersion: function getLatestServiceVersion(version) { - if (!this.constructor.services || this.constructor.services.length === 0) { - throw new Error('No services defined on ' + - this.constructor.serviceIdentifier); - } + } else if (hasDirectives) { + throwError(state, 'directives end mark is expected'); + } - if (!version) { - version = 'latest'; - } else if (AWS.util.isType(version, Date)) { - version = AWS.util.date.iso8601(version).split('T')[0]; - } + composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true); + skipSeparationSpace(state, true, -1); - if (Object.hasOwnProperty(this.constructor.services, version)) { - return version; - } + if (state.checkLineBreaks && + PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) { + throwWarning(state, 'non-ASCII line breaks are interpreted as content'); + } - var keys = Object.keys(this.constructor.services).sort(); - var selectedVersion = null; - for (var i = keys.length - 1; i >= 0; i--) { - // versions that end in "*" are not available on disk and can be - // skipped, so do not choose these as selectedVersions - if (keys[i][keys[i].length - 1] !== '*') { - selectedVersion = keys[i]; - } - if (keys[i].substr(0, 10) <= version) { - return selectedVersion; - } + state.documents.push(state.result); + + if (state.position === state.lineStart && testDocumentSeparator(state)) { + + if (state.input.charCodeAt(state.position) === 0x2E/* . */) { + state.position += 3; + skipSeparationSpace(state, true, -1); } + return; + } - throw new Error('Could not find ' + this.constructor.serviceIdentifier + - ' API to satisfy version constraint `' + version + '\''); - }, + if (state.position < (state.length - 1)) { + throwError(state, 'end of the stream or a document separator is expected'); + } else { + return; + } +} - /** - * @api private - */ - api: {}, - /** - * @api private - */ - defaultRetryCount: 3, +function loadDocuments(input, options) { + input = String(input); + options = options || {}; - /** - * @api private - */ - customizeRequests: function customizeRequests(callback) { - if (!callback) { - this.customRequestHandler = null; - } else if (typeof callback === 'function') { - this.customRequestHandler = callback; - } else { - throw new Error('Invalid callback type \'' + typeof callback + '\' provided in customizeRequests'); - } - }, + if (input.length !== 0) { - /** - * Calls an operation on a service with the given input parameters. - * - * @param operation [String] the name of the operation to call on the service. - * @param params [map] a map of input options for the operation - * @callback callback function(err, data) - * If a callback is supplied, it is called when a response is returned - * from the service. - * @param err [Error] the error object returned from the request. - * Set to `null` if the request is successful. - * @param data [Object] the de-serialized data returned from - * the request. Set to `null` if a request error occurs. - */ - makeRequest: function makeRequest(operation, params, callback) { - if (typeof params === 'function') { - callback = params; - params = null; - } - - params = params || {}; - if (this.config.params) { // copy only toplevel bound params - var rules = this.api.operations[operation]; - if (rules) { - params = AWS.util.copy(params); - AWS.util.each(this.config.params, function(key, value) { - if (rules.input.members[key]) { - if (params[key] === undefined || params[key] === null) { - params[key] = value; - } - } - }); - } + // Add tailing `\n` if not exists + if (input.charCodeAt(input.length - 1) !== 0x0A/* LF */ && + input.charCodeAt(input.length - 1) !== 0x0D/* CR */) { + input += '\n'; } - var request = new AWS.Request(this, operation, params); - this.addAllRequestListeners(request); - this.attachMonitoringEmitter(request); - if (callback) request.send(callback); - return request; - }, - - /** - * Calls an operation on a service with the given input parameters, without - * any authentication data. This method is useful for "public" API operations. - * - * @param operation [String] the name of the operation to call on the service. - * @param params [map] a map of input options for the operation - * @callback callback function(err, data) - * If a callback is supplied, it is called when a response is returned - * from the service. - * @param err [Error] the error object returned from the request. - * Set to `null` if the request is successful. - * @param data [Object] the de-serialized data returned from - * the request. Set to `null` if a request error occurs. - */ - makeUnauthenticatedRequest: function makeUnauthenticatedRequest(operation, params, callback) { - if (typeof params === 'function') { - callback = params; - params = {}; + // Strip BOM + if (input.charCodeAt(0) === 0xFEFF) { + input = input.slice(1); } + } - var request = this.makeRequest(operation, params).toUnauthenticated(); - return callback ? request.send(callback) : request; - }, + var state = new State(input, options); - /** - * Waits for a given state - * - * @param state [String] the state on the service to wait for - * @param params [map] a map of parameters to pass with each request - * @option params $waiter [map] a map of configuration options for the waiter - * @option params $waiter.delay [Number] The number of seconds to wait between - * requests - * @option params $waiter.maxAttempts [Number] The maximum number of requests - * to send while waiting - * @callback callback function(err, data) - * If a callback is supplied, it is called when a response is returned - * from the service. - * @param err [Error] the error object returned from the request. - * Set to `null` if the request is successful. - * @param data [Object] the de-serialized data returned from - * the request. Set to `null` if a request error occurs. - */ - waitFor: function waitFor(state, params, callback) { - var waiter = new AWS.ResourceWaiter(this, state); - return waiter.wait(params, callback); - }, + var nullpos = input.indexOf('\0'); - /** - * @api private - */ - addAllRequestListeners: function addAllRequestListeners(request) { - var list = [AWS.events, AWS.EventListeners.Core, this.serviceInterface(), - AWS.EventListeners.CorePost]; - for (var i = 0; i < list.length; i++) { - if (list[i]) request.addListeners(list[i]); - } + if (nullpos !== -1) { + state.position = nullpos; + throwError(state, 'null byte is not allowed in input'); + } - // disable parameter validation - if (!this.config.paramValidation) { - request.removeListener('validate', - AWS.EventListeners.Core.VALIDATE_PARAMETERS); - } + // Use 0 as string terminator. That significantly simplifies bounds check. + state.input += '\0'; - if (this.config.logger) { // add logging events - request.addListeners(AWS.EventListeners.Logger); - } + while (state.input.charCodeAt(state.position) === 0x20/* Space */) { + state.lineIndent += 1; + state.position += 1; + } - this.setupRequestListeners(request); - // call prototype's customRequestHandler - if (typeof this.constructor.prototype.customRequestHandler === 'function') { - this.constructor.prototype.customRequestHandler(request); - } - // call instance's customRequestHandler - if (Object.prototype.hasOwnProperty.call(this, 'customRequestHandler') && typeof this.customRequestHandler === 'function') { - this.customRequestHandler(request); - } - }, + while (state.position < (state.length - 1)) { + readDocument(state); + } - /** - * Event recording metrics for a whole API call. - * @returns {object} a subset of api call metrics - * @api private - */ - apiCallEvent: function apiCallEvent(request) { - var api = request.service.api.operations[request.operation]; - var monitoringEvent = { - Type: 'ApiCall', - Api: api ? api.name : request.operation, - Version: 1, - Service: request.service.api.serviceId || request.service.api.endpointPrefix, - Region: request.httpRequest.region, - MaxRetriesExceeded: 0, - UserAgent: request.httpRequest.getUserAgent(), - }; - var response = request.response; - if (response.httpResponse.statusCode) { - monitoringEvent.FinalHttpStatusCode = response.httpResponse.statusCode; - } - if (response.error) { - var error = response.error; - var statusCode = response.httpResponse.statusCode; - if (statusCode > 299) { - if (error.code) monitoringEvent.FinalAwsException = error.code; - if (error.message) monitoringEvent.FinalAwsExceptionMessage = error.message; - } else { - if (error.code || error.name) monitoringEvent.FinalSdkException = error.code || error.name; - if (error.message) monitoringEvent.FinalSdkExceptionMessage = error.message; - } - } - return monitoringEvent; - }, + return state.documents; +} - /** - * Event recording metrics for an API call attempt. - * @returns {object} a subset of api call attempt metrics - * @api private - */ - apiAttemptEvent: function apiAttemptEvent(request) { - var api = request.service.api.operations[request.operation]; - var monitoringEvent = { - Type: 'ApiCallAttempt', - Api: api ? api.name : request.operation, - Version: 1, - Service: request.service.api.serviceId || request.service.api.endpointPrefix, - Fqdn: request.httpRequest.endpoint.hostname, - UserAgent: request.httpRequest.getUserAgent(), - }; - var response = request.response; - if (response.httpResponse.statusCode) { - monitoringEvent.HttpStatusCode = response.httpResponse.statusCode; - } - if ( - !request._unAuthenticated && - request.service.config.credentials && - request.service.config.credentials.accessKeyId - ) { - monitoringEvent.AccessKey = request.service.config.credentials.accessKeyId; - } - if (!response.httpResponse.headers) return monitoringEvent; - if (request.httpRequest.headers['x-amz-security-token']) { - monitoringEvent.SessionToken = request.httpRequest.headers['x-amz-security-token']; - } - if (response.httpResponse.headers['x-amzn-requestid']) { - monitoringEvent.XAmznRequestId = response.httpResponse.headers['x-amzn-requestid']; - } - if (response.httpResponse.headers['x-amz-request-id']) { - monitoringEvent.XAmzRequestId = response.httpResponse.headers['x-amz-request-id']; - } - if (response.httpResponse.headers['x-amz-id-2']) { - monitoringEvent.XAmzId2 = response.httpResponse.headers['x-amz-id-2']; - } - return monitoringEvent; - }, - /** - * Add metrics of failed request. - * @api private - */ - attemptFailEvent: function attemptFailEvent(request) { - var monitoringEvent = this.apiAttemptEvent(request); - var response = request.response; - var error = response.error; - if (response.httpResponse.statusCode > 299 ) { - if (error.code) monitoringEvent.AwsException = error.code; - if (error.message) monitoringEvent.AwsExceptionMessage = error.message; - } else { - if (error.code || error.name) monitoringEvent.SdkException = error.code || error.name; - if (error.message) monitoringEvent.SdkExceptionMessage = error.message; - } - return monitoringEvent; - }, +function loadAll(input, iterator, options) { + if (iterator !== null && typeof iterator === 'object' && typeof options === 'undefined') { + options = iterator; + iterator = null; + } - /** - * Attach listeners to request object to fetch metrics of each request - * and emit data object through \'ApiCall\' and \'ApiCallAttempt\' events. - * @api private - */ - attachMonitoringEmitter: function attachMonitoringEmitter(request) { - var attemptTimestamp; //timestamp marking the beginning of a request attempt - var attemptStartRealTime; //Start time of request attempt. Used to calculating attemptLatency - var attemptLatency; //latency from request sent out to http response reaching SDK - var callStartRealTime; //Start time of API call. Used to calculating API call latency - var attemptCount = 0; //request.retryCount is not reliable here - var region; //region cache region for each attempt since it can be updated in plase (e.g. s3) - var callTimestamp; //timestamp when the request is created - var self = this; - var addToHead = true; - - request.on('validate', function () { - callStartRealTime = AWS.util.realClock.now(); - callTimestamp = Date.now(); - }, addToHead); - request.on('sign', function () { - attemptStartRealTime = AWS.util.realClock.now(); - attemptTimestamp = Date.now(); - region = request.httpRequest.region; - attemptCount++; - }, addToHead); - request.on('validateResponse', function() { - attemptLatency = Math.round(AWS.util.realClock.now() - attemptStartRealTime); - }); - request.addNamedListener('API_CALL_ATTEMPT', 'success', function API_CALL_ATTEMPT() { - var apiAttemptEvent = self.apiAttemptEvent(request); - apiAttemptEvent.Timestamp = attemptTimestamp; - apiAttemptEvent.AttemptLatency = attemptLatency >= 0 ? attemptLatency : 0; - apiAttemptEvent.Region = region; - self.emit('apiCallAttempt', [apiAttemptEvent]); - }); - request.addNamedListener('API_CALL_ATTEMPT_RETRY', 'retry', function API_CALL_ATTEMPT_RETRY() { - var apiAttemptEvent = self.attemptFailEvent(request); - apiAttemptEvent.Timestamp = attemptTimestamp; - //attemptLatency may not be available if fail before response - attemptLatency = attemptLatency || - Math.round(AWS.util.realClock.now() - attemptStartRealTime); - apiAttemptEvent.AttemptLatency = attemptLatency >= 0 ? attemptLatency : 0; - apiAttemptEvent.Region = region; - self.emit('apiCallAttempt', [apiAttemptEvent]); - }); - request.addNamedListener('API_CALL', 'complete', function API_CALL() { - var apiCallEvent = self.apiCallEvent(request); - apiCallEvent.AttemptCount = attemptCount; - if (apiCallEvent.AttemptCount <= 0) return; - apiCallEvent.Timestamp = callTimestamp; - var latency = Math.round(AWS.util.realClock.now() - callStartRealTime); - apiCallEvent.Latency = latency >= 0 ? latency : 0; - var response = request.response; - if ( - response.error && - response.error.retryable && - typeof response.retryCount === 'number' && - typeof response.maxRetries === 'number' && - (response.retryCount >= response.maxRetries) - ) { - apiCallEvent.MaxRetriesExceeded = 1; - } - self.emit('apiCall', [apiCallEvent]); - }); - }, + var documents = loadDocuments(input, options); - /** - * Override this method to setup any custom request listeners for each - * new request to the service. - * - * @method_abstract This is an abstract method. - */ - setupRequestListeners: function setupRequestListeners(request) { - }, + if (typeof iterator !== 'function') { + return documents; + } - /** - * Gets the signer class for a given request - * @api private - */ - getSignerClass: function getSignerClass(request) { - var version; - // get operation authtype if present - var operation = null; - var authtype = ''; - if (request) { - var operations = request.service.api.operations || {}; - operation = operations[request.operation] || null; - authtype = operation ? operation.authtype : ''; - } - if (this.config.signatureVersion) { - version = this.config.signatureVersion; - } else if (authtype === 'v4' || authtype === 'v4-unsigned-body') { - version = 'v4'; - } else { - version = this.api.signatureVersion; - } - return AWS.Signers.RequestSigner.getVersion(version); - }, + for (var index = 0, length = documents.length; index < length; index += 1) { + iterator(documents[index]); + } +} - /** - * @api private - */ - serviceInterface: function serviceInterface() { - switch (this.api.protocol) { - case 'ec2': return AWS.EventListeners.Query; - case 'query': return AWS.EventListeners.Query; - case 'json': return AWS.EventListeners.Json; - case 'rest-json': return AWS.EventListeners.RestJson; - case 'rest-xml': return AWS.EventListeners.RestXml; - } - if (this.api.protocol) { - throw new Error('Invalid service `protocol\' ' + - this.api.protocol + ' in API config'); - } - }, - /** - * @api private - */ - successfulResponse: function successfulResponse(resp) { - return resp.httpResponse.statusCode < 300; - }, +function load(input, options) { + var documents = loadDocuments(input, options); - /** - * How many times a failed request should be retried before giving up. - * the defaultRetryCount can be overriden by service classes. - * - * @api private - */ - numRetries: function numRetries() { - if (this.config.maxRetries !== undefined) { - return this.config.maxRetries; - } else { - return this.defaultRetryCount; - } - }, + if (documents.length === 0) { + /*eslint-disable no-undefined*/ + return undefined; + } else if (documents.length === 1) { + return documents[0]; + } + throw new YAMLException('expected a single document in the stream, but found more'); +} - /** - * @api private - */ - retryDelays: function retryDelays(retryCount, err) { - return AWS.util.calculateRetryDelay(retryCount, this.config.retryDelayOptions, err); - }, - /** - * @api private - */ - retryableError: function retryableError(error) { - if (this.timeoutError(error)) return true; - if (this.networkingError(error)) return true; - if (this.expiredCredentialsError(error)) return true; - if (this.throttledError(error)) return true; - if (error.statusCode >= 500) return true; - return false; - }, +module.exports.loadAll = loadAll; +module.exports.load = load; - /** - * @api private - */ - networkingError: function networkingError(error) { - return error.code === 'NetworkingError'; - }, - /** - * @api private - */ - timeoutError: function timeoutError(error) { - return error.code === 'TimeoutError'; - }, +/***/ }), - /** - * @api private - */ - expiredCredentialsError: function expiredCredentialsError(error) { - // TODO : this only handles *one* of the expired credential codes - return (error.code === 'ExpiredTokenException'); - }, +/***/ 2046: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - /** - * @api private - */ - clockSkewError: function clockSkewError(error) { - switch (error.code) { - case 'RequestTimeTooSkewed': - case 'RequestExpired': - case 'InvalidSignatureException': - case 'SignatureDoesNotMatch': - case 'AuthFailure': - case 'RequestInTheFuture': - return true; - default: return false; - } - }, +"use strict"; - /** - * @api private - */ - getSkewCorrectedDate: function getSkewCorrectedDate() { - return new Date(Date.now() + this.config.systemClockOffset); - }, - /** - * @api private - */ - applyClockOffset: function applyClockOffset(newServerTime) { - if (newServerTime) { - this.config.systemClockOffset = newServerTime - Date.now(); - } - }, +/*eslint-disable max-len*/ - /** - * @api private - */ - isClockSkewed: function isClockSkewed(newServerTime) { - if (newServerTime) { - return Math.abs(this.getSkewCorrectedDate().getTime() - newServerTime) >= 300000; - } - }, +var YAMLException = __nccwpck_require__(1248); +var Type = __nccwpck_require__(9557); - /** - * @api private - */ - throttledError: function throttledError(error) { - // this logic varies between services - if (error.statusCode === 429) return true; - switch (error.code) { - case 'ProvisionedThroughputExceededException': - case 'Throttling': - case 'ThrottlingException': - case 'RequestLimitExceeded': - case 'RequestThrottled': - case 'RequestThrottledException': - case 'TooManyRequestsException': - case 'TransactionInProgressException': //dynamodb - case 'EC2ThrottledException': - return true; - default: - return false; - } - }, - /** - * @api private - */ - endpointFromTemplate: function endpointFromTemplate(endpoint) { - if (typeof endpoint !== 'string') return endpoint; - - var e = endpoint; - e = e.replace(/\{service\}/g, this.api.endpointPrefix); - e = e.replace(/\{region\}/g, this.config.region); - e = e.replace(/\{scheme\}/g, this.config.sslEnabled ? 'https' : 'http'); - return e; - }, +function compileList(schema, name) { + var result = []; - /** - * @api private - */ - setEndpoint: function setEndpoint(endpoint) { - this.endpoint = new AWS.Endpoint(endpoint, this.config); - }, + schema[name].forEach(function (currentType) { + var newIndex = result.length; - /** - * @api private - */ - paginationConfig: function paginationConfig(operation, throwException) { - var paginator = this.api.operations[operation].paginator; - if (!paginator) { - if (throwException) { - var e = new Error(); - throw AWS.util.error(e, 'No pagination configuration for ' + operation); + result.forEach(function (previousType, previousIndex) { + if (previousType.tag === currentType.tag && + previousType.kind === currentType.kind && + previousType.multi === currentType.multi) { + + newIndex = previousIndex; } - return null; - } + }); - return paginator; - } -}); + result[newIndex] = currentType; + }); -AWS.util.update(AWS.Service, { + return result; +} - /** - * Adds one method for each operation described in the api configuration - * - * @api private - */ - defineMethods: function defineMethods(svc) { - AWS.util.each(svc.prototype.api.operations, function iterator(method) { - if (svc.prototype[method]) return; - var operation = svc.prototype.api.operations[method]; - if (operation.authtype === 'none') { - svc.prototype[method] = function (params, callback) { - return this.makeUnauthenticatedRequest(method, params, callback); - }; - } else { - svc.prototype[method] = function (params, callback) { - return this.makeRequest(method, params, callback); - }; - } - }); - }, - - /** - * Defines a new Service class using a service identifier and list of versions - * including an optional set of features (functions) to apply to the class - * prototype. - * - * @param serviceIdentifier [String] the identifier for the service - * @param versions [Array] a list of versions that work with this - * service - * @param features [Object] an object to attach to the prototype - * @return [Class] the service class defined by this function. - */ - defineService: function defineService(serviceIdentifier, versions, features) { - AWS.Service._serviceMap[serviceIdentifier] = true; - if (!Array.isArray(versions)) { - features = versions; - versions = []; - } - - var svc = inherit(AWS.Service, features || {}); - - if (typeof serviceIdentifier === 'string') { - AWS.Service.addVersions(svc, versions); - - var identifier = svc.serviceIdentifier || serviceIdentifier; - svc.serviceIdentifier = identifier; - } else { // defineService called with an API - svc.prototype.api = serviceIdentifier; - AWS.Service.defineMethods(svc); - } - AWS.SequentialExecutor.call(this.prototype); - //util.clientSideMonitoring is only available in node - if (!this.prototype.publisher && AWS.util.clientSideMonitoring) { - var Publisher = AWS.util.clientSideMonitoring.Publisher; - var configProvider = AWS.util.clientSideMonitoring.configProvider; - var publisherConfig = configProvider(); - this.prototype.publisher = new Publisher(publisherConfig); - if (publisherConfig.enabled) { - //if csm is enabled in environment, SDK should send all metrics - AWS.Service._clientSideMonitoring = true; - } - } - AWS.SequentialExecutor.call(svc.prototype); - AWS.Service.addDefaultMonitoringListeners(svc.prototype); - return svc; - }, - - /** - * @api private - */ - addVersions: function addVersions(svc, versions) { - if (!Array.isArray(versions)) versions = [versions]; - - svc.services = svc.services || {}; - for (var i = 0; i < versions.length; i++) { - if (svc.services[versions[i]] === undefined) { - svc.services[versions[i]] = null; - } - } - svc.apiVersions = Object.keys(svc.services).sort(); - }, - - /** - * @api private - */ - defineServiceApi: function defineServiceApi(superclass, version, apiConfig) { - var svc = inherit(superclass, { - serviceIdentifier: superclass.serviceIdentifier - }); - - function setApi(api) { - if (api.isApi) { - svc.prototype.api = api; - } else { - svc.prototype.api = new Api(api, { - serviceIdentifier: superclass.serviceIdentifier - }); - } - } - - if (typeof version === 'string') { - if (apiConfig) { - setApi(apiConfig); - } else { - try { - setApi(AWS.apiLoader(superclass.serviceIdentifier, version)); - } catch (err) { - throw AWS.util.error(err, { - message: 'Could not find API configuration ' + - superclass.serviceIdentifier + '-' + version - }); +function compileMap(/* lists... */) { + var result = { + scalar: {}, + sequence: {}, + mapping: {}, + fallback: {}, + multi: { + scalar: [], + sequence: [], + mapping: [], + fallback: [] } - } - if (!Object.prototype.hasOwnProperty.call(superclass.services, version)) { - superclass.apiVersions = superclass.apiVersions.concat(version).sort(); - } - superclass.services[version] = svc; + }, index, length; + + function collectType(type) { + if (type.multi) { + result.multi[type.kind].push(type); + result.multi['fallback'].push(type); } else { - setApi(version); + result[type.kind][type.tag] = result['fallback'][type.tag] = type; } + } - AWS.Service.defineMethods(svc); - return svc; - }, - - /** - * @api private - */ - hasService: function(identifier) { - return Object.prototype.hasOwnProperty.call(AWS.Service._serviceMap, identifier); - }, - - /** - * @param attachOn attach default monitoring listeners to object - * - * Each monitoring event should be emitted from service client to service constructor prototype and then - * to global service prototype like bubbling up. These default monitoring events listener will transfer - * the monitoring events to the upper layer. - * @api private - */ - addDefaultMonitoringListeners: function addDefaultMonitoringListeners(attachOn) { - attachOn.addNamedListener('MONITOR_EVENTS_BUBBLE', 'apiCallAttempt', function EVENTS_BUBBLE(event) { - var baseClass = Object.getPrototypeOf(attachOn); - if (baseClass._events) baseClass.emit('apiCallAttempt', [event]); - }); - attachOn.addNamedListener('CALL_EVENTS_BUBBLE', 'apiCall', function CALL_EVENTS_BUBBLE(event) { - var baseClass = Object.getPrototypeOf(attachOn); - if (baseClass._events) baseClass.emit('apiCall', [event]); - }); - }, - - /** - * @api private - */ - _serviceMap: {} -}); - -AWS.util.mixin(AWS.Service, AWS.SequentialExecutor); - -/** - * @api private - */ -module.exports = AWS.Service; - - -/***/ }), + for (index = 0, length = arguments.length; index < length; index += 1) { + arguments[index].forEach(collectType); + } + return result; +} -/***/ 3506: -/***/ (function(module, __unusedexports, __webpack_require__) { -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +function Schema(definition) { + return this.extend(definition); +} -apiLoader.services['kinesisanalytics'] = {}; -AWS.KinesisAnalytics = Service.defineService('kinesisanalytics', ['2015-08-14']); -Object.defineProperty(apiLoader.services['kinesisanalytics'], '2015-08-14', { - get: function get() { - var model = __webpack_require__(5616); - model.paginators = __webpack_require__(5873).pagination; - return model; - }, - enumerable: true, - configurable: true -}); -module.exports = AWS.KinesisAnalytics; +Schema.prototype.extend = function extend(definition) { + var implicit = []; + var explicit = []; + if (definition instanceof Type) { + // Schema.extend(type) + explicit.push(definition); -/***/ }), + } else if (Array.isArray(definition)) { + // Schema.extend([ type1, type2, ... ]) + explicit = explicit.concat(definition); -/***/ 3520: -/***/ (function(module) { + } else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) { + // Schema.extend({ explicit: [ type1, type2, ... ], implicit: [ type1, type2, ... ] }) + if (definition.implicit) implicit = implicit.concat(definition.implicit); + if (definition.explicit) explicit = explicit.concat(definition.explicit); -module.exports = {"pagination":{"ListMemberAccounts":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"ListS3Resources":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"}}}; + } else { + throw new YAMLException('Schema.extend argument should be a Type, [ Type ], ' + + 'or a schema definition ({ implicit: [...], explicit: [...] })'); + } -/***/ }), + implicit.forEach(function (type) { + if (!(type instanceof Type)) { + throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.'); + } -/***/ 3530: -/***/ (function(module) { + if (type.loadKind && type.loadKind !== 'scalar') { + throw new YAMLException('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.'); + } -module.exports = {"version":2,"waiters":{"SuccessfulSigningJob":{"delay":20,"operation":"DescribeSigningJob","maxAttempts":25,"acceptors":[{"expected":"Succeeded","matcher":"path","state":"success","argument":"status"},{"expected":"Failed","matcher":"path","state":"failure","argument":"status"},{"expected":"ResourceNotFoundException","matcher":"error","state":"failure"}]}}}; + if (type.multi) { + throw new YAMLException('There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.'); + } + }); -/***/ }), + explicit.forEach(function (type) { + if (!(type instanceof Type)) { + throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.'); + } + }); -/***/ 3546: -/***/ (function(module, __unusedexports, __webpack_require__) { + var result = Object.create(Schema.prototype); -var util = __webpack_require__(153); -var regionConfig = __webpack_require__(2572); + result.implicit = (this.implicit || []).concat(implicit); + result.explicit = (this.explicit || []).concat(explicit); -function generateRegionPrefix(region) { - if (!region) return null; + result.compiledImplicit = compileList(result, 'implicit'); + result.compiledExplicit = compileList(result, 'explicit'); + result.compiledTypeMap = compileMap(result.compiledImplicit, result.compiledExplicit); - var parts = region.split('-'); - if (parts.length < 3) return null; - return parts.slice(0, parts.length - 2).join('-') + '-*'; -} + return result; +}; -function derivedKeys(service) { - var region = service.config.region; - var regionPrefix = generateRegionPrefix(region); - var endpointPrefix = service.api.endpointPrefix; - return [ - [region, endpointPrefix], - [regionPrefix, endpointPrefix], - [region, '*'], - [regionPrefix, '*'], - ['*', endpointPrefix], - ['*', '*'] - ].map(function(item) { - return item[0] && item[1] ? item.join('/') : null; - }); -} +module.exports = Schema; -function applyConfig(service, config) { - util.each(config, function(key, value) { - if (key === 'globalEndpoint') return; - if (service.config[key] === undefined || service.config[key] === null) { - service.config[key] = value; - } - }); -} -function configureEndpoint(service) { - var keys = derivedKeys(service); - for (var i = 0; i < keys.length; i++) { - var key = keys[i]; - if (!key) continue; +/***/ }), - if (Object.prototype.hasOwnProperty.call(regionConfig.rules, key)) { - var config = regionConfig.rules[key]; - if (typeof config === 'string') { - config = regionConfig.patterns[config]; - } +/***/ 5746: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - // set dualstack endpoint - if (service.config.useDualstack && util.isDualstackAvailable(service)) { - config = util.copy(config); - config.endpoint = config.endpoint.replace( - /{service}\.({region}\.)?/, - '{service}.dualstack.{region}.' - ); - } +"use strict"; +// Standard YAML's Core schema. +// http://www.yaml.org/spec/1.2/spec.html#id2804923 +// +// NOTE: JS-YAML does not support schema-specific tag resolution restrictions. +// So, Core schema has no distinctions from JSON schema is JS-YAML. - // set global endpoint - service.isGlobalEndpoint = !!config.globalEndpoint; - if (config.signingRegion) { - service.signingRegion = config.signingRegion; - } - // signature version - if (!config.signatureVersion) config.signatureVersion = 'v4'; - // merge config - applyConfig(service, config); - return; - } - } -} -function getEndpointSuffix(region) { - var regionRegexes = { - '^(us|eu|ap|sa|ca|me)\\-\\w+\\-\\d+$': 'amazonaws.com', - '^cn\\-\\w+\\-\\d+$': 'amazonaws.com.cn', - '^us\\-gov\\-\\w+\\-\\d+$': 'amazonaws.com', - '^us\\-iso\\-\\w+\\-\\d+$': 'c2s.ic.gov', - '^us\\-isob\\-\\w+\\-\\d+$': 'sc2s.sgov.gov' - }; - var defaultSuffix = 'amazonaws.com'; - var regexes = Object.keys(regionRegexes); - for (var i = 0; i < regexes.length; i++) { - var regionPattern = RegExp(regexes[i]); - var dnsSuffix = regionRegexes[regexes[i]]; - if (regionPattern.test(region)) return dnsSuffix; - } - return defaultSuffix; -} -/** - * @api private - */ -module.exports = { - configureEndpoint: configureEndpoint, - getEndpointSuffix: getEndpointSuffix -}; +module.exports = __nccwpck_require__(8927); /***/ }), -/***/ 3574: -/***/ (function(module, __unusedexports, __webpack_require__) { +/***/ 7336: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; +// JS-YAML's default schema for `safeLoad` function. +// It is not described in the YAML specification. +// +// This schema is based on standard YAML's Core schema and includes most of +// extra types described at YAML tag repository. (http://yaml.org/type/) -var Type = __webpack_require__(4945); -module.exports = new Type('tag:yaml.org,2002:str', { - kind: 'scalar', - construct: function (data) { return data !== null ? data : ''; } + + +module.exports = (__nccwpck_require__(5746).extend)({ + implicit: [ + __nccwpck_require__(8966), + __nccwpck_require__(6854) + ], + explicit: [ + __nccwpck_require__(8149), + __nccwpck_require__(8649), + __nccwpck_require__(6267), + __nccwpck_require__(8758) + ] }); /***/ }), -/***/ 3581: -/***/ (function(module, __unusedexports, __webpack_require__) { +/***/ 9832: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; // Standard YAML's Failsafe schema. @@ -17820,21939 +31149,49043 @@ module.exports = new Type('tag:yaml.org,2002:str', { -var Schema = __webpack_require__(8043); +var Schema = __nccwpck_require__(2046); module.exports = new Schema({ explicit: [ - __webpack_require__(3574), - __webpack_require__(8921), - __webpack_require__(24) + __nccwpck_require__(3929), + __nccwpck_require__(7161), + __nccwpck_require__(7316) ] }); /***/ }), -/***/ 3602: -/***/ (function(module) { - -// Generated by CoffeeScript 1.12.7 -(function() { - var XMLStringifier, - bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; }, - hasProp = {}.hasOwnProperty; - - module.exports = XMLStringifier = (function() { - function XMLStringifier(options) { - this.assertLegalChar = bind(this.assertLegalChar, this); - var key, ref, value; - options || (options = {}); - this.noDoubleEncoding = options.noDoubleEncoding; - ref = options.stringify || {}; - for (key in ref) { - if (!hasProp.call(ref, key)) continue; - value = ref[key]; - this[key] = value; - } - } +/***/ 8927: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - XMLStringifier.prototype.eleName = function(val) { - val = '' + val || ''; - return this.assertLegalChar(val); - }; +"use strict"; +// Standard YAML's JSON schema. +// http://www.yaml.org/spec/1.2/spec.html#id2803231 +// +// NOTE: JS-YAML does not support schema-specific tag resolution restrictions. +// So, this schema is not such strict as defined in the YAML specification. +// It allows numbers in binary notaion, use `Null` and `NULL` as `null`, etc. - XMLStringifier.prototype.eleText = function(val) { - val = '' + val || ''; - return this.assertLegalChar(this.elEscape(val)); - }; - XMLStringifier.prototype.cdata = function(val) { - val = '' + val || ''; - val = val.replace(']]>', ']]]]>'); - return this.assertLegalChar(val); - }; - XMLStringifier.prototype.comment = function(val) { - val = '' + val || ''; - if (val.match(/--/)) { - throw new Error("Comment text cannot contain double-hypen: " + val); - } - return this.assertLegalChar(val); - }; - XMLStringifier.prototype.raw = function(val) { - return '' + val || ''; - }; - XMLStringifier.prototype.attName = function(val) { - return val = '' + val || ''; - }; +module.exports = (__nccwpck_require__(9832).extend)({ + implicit: [ + __nccwpck_require__(4333), + __nccwpck_require__(7296), + __nccwpck_require__(2271), + __nccwpck_require__(7584) + ] +}); - XMLStringifier.prototype.attValue = function(val) { - val = '' + val || ''; - return this.attEscape(val); - }; - XMLStringifier.prototype.insTarget = function(val) { - return '' + val || ''; - }; +/***/ }), - XMLStringifier.prototype.insValue = function(val) { - val = '' + val || ''; - if (val.match(/\?>/)) { - throw new Error("Invalid processing instruction value: " + val); - } - return val; - }; +/***/ 9440: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - XMLStringifier.prototype.xmlVersion = function(val) { - val = '' + val || ''; - if (!val.match(/1\.[0-9]+/)) { - throw new Error("Invalid version number: " + val); - } - return val; - }; +"use strict"; - XMLStringifier.prototype.xmlEncoding = function(val) { - val = '' + val || ''; - if (!val.match(/^[A-Za-z](?:[A-Za-z0-9._-])*$/)) { - throw new Error("Invalid encoding: " + val); - } - return val; - }; - XMLStringifier.prototype.xmlStandalone = function(val) { - if (val) { - return "yes"; - } else { - return "no"; - } - }; - XMLStringifier.prototype.dtdPubID = function(val) { - return '' + val || ''; - }; +var common = __nccwpck_require__(9816); - XMLStringifier.prototype.dtdSysID = function(val) { - return '' + val || ''; - }; - XMLStringifier.prototype.dtdElementValue = function(val) { - return '' + val || ''; - }; +// get snippet for a single line, respecting maxLength +function getLine(buffer, lineStart, lineEnd, position, maxLineLength) { + var head = ''; + var tail = ''; + var maxHalfLength = Math.floor(maxLineLength / 2) - 1; - XMLStringifier.prototype.dtdAttType = function(val) { - return '' + val || ''; - }; + if (position - lineStart > maxHalfLength) { + head = ' ... '; + lineStart = position - maxHalfLength + head.length; + } - XMLStringifier.prototype.dtdAttDefault = function(val) { - if (val != null) { - return '' + val || ''; - } else { - return val; - } - }; + if (lineEnd - position > maxHalfLength) { + tail = ' ...'; + lineEnd = position + maxHalfLength - tail.length; + } - XMLStringifier.prototype.dtdEntityValue = function(val) { - return '' + val || ''; - }; + return { + str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, '→') + tail, + pos: position - lineStart + head.length // relative position + }; +} - XMLStringifier.prototype.dtdNData = function(val) { - return '' + val || ''; - }; - XMLStringifier.prototype.convertAttKey = '@'; +function padStart(string, max) { + return common.repeat(' ', max - string.length) + string; +} - XMLStringifier.prototype.convertPIKey = '?'; - XMLStringifier.prototype.convertTextKey = '#text'; +function makeSnippet(mark, options) { + options = Object.create(options || null); - XMLStringifier.prototype.convertCDataKey = '#cdata'; + if (!mark.buffer) return null; - XMLStringifier.prototype.convertCommentKey = '#comment'; + if (!options.maxLength) options.maxLength = 79; + if (typeof options.indent !== 'number') options.indent = 1; + if (typeof options.linesBefore !== 'number') options.linesBefore = 3; + if (typeof options.linesAfter !== 'number') options.linesAfter = 2; - XMLStringifier.prototype.convertRawKey = '#raw'; + var re = /\r?\n|\r|\0/g; + var lineStarts = [ 0 ]; + var lineEnds = []; + var match; + var foundLineNo = -1; - XMLStringifier.prototype.assertLegalChar = function(str) { - var res; - res = str.match(/[\0\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/); - if (res) { - throw new Error("Invalid character in string: " + str + " at index " + res.index); - } - return str; - }; + while ((match = re.exec(mark.buffer))) { + lineEnds.push(match.index); + lineStarts.push(match.index + match[0].length); - XMLStringifier.prototype.elEscape = function(str) { - var ampregex; - ampregex = this.noDoubleEncoding ? /(?!&\S+;)&/g : /&/g; - return str.replace(ampregex, '&').replace(//g, '>').replace(/\r/g, ' '); - }; + if (mark.position <= match.index && foundLineNo < 0) { + foundLineNo = lineStarts.length - 2; + } + } - XMLStringifier.prototype.attEscape = function(str) { - var ampregex; - ampregex = this.noDoubleEncoding ? /(?!&\S+;)&/g : /&/g; - return str.replace(ampregex, '&').replace(/= lineEnds.length) break; + line = getLine( + mark.buffer, + lineStarts[foundLineNo + i], + lineEnds[foundLineNo + i], + mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]), + maxLineLength + ); + result += common.repeat(' ', options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) + + ' | ' + line.str + '\n'; + } + return result.replace(/\n$/, ''); +} -/***/ }), -/***/ 3605: -/***/ (function(module) { +module.exports = makeSnippet; -module.exports = {"version":"2.0","metadata":{"apiVersion":"2018-08-01","endpointPrefix":"license-manager","jsonVersion":"1.1","protocol":"json","serviceFullName":"AWS License Manager","serviceId":"License Manager","signatureVersion":"v4","targetPrefix":"AWSLicenseManager","uid":"license-manager-2018-08-01"},"operations":{"CreateLicenseConfiguration":{"input":{"type":"structure","required":["Name","LicenseCountingType"],"members":{"Name":{},"Description":{},"LicenseCountingType":{},"LicenseCount":{"type":"long"},"LicenseCountHardLimit":{"type":"boolean"},"LicenseRules":{"shape":"S6"},"Tags":{"shape":"S7"},"ProductInformationList":{"shape":"S9"}}},"output":{"type":"structure","members":{"LicenseConfigurationArn":{}}}},"DeleteLicenseConfiguration":{"input":{"type":"structure","required":["LicenseConfigurationArn"],"members":{"LicenseConfigurationArn":{}}},"output":{"type":"structure","members":{}}},"GetLicenseConfiguration":{"input":{"type":"structure","required":["LicenseConfigurationArn"],"members":{"LicenseConfigurationArn":{}}},"output":{"type":"structure","members":{"LicenseConfigurationId":{},"LicenseConfigurationArn":{},"Name":{},"Description":{},"LicenseCountingType":{},"LicenseRules":{"shape":"S6"},"LicenseCount":{"type":"long"},"LicenseCountHardLimit":{"type":"boolean"},"ConsumedLicenses":{"type":"long"},"Status":{},"OwnerAccountId":{},"ConsumedLicenseSummaryList":{"shape":"Si"},"ManagedResourceSummaryList":{"shape":"Sl"},"Tags":{"shape":"S7"},"ProductInformationList":{"shape":"S9"},"AutomatedDiscoveryInformation":{"shape":"Sn"}}}},"GetServiceSettings":{"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"S3BucketArn":{},"SnsTopicArn":{},"OrganizationConfiguration":{"shape":"Sr"},"EnableCrossAccountsDiscovery":{"type":"boolean"},"LicenseManagerResourceShareArn":{}}}},"ListAssociationsForLicenseConfiguration":{"input":{"type":"structure","required":["LicenseConfigurationArn"],"members":{"LicenseConfigurationArn":{},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"LicenseConfigurationAssociations":{"type":"list","member":{"type":"structure","members":{"ResourceArn":{},"ResourceType":{},"ResourceOwnerId":{},"AssociationTime":{"type":"timestamp"}}}},"NextToken":{}}}},"ListFailuresForLicenseConfigurationOperations":{"input":{"type":"structure","required":["LicenseConfigurationArn"],"members":{"LicenseConfigurationArn":{},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"LicenseOperationFailureList":{"type":"list","member":{"type":"structure","members":{"ResourceArn":{},"ResourceType":{},"ErrorMessage":{},"FailureTime":{"type":"timestamp"},"OperationName":{},"ResourceOwnerId":{},"OperationRequestedBy":{},"MetadataList":{"type":"list","member":{"type":"structure","members":{"Name":{},"Value":{}}}}}}},"NextToken":{}}}},"ListLicenseConfigurations":{"input":{"type":"structure","members":{"LicenseConfigurationArns":{"shape":"S6"},"MaxResults":{"type":"integer"},"NextToken":{},"Filters":{"shape":"S15"}}},"output":{"type":"structure","members":{"LicenseConfigurations":{"type":"list","member":{"type":"structure","members":{"LicenseConfigurationId":{},"LicenseConfigurationArn":{},"Name":{},"Description":{},"LicenseCountingType":{},"LicenseRules":{"shape":"S6"},"LicenseCount":{"type":"long"},"LicenseCountHardLimit":{"type":"boolean"},"ConsumedLicenses":{"type":"long"},"Status":{},"OwnerAccountId":{},"ConsumedLicenseSummaryList":{"shape":"Si"},"ManagedResourceSummaryList":{"shape":"Sl"},"ProductInformationList":{"shape":"S9"},"AutomatedDiscoveryInformation":{"shape":"Sn"}}}},"NextToken":{}}}},"ListLicenseSpecificationsForResource":{"input":{"type":"structure","required":["ResourceArn"],"members":{"ResourceArn":{},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"LicenseSpecifications":{"shape":"S1f"},"NextToken":{}}}},"ListResourceInventory":{"input":{"type":"structure","members":{"MaxResults":{"type":"integer"},"NextToken":{},"Filters":{"type":"list","member":{"type":"structure","required":["Name","Condition"],"members":{"Name":{},"Condition":{},"Value":{}}}}}},"output":{"type":"structure","members":{"ResourceInventoryList":{"type":"list","member":{"type":"structure","members":{"ResourceId":{},"ResourceType":{},"ResourceArn":{},"Platform":{},"PlatformVersion":{},"ResourceOwningAccountId":{}}}},"NextToken":{}}}},"ListTagsForResource":{"input":{"type":"structure","required":["ResourceArn"],"members":{"ResourceArn":{}}},"output":{"type":"structure","members":{"Tags":{"shape":"S7"}}}},"ListUsageForLicenseConfiguration":{"input":{"type":"structure","required":["LicenseConfigurationArn"],"members":{"LicenseConfigurationArn":{},"MaxResults":{"type":"integer"},"NextToken":{},"Filters":{"shape":"S15"}}},"output":{"type":"structure","members":{"LicenseConfigurationUsageList":{"type":"list","member":{"type":"structure","members":{"ResourceArn":{},"ResourceType":{},"ResourceStatus":{},"ResourceOwnerId":{},"AssociationTime":{"type":"timestamp"},"ConsumedLicenses":{"type":"long"}}}},"NextToken":{}}}},"TagResource":{"input":{"type":"structure","required":["ResourceArn","Tags"],"members":{"ResourceArn":{},"Tags":{"shape":"S7"}}},"output":{"type":"structure","members":{}}},"UntagResource":{"input":{"type":"structure","required":["ResourceArn","TagKeys"],"members":{"ResourceArn":{},"TagKeys":{"type":"list","member":{}}}},"output":{"type":"structure","members":{}}},"UpdateLicenseConfiguration":{"input":{"type":"structure","required":["LicenseConfigurationArn"],"members":{"LicenseConfigurationArn":{},"LicenseConfigurationStatus":{},"LicenseRules":{"shape":"S6"},"LicenseCount":{"type":"long"},"LicenseCountHardLimit":{"type":"boolean"},"Name":{},"Description":{},"ProductInformationList":{"shape":"S9"}}},"output":{"type":"structure","members":{}}},"UpdateLicenseSpecificationsForResource":{"input":{"type":"structure","required":["ResourceArn"],"members":{"ResourceArn":{},"AddLicenseSpecifications":{"shape":"S1f"},"RemoveLicenseSpecifications":{"shape":"S1f"}}},"output":{"type":"structure","members":{}}},"UpdateServiceSettings":{"input":{"type":"structure","members":{"S3BucketArn":{},"SnsTopicArn":{},"OrganizationConfiguration":{"shape":"Sr"},"EnableCrossAccountsDiscovery":{"type":"boolean"}}},"output":{"type":"structure","members":{}}}},"shapes":{"S6":{"type":"list","member":{}},"S7":{"type":"list","member":{"type":"structure","members":{"Key":{},"Value":{}}}},"S9":{"type":"list","member":{"type":"structure","required":["ResourceType","ProductInformationFilterList"],"members":{"ResourceType":{},"ProductInformationFilterList":{"type":"list","member":{"type":"structure","required":["ProductInformationFilterName","ProductInformationFilterValue","ProductInformationFilterComparator"],"members":{"ProductInformationFilterName":{},"ProductInformationFilterValue":{"shape":"S6"},"ProductInformationFilterComparator":{}}}}}}},"Si":{"type":"list","member":{"type":"structure","members":{"ResourceType":{},"ConsumedLicenses":{"type":"long"}}}},"Sl":{"type":"list","member":{"type":"structure","members":{"ResourceType":{},"AssociationCount":{"type":"long"}}}},"Sn":{"type":"structure","members":{"LastRunTime":{"type":"timestamp"}}},"Sr":{"type":"structure","required":["EnableIntegration"],"members":{"EnableIntegration":{"type":"boolean"}}},"S15":{"type":"list","member":{"type":"structure","members":{"Name":{},"Values":{"type":"list","member":{}}}}},"S1f":{"type":"list","member":{"type":"structure","required":["LicenseConfigurationArn"],"members":{"LicenseConfigurationArn":{}}}}}}; /***/ }), -/***/ 3611: -/***/ (function(module, __unusedexports, __webpack_require__) { +/***/ 9557: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; -// Standard YAML's Core schema. -// http://www.yaml.org/spec/1.2/spec.html#id2804923 -// -// NOTE: JS-YAML does not support schema-specific tag resolution restrictions. -// So, Core schema has no distinctions from JSON schema is JS-YAML. +var YAMLException = __nccwpck_require__(1248); +var TYPE_CONSTRUCTOR_OPTIONS = [ + 'kind', + 'multi', + 'resolve', + 'construct', + 'instanceOf', + 'predicate', + 'represent', + 'representName', + 'defaultStyle', + 'styleAliases' +]; +var YAML_NODE_KINDS = [ + 'scalar', + 'sequence', + 'mapping' +]; -var Schema = __webpack_require__(8043); - - -module.exports = new Schema({ - include: [ - __webpack_require__(8023) - ] -}); - +function compileStyleAliases(map) { + var result = {}; -/***/ }), + if (map !== null) { + Object.keys(map).forEach(function (style) { + map[style].forEach(function (alias) { + result[String(alias)] = style; + }); + }); + } -/***/ 3616: -/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) { + return result; +} -var AWS = __webpack_require__(395); +function Type(tag, options) { + options = options || {}; -AWS.util.update(AWS.APIGateway.prototype, { -/** - * Sets the Accept header to application/json. - * - * @api private - */ - setAcceptHeader: function setAcceptHeader(req) { - var httpRequest = req.httpRequest; - if (!httpRequest.headers.Accept) { - httpRequest.headers['Accept'] = 'application/json'; + Object.keys(options).forEach(function (name) { + if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) { + throw new YAMLException('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.'); } - }, + }); - /** - * @api private - */ - setupRequestListeners: function setupRequestListeners(request) { - request.addListener('build', this.setAcceptHeader); - if (request.operation === 'getExport') { - var params = request.params || {}; - if (params.exportType === 'swagger') { - request.addListener('extractData', AWS.util.convertPayloadToString); - } - } + // TODO: Add tag format check. + this.options = options; // keep original options in case user wants to extend this type later + this.tag = tag; + this.kind = options['kind'] || null; + this.resolve = options['resolve'] || function () { return true; }; + this.construct = options['construct'] || function (data) { return data; }; + this.instanceOf = options['instanceOf'] || null; + this.predicate = options['predicate'] || null; + this.represent = options['represent'] || null; + this.representName = options['representName'] || null; + this.defaultStyle = options['defaultStyle'] || null; + this.multi = options['multi'] || false; + this.styleAliases = compileStyleAliases(options['styleAliases'] || null); + + if (YAML_NODE_KINDS.indexOf(this.kind) === -1) { + throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.'); } -}); +} +module.exports = Type; /***/ }), -/***/ 3624: -/***/ (function(module, __unusedexports, __webpack_require__) { +/***/ 8149: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var util = __webpack_require__(153); -var property = util.property; +"use strict"; -function ResourceWaiter(name, waiter, options) { - options = options || {}; - property(this, 'name', name); - property(this, 'api', options.api, false); - if (waiter.operation) { - property(this, 'operation', util.string.lowerFirst(waiter.operation)); - } +/*eslint-disable no-bitwise*/ - var self = this; - var keys = [ - 'type', - 'description', - 'delay', - 'maxAttempts', - 'acceptors' - ]; - - keys.forEach(function(key) { - var value = waiter[key]; - if (value) { - property(self, key, value); - } - }); -} -/** - * @api private - */ -module.exports = ResourceWaiter; +var Type = __nccwpck_require__(9557); -/***/ }), +// [ 64, 65, 66 ] -> [ padding, CR, LF ] +var BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r'; -/***/ 3627: -/***/ (function(module) { -module.exports = {"version":"2.0","metadata":{"apiVersion":"2012-01-25","endpointPrefix":"swf","jsonVersion":"1.0","protocol":"json","serviceAbbreviation":"Amazon SWF","serviceFullName":"Amazon Simple Workflow Service","serviceId":"SWF","signatureVersion":"v4","targetPrefix":"SimpleWorkflowService","uid":"swf-2012-01-25"},"operations":{"CountClosedWorkflowExecutions":{"input":{"type":"structure","required":["domain"],"members":{"domain":{},"startTimeFilter":{"shape":"S3"},"closeTimeFilter":{"shape":"S3"},"executionFilter":{"shape":"S5"},"typeFilter":{"shape":"S7"},"tagFilter":{"shape":"Sa"},"closeStatusFilter":{"shape":"Sc"}}},"output":{"shape":"Se"}},"CountOpenWorkflowExecutions":{"input":{"type":"structure","required":["domain","startTimeFilter"],"members":{"domain":{},"startTimeFilter":{"shape":"S3"},"typeFilter":{"shape":"S7"},"tagFilter":{"shape":"Sa"},"executionFilter":{"shape":"S5"}}},"output":{"shape":"Se"}},"CountPendingActivityTasks":{"input":{"type":"structure","required":["domain","taskList"],"members":{"domain":{},"taskList":{"shape":"Sj"}}},"output":{"shape":"Sk"}},"CountPendingDecisionTasks":{"input":{"type":"structure","required":["domain","taskList"],"members":{"domain":{},"taskList":{"shape":"Sj"}}},"output":{"shape":"Sk"}},"DeprecateActivityType":{"input":{"type":"structure","required":["domain","activityType"],"members":{"domain":{},"activityType":{"shape":"Sn"}}}},"DeprecateDomain":{"input":{"type":"structure","required":["name"],"members":{"name":{}}}},"DeprecateWorkflowType":{"input":{"type":"structure","required":["domain","workflowType"],"members":{"domain":{},"workflowType":{"shape":"Sr"}}}},"DescribeActivityType":{"input":{"type":"structure","required":["domain","activityType"],"members":{"domain":{},"activityType":{"shape":"Sn"}}},"output":{"type":"structure","required":["typeInfo","configuration"],"members":{"typeInfo":{"shape":"Su"},"configuration":{"type":"structure","members":{"defaultTaskStartToCloseTimeout":{},"defaultTaskHeartbeatTimeout":{},"defaultTaskList":{"shape":"Sj"},"defaultTaskPriority":{},"defaultTaskScheduleToStartTimeout":{},"defaultTaskScheduleToCloseTimeout":{}}}}}},"DescribeDomain":{"input":{"type":"structure","required":["name"],"members":{"name":{}}},"output":{"type":"structure","required":["domainInfo","configuration"],"members":{"domainInfo":{"shape":"S12"},"configuration":{"type":"structure","required":["workflowExecutionRetentionPeriodInDays"],"members":{"workflowExecutionRetentionPeriodInDays":{}}}}}},"DescribeWorkflowExecution":{"input":{"type":"structure","required":["domain","execution"],"members":{"domain":{},"execution":{"shape":"S17"}}},"output":{"type":"structure","required":["executionInfo","executionConfiguration","openCounts"],"members":{"executionInfo":{"shape":"S1a"},"executionConfiguration":{"type":"structure","required":["taskStartToCloseTimeout","executionStartToCloseTimeout","taskList","childPolicy"],"members":{"taskStartToCloseTimeout":{},"executionStartToCloseTimeout":{},"taskList":{"shape":"Sj"},"taskPriority":{},"childPolicy":{},"lambdaRole":{}}},"openCounts":{"type":"structure","required":["openActivityTasks","openDecisionTasks","openTimers","openChildWorkflowExecutions"],"members":{"openActivityTasks":{"type":"integer"},"openDecisionTasks":{"type":"integer"},"openTimers":{"type":"integer"},"openChildWorkflowExecutions":{"type":"integer"},"openLambdaFunctions":{"type":"integer"}}},"latestActivityTaskTimestamp":{"type":"timestamp"},"latestExecutionContext":{}}}},"DescribeWorkflowType":{"input":{"type":"structure","required":["domain","workflowType"],"members":{"domain":{},"workflowType":{"shape":"Sr"}}},"output":{"type":"structure","required":["typeInfo","configuration"],"members":{"typeInfo":{"shape":"S1m"},"configuration":{"type":"structure","members":{"defaultTaskStartToCloseTimeout":{},"defaultExecutionStartToCloseTimeout":{},"defaultTaskList":{"shape":"Sj"},"defaultTaskPriority":{},"defaultChildPolicy":{},"defaultLambdaRole":{}}}}}},"GetWorkflowExecutionHistory":{"input":{"type":"structure","required":["domain","execution"],"members":{"domain":{},"execution":{"shape":"S17"},"nextPageToken":{},"maximumPageSize":{"type":"integer"},"reverseOrder":{"type":"boolean"}}},"output":{"type":"structure","required":["events"],"members":{"events":{"shape":"S1t"},"nextPageToken":{}}}},"ListActivityTypes":{"input":{"type":"structure","required":["domain","registrationStatus"],"members":{"domain":{},"name":{},"registrationStatus":{},"nextPageToken":{},"maximumPageSize":{"type":"integer"},"reverseOrder":{"type":"boolean"}}},"output":{"type":"structure","required":["typeInfos"],"members":{"typeInfos":{"type":"list","member":{"shape":"Su"}},"nextPageToken":{}}}},"ListClosedWorkflowExecutions":{"input":{"type":"structure","required":["domain"],"members":{"domain":{},"startTimeFilter":{"shape":"S3"},"closeTimeFilter":{"shape":"S3"},"executionFilter":{"shape":"S5"},"closeStatusFilter":{"shape":"Sc"},"typeFilter":{"shape":"S7"},"tagFilter":{"shape":"Sa"},"nextPageToken":{},"maximumPageSize":{"type":"integer"},"reverseOrder":{"type":"boolean"}}},"output":{"shape":"S4g"}},"ListDomains":{"input":{"type":"structure","required":["registrationStatus"],"members":{"nextPageToken":{},"registrationStatus":{},"maximumPageSize":{"type":"integer"},"reverseOrder":{"type":"boolean"}}},"output":{"type":"structure","required":["domainInfos"],"members":{"domainInfos":{"type":"list","member":{"shape":"S12"}},"nextPageToken":{}}}},"ListOpenWorkflowExecutions":{"input":{"type":"structure","required":["domain","startTimeFilter"],"members":{"domain":{},"startTimeFilter":{"shape":"S3"},"typeFilter":{"shape":"S7"},"tagFilter":{"shape":"Sa"},"nextPageToken":{},"maximumPageSize":{"type":"integer"},"reverseOrder":{"type":"boolean"},"executionFilter":{"shape":"S5"}}},"output":{"shape":"S4g"}},"ListTagsForResource":{"input":{"type":"structure","required":["resourceArn"],"members":{"resourceArn":{}}},"output":{"type":"structure","members":{"tags":{"shape":"S4o"}}}},"ListWorkflowTypes":{"input":{"type":"structure","required":["domain","registrationStatus"],"members":{"domain":{},"name":{},"registrationStatus":{},"nextPageToken":{},"maximumPageSize":{"type":"integer"},"reverseOrder":{"type":"boolean"}}},"output":{"type":"structure","required":["typeInfos"],"members":{"typeInfos":{"type":"list","member":{"shape":"S1m"}},"nextPageToken":{}}}},"PollForActivityTask":{"input":{"type":"structure","required":["domain","taskList"],"members":{"domain":{},"taskList":{"shape":"Sj"},"identity":{}}},"output":{"type":"structure","required":["taskToken","activityId","startedEventId","workflowExecution","activityType"],"members":{"taskToken":{},"activityId":{},"startedEventId":{"type":"long"},"workflowExecution":{"shape":"S17"},"activityType":{"shape":"Sn"},"input":{}}}},"PollForDecisionTask":{"input":{"type":"structure","required":["domain","taskList"],"members":{"domain":{},"taskList":{"shape":"Sj"},"identity":{},"nextPageToken":{},"maximumPageSize":{"type":"integer"},"reverseOrder":{"type":"boolean"}}},"output":{"type":"structure","required":["taskToken","startedEventId","workflowExecution","workflowType","events"],"members":{"taskToken":{},"startedEventId":{"type":"long"},"workflowExecution":{"shape":"S17"},"workflowType":{"shape":"Sr"},"events":{"shape":"S1t"},"nextPageToken":{},"previousStartedEventId":{"type":"long"}}}},"RecordActivityTaskHeartbeat":{"input":{"type":"structure","required":["taskToken"],"members":{"taskToken":{},"details":{}}},"output":{"type":"structure","required":["cancelRequested"],"members":{"cancelRequested":{"type":"boolean"}}}},"RegisterActivityType":{"input":{"type":"structure","required":["domain","name","version"],"members":{"domain":{},"name":{},"version":{},"description":{},"defaultTaskStartToCloseTimeout":{},"defaultTaskHeartbeatTimeout":{},"defaultTaskList":{"shape":"Sj"},"defaultTaskPriority":{},"defaultTaskScheduleToStartTimeout":{},"defaultTaskScheduleToCloseTimeout":{}}}},"RegisterDomain":{"input":{"type":"structure","required":["name","workflowExecutionRetentionPeriodInDays"],"members":{"name":{},"description":{},"workflowExecutionRetentionPeriodInDays":{},"tags":{"shape":"S4o"}}}},"RegisterWorkflowType":{"input":{"type":"structure","required":["domain","name","version"],"members":{"domain":{},"name":{},"version":{},"description":{},"defaultTaskStartToCloseTimeout":{},"defaultExecutionStartToCloseTimeout":{},"defaultTaskList":{"shape":"Sj"},"defaultTaskPriority":{},"defaultChildPolicy":{},"defaultLambdaRole":{}}}},"RequestCancelWorkflowExecution":{"input":{"type":"structure","required":["domain","workflowId"],"members":{"domain":{},"workflowId":{},"runId":{}}}},"RespondActivityTaskCanceled":{"input":{"type":"structure","required":["taskToken"],"members":{"taskToken":{},"details":{}}}},"RespondActivityTaskCompleted":{"input":{"type":"structure","required":["taskToken"],"members":{"taskToken":{},"result":{}}}},"RespondActivityTaskFailed":{"input":{"type":"structure","required":["taskToken"],"members":{"taskToken":{},"reason":{},"details":{}}}},"RespondDecisionTaskCompleted":{"input":{"type":"structure","required":["taskToken"],"members":{"taskToken":{},"decisions":{"type":"list","member":{"type":"structure","required":["decisionType"],"members":{"decisionType":{},"scheduleActivityTaskDecisionAttributes":{"type":"structure","required":["activityType","activityId"],"members":{"activityType":{"shape":"Sn"},"activityId":{},"control":{},"input":{},"scheduleToCloseTimeout":{},"taskList":{"shape":"Sj"},"taskPriority":{},"scheduleToStartTimeout":{},"startToCloseTimeout":{},"heartbeatTimeout":{}}},"requestCancelActivityTaskDecisionAttributes":{"type":"structure","required":["activityId"],"members":{"activityId":{}}},"completeWorkflowExecutionDecisionAttributes":{"type":"structure","members":{"result":{}}},"failWorkflowExecutionDecisionAttributes":{"type":"structure","members":{"reason":{},"details":{}}},"cancelWorkflowExecutionDecisionAttributes":{"type":"structure","members":{"details":{}}},"continueAsNewWorkflowExecutionDecisionAttributes":{"type":"structure","members":{"input":{},"executionStartToCloseTimeout":{},"taskList":{"shape":"Sj"},"taskPriority":{},"taskStartToCloseTimeout":{},"childPolicy":{},"tagList":{"shape":"S1c"},"workflowTypeVersion":{},"lambdaRole":{}}},"recordMarkerDecisionAttributes":{"type":"structure","required":["markerName"],"members":{"markerName":{},"details":{}}},"startTimerDecisionAttributes":{"type":"structure","required":["timerId","startToFireTimeout"],"members":{"timerId":{},"control":{},"startToFireTimeout":{}}},"cancelTimerDecisionAttributes":{"type":"structure","required":["timerId"],"members":{"timerId":{}}},"signalExternalWorkflowExecutionDecisionAttributes":{"type":"structure","required":["workflowId","signalName"],"members":{"workflowId":{},"runId":{},"signalName":{},"input":{},"control":{}}},"requestCancelExternalWorkflowExecutionDecisionAttributes":{"type":"structure","required":["workflowId"],"members":{"workflowId":{},"runId":{},"control":{}}},"startChildWorkflowExecutionDecisionAttributes":{"type":"structure","required":["workflowType","workflowId"],"members":{"workflowType":{"shape":"Sr"},"workflowId":{},"control":{},"input":{},"executionStartToCloseTimeout":{},"taskList":{"shape":"Sj"},"taskPriority":{},"taskStartToCloseTimeout":{},"childPolicy":{},"tagList":{"shape":"S1c"},"lambdaRole":{}}},"scheduleLambdaFunctionDecisionAttributes":{"type":"structure","required":["id","name"],"members":{"id":{},"name":{},"control":{},"input":{},"startToCloseTimeout":{}}}}}},"executionContext":{}}}},"SignalWorkflowExecution":{"input":{"type":"structure","required":["domain","workflowId","signalName"],"members":{"domain":{},"workflowId":{},"runId":{},"signalName":{},"input":{}}}},"StartWorkflowExecution":{"input":{"type":"structure","required":["domain","workflowId","workflowType"],"members":{"domain":{},"workflowId":{},"workflowType":{"shape":"Sr"},"taskList":{"shape":"Sj"},"taskPriority":{},"input":{},"executionStartToCloseTimeout":{},"tagList":{"shape":"S1c"},"taskStartToCloseTimeout":{},"childPolicy":{},"lambdaRole":{}}},"output":{"type":"structure","members":{"runId":{}}}},"TagResource":{"input":{"type":"structure","required":["resourceArn","tags"],"members":{"resourceArn":{},"tags":{"shape":"S4o"}}}},"TerminateWorkflowExecution":{"input":{"type":"structure","required":["domain","workflowId"],"members":{"domain":{},"workflowId":{},"runId":{},"reason":{},"details":{},"childPolicy":{}}}},"UndeprecateActivityType":{"input":{"type":"structure","required":["domain","activityType"],"members":{"domain":{},"activityType":{"shape":"Sn"}}}},"UndeprecateDomain":{"input":{"type":"structure","required":["name"],"members":{"name":{}}}},"UndeprecateWorkflowType":{"input":{"type":"structure","required":["domain","workflowType"],"members":{"domain":{},"workflowType":{"shape":"Sr"}}}},"UntagResource":{"input":{"type":"structure","required":["resourceArn","tagKeys"],"members":{"resourceArn":{},"tagKeys":{"type":"list","member":{}}}}}},"shapes":{"S3":{"type":"structure","required":["oldestDate"],"members":{"oldestDate":{"type":"timestamp"},"latestDate":{"type":"timestamp"}}},"S5":{"type":"structure","required":["workflowId"],"members":{"workflowId":{}}},"S7":{"type":"structure","required":["name"],"members":{"name":{},"version":{}}},"Sa":{"type":"structure","required":["tag"],"members":{"tag":{}}},"Sc":{"type":"structure","required":["status"],"members":{"status":{}}},"Se":{"type":"structure","required":["count"],"members":{"count":{"type":"integer"},"truncated":{"type":"boolean"}}},"Sj":{"type":"structure","required":["name"],"members":{"name":{}}},"Sk":{"type":"structure","required":["count"],"members":{"count":{"type":"integer"},"truncated":{"type":"boolean"}}},"Sn":{"type":"structure","required":["name","version"],"members":{"name":{},"version":{}}},"Sr":{"type":"structure","required":["name","version"],"members":{"name":{},"version":{}}},"Su":{"type":"structure","required":["activityType","status","creationDate"],"members":{"activityType":{"shape":"Sn"},"status":{},"description":{},"creationDate":{"type":"timestamp"},"deprecationDate":{"type":"timestamp"}}},"S12":{"type":"structure","required":["name","status"],"members":{"name":{},"status":{},"description":{},"arn":{}}},"S17":{"type":"structure","required":["workflowId","runId"],"members":{"workflowId":{},"runId":{}}},"S1a":{"type":"structure","required":["execution","workflowType","startTimestamp","executionStatus"],"members":{"execution":{"shape":"S17"},"workflowType":{"shape":"Sr"},"startTimestamp":{"type":"timestamp"},"closeTimestamp":{"type":"timestamp"},"executionStatus":{},"closeStatus":{},"parent":{"shape":"S17"},"tagList":{"shape":"S1c"},"cancelRequested":{"type":"boolean"}}},"S1c":{"type":"list","member":{}},"S1m":{"type":"structure","required":["workflowType","status","creationDate"],"members":{"workflowType":{"shape":"Sr"},"status":{},"description":{},"creationDate":{"type":"timestamp"},"deprecationDate":{"type":"timestamp"}}},"S1t":{"type":"list","member":{"type":"structure","required":["eventTimestamp","eventType","eventId"],"members":{"eventTimestamp":{"type":"timestamp"},"eventType":{},"eventId":{"type":"long"},"workflowExecutionStartedEventAttributes":{"type":"structure","required":["childPolicy","taskList","workflowType"],"members":{"input":{},"executionStartToCloseTimeout":{},"taskStartToCloseTimeout":{},"childPolicy":{},"taskList":{"shape":"Sj"},"taskPriority":{},"workflowType":{"shape":"Sr"},"tagList":{"shape":"S1c"},"continuedExecutionRunId":{},"parentWorkflowExecution":{"shape":"S17"},"parentInitiatedEventId":{"type":"long"},"lambdaRole":{}}},"workflowExecutionCompletedEventAttributes":{"type":"structure","required":["decisionTaskCompletedEventId"],"members":{"result":{},"decisionTaskCompletedEventId":{"type":"long"}}},"completeWorkflowExecutionFailedEventAttributes":{"type":"structure","required":["cause","decisionTaskCompletedEventId"],"members":{"cause":{},"decisionTaskCompletedEventId":{"type":"long"}}},"workflowExecutionFailedEventAttributes":{"type":"structure","required":["decisionTaskCompletedEventId"],"members":{"reason":{},"details":{},"decisionTaskCompletedEventId":{"type":"long"}}},"failWorkflowExecutionFailedEventAttributes":{"type":"structure","required":["cause","decisionTaskCompletedEventId"],"members":{"cause":{},"decisionTaskCompletedEventId":{"type":"long"}}},"workflowExecutionTimedOutEventAttributes":{"type":"structure","required":["timeoutType","childPolicy"],"members":{"timeoutType":{},"childPolicy":{}}},"workflowExecutionCanceledEventAttributes":{"type":"structure","required":["decisionTaskCompletedEventId"],"members":{"details":{},"decisionTaskCompletedEventId":{"type":"long"}}},"cancelWorkflowExecutionFailedEventAttributes":{"type":"structure","required":["cause","decisionTaskCompletedEventId"],"members":{"cause":{},"decisionTaskCompletedEventId":{"type":"long"}}},"workflowExecutionContinuedAsNewEventAttributes":{"type":"structure","required":["decisionTaskCompletedEventId","newExecutionRunId","taskList","childPolicy","workflowType"],"members":{"input":{},"decisionTaskCompletedEventId":{"type":"long"},"newExecutionRunId":{},"executionStartToCloseTimeout":{},"taskList":{"shape":"Sj"},"taskPriority":{},"taskStartToCloseTimeout":{},"childPolicy":{},"tagList":{"shape":"S1c"},"workflowType":{"shape":"Sr"},"lambdaRole":{}}},"continueAsNewWorkflowExecutionFailedEventAttributes":{"type":"structure","required":["cause","decisionTaskCompletedEventId"],"members":{"cause":{},"decisionTaskCompletedEventId":{"type":"long"}}},"workflowExecutionTerminatedEventAttributes":{"type":"structure","required":["childPolicy"],"members":{"reason":{},"details":{},"childPolicy":{},"cause":{}}},"workflowExecutionCancelRequestedEventAttributes":{"type":"structure","members":{"externalWorkflowExecution":{"shape":"S17"},"externalInitiatedEventId":{"type":"long"},"cause":{}}},"decisionTaskScheduledEventAttributes":{"type":"structure","required":["taskList"],"members":{"taskList":{"shape":"Sj"},"taskPriority":{},"startToCloseTimeout":{}}},"decisionTaskStartedEventAttributes":{"type":"structure","required":["scheduledEventId"],"members":{"identity":{},"scheduledEventId":{"type":"long"}}},"decisionTaskCompletedEventAttributes":{"type":"structure","required":["scheduledEventId","startedEventId"],"members":{"executionContext":{},"scheduledEventId":{"type":"long"},"startedEventId":{"type":"long"}}},"decisionTaskTimedOutEventAttributes":{"type":"structure","required":["timeoutType","scheduledEventId","startedEventId"],"members":{"timeoutType":{},"scheduledEventId":{"type":"long"},"startedEventId":{"type":"long"}}},"activityTaskScheduledEventAttributes":{"type":"structure","required":["activityType","activityId","taskList","decisionTaskCompletedEventId"],"members":{"activityType":{"shape":"Sn"},"activityId":{},"input":{},"control":{},"scheduleToStartTimeout":{},"scheduleToCloseTimeout":{},"startToCloseTimeout":{},"taskList":{"shape":"Sj"},"taskPriority":{},"decisionTaskCompletedEventId":{"type":"long"},"heartbeatTimeout":{}}},"activityTaskStartedEventAttributes":{"type":"structure","required":["scheduledEventId"],"members":{"identity":{},"scheduledEventId":{"type":"long"}}},"activityTaskCompletedEventAttributes":{"type":"structure","required":["scheduledEventId","startedEventId"],"members":{"result":{},"scheduledEventId":{"type":"long"},"startedEventId":{"type":"long"}}},"activityTaskFailedEventAttributes":{"type":"structure","required":["scheduledEventId","startedEventId"],"members":{"reason":{},"details":{},"scheduledEventId":{"type":"long"},"startedEventId":{"type":"long"}}},"activityTaskTimedOutEventAttributes":{"type":"structure","required":["timeoutType","scheduledEventId","startedEventId"],"members":{"timeoutType":{},"scheduledEventId":{"type":"long"},"startedEventId":{"type":"long"},"details":{}}},"activityTaskCanceledEventAttributes":{"type":"structure","required":["scheduledEventId","startedEventId"],"members":{"details":{},"scheduledEventId":{"type":"long"},"startedEventId":{"type":"long"},"latestCancelRequestedEventId":{"type":"long"}}},"activityTaskCancelRequestedEventAttributes":{"type":"structure","required":["decisionTaskCompletedEventId","activityId"],"members":{"decisionTaskCompletedEventId":{"type":"long"},"activityId":{}}},"workflowExecutionSignaledEventAttributes":{"type":"structure","required":["signalName"],"members":{"signalName":{},"input":{},"externalWorkflowExecution":{"shape":"S17"},"externalInitiatedEventId":{"type":"long"}}},"markerRecordedEventAttributes":{"type":"structure","required":["markerName","decisionTaskCompletedEventId"],"members":{"markerName":{},"details":{},"decisionTaskCompletedEventId":{"type":"long"}}},"recordMarkerFailedEventAttributes":{"type":"structure","required":["markerName","cause","decisionTaskCompletedEventId"],"members":{"markerName":{},"cause":{},"decisionTaskCompletedEventId":{"type":"long"}}},"timerStartedEventAttributes":{"type":"structure","required":["timerId","startToFireTimeout","decisionTaskCompletedEventId"],"members":{"timerId":{},"control":{},"startToFireTimeout":{},"decisionTaskCompletedEventId":{"type":"long"}}},"timerFiredEventAttributes":{"type":"structure","required":["timerId","startedEventId"],"members":{"timerId":{},"startedEventId":{"type":"long"}}},"timerCanceledEventAttributes":{"type":"structure","required":["timerId","startedEventId","decisionTaskCompletedEventId"],"members":{"timerId":{},"startedEventId":{"type":"long"},"decisionTaskCompletedEventId":{"type":"long"}}},"startChildWorkflowExecutionInitiatedEventAttributes":{"type":"structure","required":["workflowId","workflowType","taskList","decisionTaskCompletedEventId","childPolicy"],"members":{"workflowId":{},"workflowType":{"shape":"Sr"},"control":{},"input":{},"executionStartToCloseTimeout":{},"taskList":{"shape":"Sj"},"taskPriority":{},"decisionTaskCompletedEventId":{"type":"long"},"childPolicy":{},"taskStartToCloseTimeout":{},"tagList":{"shape":"S1c"},"lambdaRole":{}}},"childWorkflowExecutionStartedEventAttributes":{"type":"structure","required":["workflowExecution","workflowType","initiatedEventId"],"members":{"workflowExecution":{"shape":"S17"},"workflowType":{"shape":"Sr"},"initiatedEventId":{"type":"long"}}},"childWorkflowExecutionCompletedEventAttributes":{"type":"structure","required":["workflowExecution","workflowType","initiatedEventId","startedEventId"],"members":{"workflowExecution":{"shape":"S17"},"workflowType":{"shape":"Sr"},"result":{},"initiatedEventId":{"type":"long"},"startedEventId":{"type":"long"}}},"childWorkflowExecutionFailedEventAttributes":{"type":"structure","required":["workflowExecution","workflowType","initiatedEventId","startedEventId"],"members":{"workflowExecution":{"shape":"S17"},"workflowType":{"shape":"Sr"},"reason":{},"details":{},"initiatedEventId":{"type":"long"},"startedEventId":{"type":"long"}}},"childWorkflowExecutionTimedOutEventAttributes":{"type":"structure","required":["workflowExecution","workflowType","timeoutType","initiatedEventId","startedEventId"],"members":{"workflowExecution":{"shape":"S17"},"workflowType":{"shape":"Sr"},"timeoutType":{},"initiatedEventId":{"type":"long"},"startedEventId":{"type":"long"}}},"childWorkflowExecutionCanceledEventAttributes":{"type":"structure","required":["workflowExecution","workflowType","initiatedEventId","startedEventId"],"members":{"workflowExecution":{"shape":"S17"},"workflowType":{"shape":"Sr"},"details":{},"initiatedEventId":{"type":"long"},"startedEventId":{"type":"long"}}},"childWorkflowExecutionTerminatedEventAttributes":{"type":"structure","required":["workflowExecution","workflowType","initiatedEventId","startedEventId"],"members":{"workflowExecution":{"shape":"S17"},"workflowType":{"shape":"Sr"},"initiatedEventId":{"type":"long"},"startedEventId":{"type":"long"}}},"signalExternalWorkflowExecutionInitiatedEventAttributes":{"type":"structure","required":["workflowId","signalName","decisionTaskCompletedEventId"],"members":{"workflowId":{},"runId":{},"signalName":{},"input":{},"decisionTaskCompletedEventId":{"type":"long"},"control":{}}},"externalWorkflowExecutionSignaledEventAttributes":{"type":"structure","required":["workflowExecution","initiatedEventId"],"members":{"workflowExecution":{"shape":"S17"},"initiatedEventId":{"type":"long"}}},"signalExternalWorkflowExecutionFailedEventAttributes":{"type":"structure","required":["workflowId","cause","initiatedEventId","decisionTaskCompletedEventId"],"members":{"workflowId":{},"runId":{},"cause":{},"initiatedEventId":{"type":"long"},"decisionTaskCompletedEventId":{"type":"long"},"control":{}}},"externalWorkflowExecutionCancelRequestedEventAttributes":{"type":"structure","required":["workflowExecution","initiatedEventId"],"members":{"workflowExecution":{"shape":"S17"},"initiatedEventId":{"type":"long"}}},"requestCancelExternalWorkflowExecutionInitiatedEventAttributes":{"type":"structure","required":["workflowId","decisionTaskCompletedEventId"],"members":{"workflowId":{},"runId":{},"decisionTaskCompletedEventId":{"type":"long"},"control":{}}},"requestCancelExternalWorkflowExecutionFailedEventAttributes":{"type":"structure","required":["workflowId","cause","initiatedEventId","decisionTaskCompletedEventId"],"members":{"workflowId":{},"runId":{},"cause":{},"initiatedEventId":{"type":"long"},"decisionTaskCompletedEventId":{"type":"long"},"control":{}}},"scheduleActivityTaskFailedEventAttributes":{"type":"structure","required":["activityType","activityId","cause","decisionTaskCompletedEventId"],"members":{"activityType":{"shape":"Sn"},"activityId":{},"cause":{},"decisionTaskCompletedEventId":{"type":"long"}}},"requestCancelActivityTaskFailedEventAttributes":{"type":"structure","required":["activityId","cause","decisionTaskCompletedEventId"],"members":{"activityId":{},"cause":{},"decisionTaskCompletedEventId":{"type":"long"}}},"startTimerFailedEventAttributes":{"type":"structure","required":["timerId","cause","decisionTaskCompletedEventId"],"members":{"timerId":{},"cause":{},"decisionTaskCompletedEventId":{"type":"long"}}},"cancelTimerFailedEventAttributes":{"type":"structure","required":["timerId","cause","decisionTaskCompletedEventId"],"members":{"timerId":{},"cause":{},"decisionTaskCompletedEventId":{"type":"long"}}},"startChildWorkflowExecutionFailedEventAttributes":{"type":"structure","required":["workflowType","cause","workflowId","initiatedEventId","decisionTaskCompletedEventId"],"members":{"workflowType":{"shape":"Sr"},"cause":{},"workflowId":{},"initiatedEventId":{"type":"long"},"decisionTaskCompletedEventId":{"type":"long"},"control":{}}},"lambdaFunctionScheduledEventAttributes":{"type":"structure","required":["id","name","decisionTaskCompletedEventId"],"members":{"id":{},"name":{},"control":{},"input":{},"startToCloseTimeout":{},"decisionTaskCompletedEventId":{"type":"long"}}},"lambdaFunctionStartedEventAttributes":{"type":"structure","required":["scheduledEventId"],"members":{"scheduledEventId":{"type":"long"}}},"lambdaFunctionCompletedEventAttributes":{"type":"structure","required":["scheduledEventId","startedEventId"],"members":{"scheduledEventId":{"type":"long"},"startedEventId":{"type":"long"},"result":{}}},"lambdaFunctionFailedEventAttributes":{"type":"structure","required":["scheduledEventId","startedEventId"],"members":{"scheduledEventId":{"type":"long"},"startedEventId":{"type":"long"},"reason":{},"details":{}}},"lambdaFunctionTimedOutEventAttributes":{"type":"structure","required":["scheduledEventId","startedEventId"],"members":{"scheduledEventId":{"type":"long"},"startedEventId":{"type":"long"},"timeoutType":{}}},"scheduleLambdaFunctionFailedEventAttributes":{"type":"structure","required":["id","name","cause","decisionTaskCompletedEventId"],"members":{"id":{},"name":{},"cause":{},"decisionTaskCompletedEventId":{"type":"long"}}},"startLambdaFunctionFailedEventAttributes":{"type":"structure","members":{"scheduledEventId":{"type":"long"},"cause":{},"message":{}}}}}},"S4g":{"type":"structure","required":["executionInfos"],"members":{"executionInfos":{"type":"list","member":{"shape":"S1a"}},"nextPageToken":{}}},"S4o":{"type":"list","member":{"type":"structure","required":["key"],"members":{"key":{},"value":{}}}}}}; +function resolveYamlBinary(data) { + if (data === null) return false; -/***/ }), + var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP; -/***/ 3629: -/***/ (function(module, __unusedexports, __webpack_require__) { + // Convert one by one. + for (idx = 0; idx < max; idx++) { + code = map.indexOf(data.charAt(idx)); -"use strict"; + // Skip CR/LF + if (code > 64) continue; + // Fail on illegal characters + if (code < 0) return false; -var Type = __webpack_require__(4945); + bitlen += 6; + } -function resolveJavascriptRegExp(data) { - if (data === null) return false; - if (data.length === 0) return false; + // If there are any bits left, source was corrupted + return (bitlen % 8) === 0; +} - var regexp = data, - tail = /\/([gim]*)$/.exec(data), - modifiers = ''; +function constructYamlBinary(data) { + var idx, tailbits, + input = data.replace(/[\r\n=]/g, ''), // remove CR/LF & padding to simplify scan + max = input.length, + map = BASE64_MAP, + bits = 0, + result = []; + + // Collect by 6*4 bits (3 bytes) - // if regexp starts with '/' it can have modifiers and must be properly closed - // `/foo/gim` - modifiers tail can be maximum 3 chars - if (regexp[0] === '/') { - if (tail) modifiers = tail[1]; + for (idx = 0; idx < max; idx++) { + if ((idx % 4 === 0) && idx) { + result.push((bits >> 16) & 0xFF); + result.push((bits >> 8) & 0xFF); + result.push(bits & 0xFF); + } - if (modifiers.length > 3) return false; - // if expression starts with /, is should be properly terminated - if (regexp[regexp.length - modifiers.length - 1] !== '/') return false; + bits = (bits << 6) | map.indexOf(input.charAt(idx)); } - return true; -} + // Dump tail -function constructJavascriptRegExp(data) { - var regexp = data, - tail = /\/([gim]*)$/.exec(data), - modifiers = ''; + tailbits = (max % 4) * 6; - // `/foo/gim` - tail can be maximum 4 chars - if (regexp[0] === '/') { - if (tail) modifiers = tail[1]; - regexp = regexp.slice(1, regexp.length - modifiers.length - 1); + if (tailbits === 0) { + result.push((bits >> 16) & 0xFF); + result.push((bits >> 8) & 0xFF); + result.push(bits & 0xFF); + } else if (tailbits === 18) { + result.push((bits >> 10) & 0xFF); + result.push((bits >> 2) & 0xFF); + } else if (tailbits === 12) { + result.push((bits >> 4) & 0xFF); } - return new RegExp(regexp, modifiers); + return new Uint8Array(result); } -function representJavascriptRegExp(object /*, style*/) { - var result = '/' + object.source + '/'; +function representYamlBinary(object /*, style*/) { + var result = '', bits = 0, idx, tail, + max = object.length, + map = BASE64_MAP; + + // Convert every three bytes to 4 ASCII characters. + + for (idx = 0; idx < max; idx++) { + if ((idx % 3 === 0) && idx) { + result += map[(bits >> 18) & 0x3F]; + result += map[(bits >> 12) & 0x3F]; + result += map[(bits >> 6) & 0x3F]; + result += map[bits & 0x3F]; + } + + bits = (bits << 8) + object[idx]; + } + + // Dump tail + + tail = max % 3; - if (object.global) result += 'g'; - if (object.multiline) result += 'm'; - if (object.ignoreCase) result += 'i'; + if (tail === 0) { + result += map[(bits >> 18) & 0x3F]; + result += map[(bits >> 12) & 0x3F]; + result += map[(bits >> 6) & 0x3F]; + result += map[bits & 0x3F]; + } else if (tail === 2) { + result += map[(bits >> 10) & 0x3F]; + result += map[(bits >> 4) & 0x3F]; + result += map[(bits << 2) & 0x3F]; + result += map[64]; + } else if (tail === 1) { + result += map[(bits >> 2) & 0x3F]; + result += map[(bits << 4) & 0x3F]; + result += map[64]; + result += map[64]; + } return result; } -function isRegExp(object) { - return Object.prototype.toString.call(object) === '[object RegExp]'; +function isBinary(obj) { + return Object.prototype.toString.call(obj) === '[object Uint8Array]'; } -module.exports = new Type('tag:yaml.org,2002:js/regexp', { +module.exports = new Type('tag:yaml.org,2002:binary', { kind: 'scalar', - resolve: resolveJavascriptRegExp, - construct: constructJavascriptRegExp, - predicate: isRegExp, - represent: representJavascriptRegExp + resolve: resolveYamlBinary, + construct: constructYamlBinary, + predicate: isBinary, + represent: representYamlBinary }); /***/ }), -/***/ 3642: -/***/ (function(module) { - -module.exports = {"version":"2.0","metadata":{"apiVersion":"2019-05-01","endpointPrefix":"workmailmessageflow","jsonVersion":"1.1","protocol":"rest-json","serviceFullName":"Amazon WorkMail Message Flow","serviceId":"WorkMailMessageFlow","signatureVersion":"v4","uid":"workmailmessageflow-2019-05-01"},"operations":{"GetRawMessageContent":{"http":{"method":"GET","requestUri":"/messages/{messageId}"},"input":{"type":"structure","required":["messageId"],"members":{"messageId":{"location":"uri","locationName":"messageId"}}},"output":{"type":"structure","required":["messageContent"],"members":{"messageContent":{"type":"blob","streaming":true}},"payload":"messageContent"}}},"shapes":{}}; +/***/ 7296: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -/***/ }), +"use strict"; -/***/ 3658: -/***/ (function(module) { -module.exports = {"pagination":{}}; +var Type = __nccwpck_require__(9557); -/***/ }), +function resolveYamlBoolean(data) { + if (data === null) return false; -/***/ 3681: -/***/ (function(module) { + var max = data.length; -module.exports = {"pagination":{"ListJournalKinesisStreamsForLedger":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListJournalS3Exports":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListJournalS3ExportsForLedger":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListLedgers":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"}}}; + return (max === 4 && (data === 'true' || data === 'True' || data === 'TRUE')) || + (max === 5 && (data === 'false' || data === 'False' || data === 'FALSE')); +} -/***/ }), +function constructYamlBoolean(data) { + return data === 'true' || + data === 'True' || + data === 'TRUE'; +} -/***/ 3682: -/***/ (function(module, __unusedexports, __webpack_require__) { +function isBoolean(object) { + return Object.prototype.toString.call(object) === '[object Boolean]'; +} -var Collection = __webpack_require__(1583); +module.exports = new Type('tag:yaml.org,2002:bool', { + kind: 'scalar', + resolve: resolveYamlBoolean, + construct: constructYamlBoolean, + predicate: isBoolean, + represent: { + lowercase: function (object) { return object ? 'true' : 'false'; }, + uppercase: function (object) { return object ? 'TRUE' : 'FALSE'; }, + camelcase: function (object) { return object ? 'True' : 'False'; } + }, + defaultStyle: 'lowercase' +}); -var util = __webpack_require__(153); -function property(obj, name, value) { - if (value !== null && value !== undefined) { - util.property.apply(this, arguments); - } -} +/***/ }), -function memoizedProperty(obj, name) { - if (!obj.constructor.prototype[name]) { - util.memoizedProperty.apply(this, arguments); - } -} +/***/ 7584: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -function Shape(shape, options, memberName) { - options = options || {}; +"use strict"; - property(this, 'shape', shape.shape); - property(this, 'api', options.api, false); - property(this, 'type', shape.type); - property(this, 'enum', shape.enum); - property(this, 'min', shape.min); - property(this, 'max', shape.max); - property(this, 'pattern', shape.pattern); - property(this, 'location', shape.location || this.location || 'body'); - property(this, 'name', this.name || shape.xmlName || shape.queryName || - shape.locationName || memberName); - property(this, 'isStreaming', shape.streaming || this.isStreaming || false); - property(this, 'requiresLength', shape.requiresLength, false); - property(this, 'isComposite', shape.isComposite || false); - property(this, 'isShape', true, false); - property(this, 'isQueryName', Boolean(shape.queryName), false); - property(this, 'isLocationName', Boolean(shape.locationName), false); - property(this, 'isIdempotent', shape.idempotencyToken === true); - property(this, 'isJsonValue', shape.jsonvalue === true); - property(this, 'isSensitive', shape.sensitive === true || shape.prototype && shape.prototype.sensitive === true); - property(this, 'isEventStream', Boolean(shape.eventstream), false); - property(this, 'isEvent', Boolean(shape.event), false); - property(this, 'isEventPayload', Boolean(shape.eventpayload), false); - property(this, 'isEventHeader', Boolean(shape.eventheader), false); - property(this, 'isTimestampFormatSet', Boolean(shape.timestampFormat) || shape.prototype && shape.prototype.isTimestampFormatSet === true, false); - property(this, 'endpointDiscoveryId', Boolean(shape.endpointdiscoveryid), false); - property(this, 'hostLabel', Boolean(shape.hostLabel), false); - - if (options.documentation) { - property(this, 'documentation', shape.documentation); - property(this, 'documentationUrl', shape.documentationUrl); - } - - if (shape.xmlAttribute) { - property(this, 'isXmlAttribute', shape.xmlAttribute || false); - } - - // type conversion and parsing - property(this, 'defaultValue', null); - this.toWireFormat = function(value) { - if (value === null || value === undefined) return ''; - return value; - }; - this.toType = function(value) { return value; }; -} -/** - * @api private - */ -Shape.normalizedTypes = { - character: 'string', - double: 'float', - long: 'integer', - short: 'integer', - biginteger: 'integer', - bigdecimal: 'float', - blob: 'binary' -}; +var common = __nccwpck_require__(9816); +var Type = __nccwpck_require__(9557); -/** - * @api private - */ -Shape.types = { - 'structure': StructureShape, - 'list': ListShape, - 'map': MapShape, - 'boolean': BooleanShape, - 'timestamp': TimestampShape, - 'float': FloatShape, - 'integer': IntegerShape, - 'string': StringShape, - 'base64': Base64Shape, - 'binary': BinaryShape -}; +var YAML_FLOAT_PATTERN = new RegExp( + // 2.5e4, 2.5 and integers + '^(?:[-+]?(?:[0-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?' + + // .2e4, .2 + // special case, seems not from spec + '|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?' + + // .inf + '|[-+]?\\.(?:inf|Inf|INF)' + + // .nan + '|\\.(?:nan|NaN|NAN))$'); -Shape.resolve = function resolve(shape, options) { - if (shape.shape) { - var refShape = options.api.shapes[shape.shape]; - if (!refShape) { - throw new Error('Cannot find shape reference: ' + shape.shape); - } +function resolveYamlFloat(data) { + if (data === null) return false; - return refShape; - } else { - return null; + if (!YAML_FLOAT_PATTERN.test(data) || + // Quick hack to not allow integers end with `_` + // Probably should update regexp & check speed + data[data.length - 1] === '_') { + return false; } -}; -Shape.create = function create(shape, options, memberName) { - if (shape.isShape) return shape; - - var refShape = Shape.resolve(shape, options); - if (refShape) { - var filteredKeys = Object.keys(shape); - if (!options.documentation) { - filteredKeys = filteredKeys.filter(function(name) { - return !name.match(/documentation/); - }); - } + return true; +} - // create an inline shape with extra members - var InlineShape = function() { - refShape.constructor.call(this, shape, options, memberName); - }; - InlineShape.prototype = refShape; - return new InlineShape(); - } else { - // set type if not set - if (!shape.type) { - if (shape.members) shape.type = 'structure'; - else if (shape.member) shape.type = 'list'; - else if (shape.key) shape.type = 'map'; - else shape.type = 'string'; - } +function constructYamlFloat(data) { + var value, sign; - // normalize types - var origType = shape.type; - if (Shape.normalizedTypes[shape.type]) { - shape.type = Shape.normalizedTypes[shape.type]; - } + value = data.replace(/_/g, '').toLowerCase(); + sign = value[0] === '-' ? -1 : 1; - if (Shape.types[shape.type]) { - return new Shape.types[shape.type](shape, options, memberName); - } else { - throw new Error('Unrecognized shape type: ' + origType); - } + if ('+-'.indexOf(value[0]) >= 0) { + value = value.slice(1); } -}; -function CompositeShape(shape) { - Shape.apply(this, arguments); - property(this, 'isComposite', true); + if (value === '.inf') { + return (sign === 1) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY; - if (shape.flattened) { - property(this, 'flattened', shape.flattened || false); + } else if (value === '.nan') { + return NaN; } + return sign * parseFloat(value, 10); } -function StructureShape(shape, options) { - var self = this; - var requiredMap = null, firstInit = !this.isShape; - - CompositeShape.apply(this, arguments); - if (firstInit) { - property(this, 'defaultValue', function() { return {}; }); - property(this, 'members', {}); - property(this, 'memberNames', []); - property(this, 'required', []); - property(this, 'isRequired', function() { return false; }); - } +var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/; - if (shape.members) { - property(this, 'members', new Collection(shape.members, options, function(name, member) { - return Shape.create(member, options, name); - })); - memoizedProperty(this, 'memberNames', function() { - return shape.xmlOrder || Object.keys(shape.members); - }); - - if (shape.event) { - memoizedProperty(this, 'eventPayloadMemberName', function() { - var members = self.members; - var memberNames = self.memberNames; - // iterate over members to find ones that are event payloads - for (var i = 0, iLen = memberNames.length; i < iLen; i++) { - if (members[memberNames[i]].isEventPayload) { - return memberNames[i]; - } - } - }); +function representYamlFloat(object, style) { + var res; - memoizedProperty(this, 'eventHeaderMemberNames', function() { - var members = self.members; - var memberNames = self.memberNames; - var eventHeaderMemberNames = []; - // iterate over members to find ones that are event headers - for (var i = 0, iLen = memberNames.length; i < iLen; i++) { - if (members[memberNames[i]].isEventHeader) { - eventHeaderMemberNames.push(memberNames[i]); - } - } - return eventHeaderMemberNames; - }); + if (isNaN(object)) { + switch (style) { + case 'lowercase': return '.nan'; + case 'uppercase': return '.NAN'; + case 'camelcase': return '.NaN'; + } + } else if (Number.POSITIVE_INFINITY === object) { + switch (style) { + case 'lowercase': return '.inf'; + case 'uppercase': return '.INF'; + case 'camelcase': return '.Inf'; + } + } else if (Number.NEGATIVE_INFINITY === object) { + switch (style) { + case 'lowercase': return '-.inf'; + case 'uppercase': return '-.INF'; + case 'camelcase': return '-.Inf'; } + } else if (common.isNegativeZero(object)) { + return '-0.0'; } - if (shape.required) { - property(this, 'required', shape.required); - property(this, 'isRequired', function(name) { - if (!requiredMap) { - requiredMap = {}; - for (var i = 0; i < shape.required.length; i++) { - requiredMap[shape.required[i]] = true; - } - } - - return requiredMap[name]; - }, false, true); - } + res = object.toString(10); - property(this, 'resultWrapper', shape.resultWrapper || null); + // JS stringifier can build scientific format without dots: 5e-100, + // while YAML requres dot: 5.e-100. Fix it with simple hack - if (shape.payload) { - property(this, 'payload', shape.payload); - } + return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace('e', '.e') : res; +} - if (typeof shape.xmlNamespace === 'string') { - property(this, 'xmlNamespaceUri', shape.xmlNamespace); - } else if (typeof shape.xmlNamespace === 'object') { - property(this, 'xmlNamespacePrefix', shape.xmlNamespace.prefix); - property(this, 'xmlNamespaceUri', shape.xmlNamespace.uri); - } +function isFloat(object) { + return (Object.prototype.toString.call(object) === '[object Number]') && + (object % 1 !== 0 || common.isNegativeZero(object)); } -function ListShape(shape, options) { - var self = this, firstInit = !this.isShape; - CompositeShape.apply(this, arguments); +module.exports = new Type('tag:yaml.org,2002:float', { + kind: 'scalar', + resolve: resolveYamlFloat, + construct: constructYamlFloat, + predicate: isFloat, + represent: representYamlFloat, + defaultStyle: 'lowercase' +}); - if (firstInit) { - property(this, 'defaultValue', function() { return []; }); - } - if (shape.member) { - memoizedProperty(this, 'member', function() { - return Shape.create(shape.member, options); - }); - } +/***/ }), - if (this.flattened) { - var oldName = this.name; - memoizedProperty(this, 'name', function() { - return self.member.name || oldName; - }); - } -} +/***/ 2271: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -function MapShape(shape, options) { - var firstInit = !this.isShape; - CompositeShape.apply(this, arguments); - - if (firstInit) { - property(this, 'defaultValue', function() { return {}; }); - property(this, 'key', Shape.create({type: 'string'}, options)); - property(this, 'value', Shape.create({type: 'string'}, options)); - } +"use strict"; - if (shape.key) { - memoizedProperty(this, 'key', function() { - return Shape.create(shape.key, options); - }); - } - if (shape.value) { - memoizedProperty(this, 'value', function() { - return Shape.create(shape.value, options); - }); - } -} -function TimestampShape(shape) { - var self = this; - Shape.apply(this, arguments); - - if (shape.timestampFormat) { - property(this, 'timestampFormat', shape.timestampFormat); - } else if (self.isTimestampFormatSet && this.timestampFormat) { - property(this, 'timestampFormat', this.timestampFormat); - } else if (this.location === 'header') { - property(this, 'timestampFormat', 'rfc822'); - } else if (this.location === 'querystring') { - property(this, 'timestampFormat', 'iso8601'); - } else if (this.api) { - switch (this.api.protocol) { - case 'json': - case 'rest-json': - property(this, 'timestampFormat', 'unixTimestamp'); - break; - case 'rest-xml': - case 'query': - case 'ec2': - property(this, 'timestampFormat', 'iso8601'); - break; - } - } +var common = __nccwpck_require__(9816); +var Type = __nccwpck_require__(9557); - this.toType = function(value) { - if (value === null || value === undefined) return null; - if (typeof value.toUTCString === 'function') return value; - return typeof value === 'string' || typeof value === 'number' ? - util.date.parseTimestamp(value) : null; - }; +function isHexCode(c) { + return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) || + ((0x41/* A */ <= c) && (c <= 0x46/* F */)) || + ((0x61/* a */ <= c) && (c <= 0x66/* f */)); +} - this.toWireFormat = function(value) { - return util.date.format(value, self.timestampFormat); - }; +function isOctCode(c) { + return ((0x30/* 0 */ <= c) && (c <= 0x37/* 7 */)); } -function StringShape() { - Shape.apply(this, arguments); +function isDecCode(c) { + return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)); +} - var nullLessProtocols = ['rest-xml', 'query', 'ec2']; - this.toType = function(value) { - value = this.api && nullLessProtocols.indexOf(this.api.protocol) > -1 ? - value || '' : value; - if (this.isJsonValue) { - return JSON.parse(value); - } +function resolveYamlInteger(data) { + if (data === null) return false; - return value && typeof value.toString === 'function' ? - value.toString() : value; - }; + var max = data.length, + index = 0, + hasDigits = false, + ch; - this.toWireFormat = function(value) { - return this.isJsonValue ? JSON.stringify(value) : value; - }; -} + if (!max) return false; -function FloatShape() { - Shape.apply(this, arguments); + ch = data[index]; - this.toType = function(value) { - if (value === null || value === undefined) return null; - return parseFloat(value); - }; - this.toWireFormat = this.toType; -} + // sign + if (ch === '-' || ch === '+') { + ch = data[++index]; + } -function IntegerShape() { - Shape.apply(this, arguments); + if (ch === '0') { + // 0 + if (index + 1 === max) return true; + ch = data[++index]; - this.toType = function(value) { - if (value === null || value === undefined) return null; - return parseInt(value, 10); - }; - this.toWireFormat = this.toType; -} - -function BinaryShape() { - Shape.apply(this, arguments); - this.toType = function(value) { - var buf = util.base64.decode(value); - if (this.isSensitive && util.isNode() && typeof util.Buffer.alloc === 'function') { - /* Node.js can create a Buffer that is not isolated. - * i.e. buf.byteLength !== buf.buffer.byteLength - * This means that the sensitive data is accessible to anyone with access to buf.buffer. - * If this is the node shared Buffer, then other code within this process _could_ find this secret. - * Copy sensitive data to an isolated Buffer and zero the sensitive data. - * While this is safe to do here, copying this code somewhere else may produce unexpected results. - */ - var secureBuf = util.Buffer.alloc(buf.length, buf); - buf.fill(0); - buf = secureBuf; - } - return buf; - }; - this.toWireFormat = util.base64.encode; -} + // base 2, base 8, base 16 -function Base64Shape() { - BinaryShape.apply(this, arguments); -} + if (ch === 'b') { + // base 2 + index++; -function BooleanShape() { - Shape.apply(this, arguments); + for (; index < max; index++) { + ch = data[index]; + if (ch === '_') continue; + if (ch !== '0' && ch !== '1') return false; + hasDigits = true; + } + return hasDigits && ch !== '_'; + } - this.toType = function(value) { - if (typeof value === 'boolean') return value; - if (value === null || value === undefined) return null; - return value === 'true'; - }; -} -/** - * @api private - */ -Shape.shapes = { - StructureShape: StructureShape, - ListShape: ListShape, - MapShape: MapShape, - StringShape: StringShape, - BooleanShape: BooleanShape, - Base64Shape: Base64Shape -}; + if (ch === 'x') { + // base 16 + index++; -/** - * @api private - */ -module.exports = Shape; + for (; index < max; index++) { + ch = data[index]; + if (ch === '_') continue; + if (!isHexCode(data.charCodeAt(index))) return false; + hasDigits = true; + } + return hasDigits && ch !== '_'; + } -/***/ }), + if (ch === 'o') { + // base 8 + index++; -/***/ 3691: -/***/ (function(module) { + for (; index < max; index++) { + ch = data[index]; + if (ch === '_') continue; + if (!isOctCode(data.charCodeAt(index))) return false; + hasDigits = true; + } + return hasDigits && ch !== '_'; + } + } -module.exports = {"metadata":{"apiVersion":"2009-04-15","endpointPrefix":"sdb","serviceFullName":"Amazon SimpleDB","serviceId":"SimpleDB","signatureVersion":"v2","xmlNamespace":"http://sdb.amazonaws.com/doc/2009-04-15/","protocol":"query"},"operations":{"BatchDeleteAttributes":{"input":{"type":"structure","required":["DomainName","Items"],"members":{"DomainName":{},"Items":{"type":"list","member":{"locationName":"Item","type":"structure","required":["Name"],"members":{"Name":{"locationName":"ItemName"},"Attributes":{"shape":"S5"}}},"flattened":true}}}},"BatchPutAttributes":{"input":{"type":"structure","required":["DomainName","Items"],"members":{"DomainName":{},"Items":{"type":"list","member":{"locationName":"Item","type":"structure","required":["Name","Attributes"],"members":{"Name":{"locationName":"ItemName"},"Attributes":{"shape":"Sa"}}},"flattened":true}}}},"CreateDomain":{"input":{"type":"structure","required":["DomainName"],"members":{"DomainName":{}}}},"DeleteAttributes":{"input":{"type":"structure","required":["DomainName","ItemName"],"members":{"DomainName":{},"ItemName":{},"Attributes":{"shape":"S5"},"Expected":{"shape":"Sf"}}}},"DeleteDomain":{"input":{"type":"structure","required":["DomainName"],"members":{"DomainName":{}}}},"DomainMetadata":{"input":{"type":"structure","required":["DomainName"],"members":{"DomainName":{}}},"output":{"resultWrapper":"DomainMetadataResult","type":"structure","members":{"ItemCount":{"type":"integer"},"ItemNamesSizeBytes":{"type":"long"},"AttributeNameCount":{"type":"integer"},"AttributeNamesSizeBytes":{"type":"long"},"AttributeValueCount":{"type":"integer"},"AttributeValuesSizeBytes":{"type":"long"},"Timestamp":{"type":"integer"}}}},"GetAttributes":{"input":{"type":"structure","required":["DomainName","ItemName"],"members":{"DomainName":{},"ItemName":{},"AttributeNames":{"type":"list","member":{"locationName":"AttributeName"},"flattened":true},"ConsistentRead":{"type":"boolean"}}},"output":{"resultWrapper":"GetAttributesResult","type":"structure","members":{"Attributes":{"shape":"So"}}}},"ListDomains":{"input":{"type":"structure","members":{"MaxNumberOfDomains":{"type":"integer"},"NextToken":{}}},"output":{"resultWrapper":"ListDomainsResult","type":"structure","members":{"DomainNames":{"type":"list","member":{"locationName":"DomainName"},"flattened":true},"NextToken":{}}}},"PutAttributes":{"input":{"type":"structure","required":["DomainName","ItemName","Attributes"],"members":{"DomainName":{},"ItemName":{},"Attributes":{"shape":"Sa"},"Expected":{"shape":"Sf"}}}},"Select":{"input":{"type":"structure","required":["SelectExpression"],"members":{"SelectExpression":{},"NextToken":{},"ConsistentRead":{"type":"boolean"}}},"output":{"resultWrapper":"SelectResult","type":"structure","members":{"Items":{"type":"list","member":{"locationName":"Item","type":"structure","required":["Name","Attributes"],"members":{"Name":{},"AlternateNameEncoding":{},"Attributes":{"shape":"So"}}},"flattened":true},"NextToken":{}}}}},"shapes":{"S5":{"type":"list","member":{"locationName":"Attribute","type":"structure","required":["Name"],"members":{"Name":{},"Value":{}}},"flattened":true},"Sa":{"type":"list","member":{"locationName":"Attribute","type":"structure","required":["Name","Value"],"members":{"Name":{},"Value":{},"Replace":{"type":"boolean"}}},"flattened":true},"Sf":{"type":"structure","members":{"Name":{},"Value":{},"Exists":{"type":"boolean"}}},"So":{"type":"list","member":{"locationName":"Attribute","type":"structure","required":["Name","Value"],"members":{"Name":{},"AlternateNameEncoding":{},"Value":{},"AlternateValueEncoding":{}}},"flattened":true}}}; + // base 10 (except 0) -/***/ }), + // value should not start with `_`; + if (ch === '_') return false; -/***/ 3693: -/***/ (function(module) { + for (; index < max; index++) { + ch = data[index]; + if (ch === '_') continue; + if (!isDecCode(data.charCodeAt(index))) { + return false; + } + hasDigits = true; + } -module.exports = {"version":"2.0","metadata":{"apiVersion":"2011-01-01","endpointPrefix":"autoscaling","protocol":"query","serviceFullName":"Auto Scaling","serviceId":"Auto Scaling","signatureVersion":"v4","uid":"autoscaling-2011-01-01","xmlNamespace":"http://autoscaling.amazonaws.com/doc/2011-01-01/"},"operations":{"AttachInstances":{"input":{"type":"structure","required":["AutoScalingGroupName"],"members":{"InstanceIds":{"shape":"S2"},"AutoScalingGroupName":{}}}},"AttachLoadBalancerTargetGroups":{"input":{"type":"structure","required":["AutoScalingGroupName","TargetGroupARNs"],"members":{"AutoScalingGroupName":{},"TargetGroupARNs":{"shape":"S6"}}},"output":{"resultWrapper":"AttachLoadBalancerTargetGroupsResult","type":"structure","members":{}}},"AttachLoadBalancers":{"input":{"type":"structure","required":["AutoScalingGroupName","LoadBalancerNames"],"members":{"AutoScalingGroupName":{},"LoadBalancerNames":{"shape":"Sa"}}},"output":{"resultWrapper":"AttachLoadBalancersResult","type":"structure","members":{}}},"BatchDeleteScheduledAction":{"input":{"type":"structure","required":["AutoScalingGroupName","ScheduledActionNames"],"members":{"AutoScalingGroupName":{},"ScheduledActionNames":{"shape":"Se"}}},"output":{"resultWrapper":"BatchDeleteScheduledActionResult","type":"structure","members":{"FailedScheduledActions":{"shape":"Sg"}}}},"BatchPutScheduledUpdateGroupAction":{"input":{"type":"structure","required":["AutoScalingGroupName","ScheduledUpdateGroupActions"],"members":{"AutoScalingGroupName":{},"ScheduledUpdateGroupActions":{"type":"list","member":{"type":"structure","required":["ScheduledActionName"],"members":{"ScheduledActionName":{},"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"Recurrence":{},"MinSize":{"type":"integer"},"MaxSize":{"type":"integer"},"DesiredCapacity":{"type":"integer"}}}}}},"output":{"resultWrapper":"BatchPutScheduledUpdateGroupActionResult","type":"structure","members":{"FailedScheduledUpdateGroupActions":{"shape":"Sg"}}}},"CancelInstanceRefresh":{"input":{"type":"structure","required":["AutoScalingGroupName"],"members":{"AutoScalingGroupName":{}}},"output":{"resultWrapper":"CancelInstanceRefreshResult","type":"structure","members":{"InstanceRefreshId":{}}}},"CompleteLifecycleAction":{"input":{"type":"structure","required":["LifecycleHookName","AutoScalingGroupName","LifecycleActionResult"],"members":{"LifecycleHookName":{},"AutoScalingGroupName":{},"LifecycleActionToken":{},"LifecycleActionResult":{},"InstanceId":{}}},"output":{"resultWrapper":"CompleteLifecycleActionResult","type":"structure","members":{}}},"CreateAutoScalingGroup":{"input":{"type":"structure","required":["AutoScalingGroupName","MinSize","MaxSize"],"members":{"AutoScalingGroupName":{},"LaunchConfigurationName":{},"LaunchTemplate":{"shape":"S10"},"MixedInstancesPolicy":{"shape":"S12"},"InstanceId":{},"MinSize":{"type":"integer"},"MaxSize":{"type":"integer"},"DesiredCapacity":{"type":"integer"},"DefaultCooldown":{"type":"integer"},"AvailabilityZones":{"shape":"S1d"},"LoadBalancerNames":{"shape":"Sa"},"TargetGroupARNs":{"shape":"S6"},"HealthCheckType":{},"HealthCheckGracePeriod":{"type":"integer"},"PlacementGroup":{},"VPCZoneIdentifier":{},"TerminationPolicies":{"shape":"S1g"},"NewInstancesProtectedFromScaleIn":{"type":"boolean"},"LifecycleHookSpecificationList":{"type":"list","member":{"type":"structure","required":["LifecycleHookName","LifecycleTransition"],"members":{"LifecycleHookName":{},"LifecycleTransition":{},"NotificationMetadata":{},"HeartbeatTimeout":{"type":"integer"},"DefaultResult":{},"NotificationTargetARN":{},"RoleARN":{}}}},"Tags":{"shape":"S1p"},"ServiceLinkedRoleARN":{},"MaxInstanceLifetime":{"type":"integer"}}}},"CreateLaunchConfiguration":{"input":{"type":"structure","required":["LaunchConfigurationName"],"members":{"LaunchConfigurationName":{},"ImageId":{},"KeyName":{},"SecurityGroups":{"shape":"S1w"},"ClassicLinkVPCId":{},"ClassicLinkVPCSecurityGroups":{"shape":"S1x"},"UserData":{},"InstanceId":{},"InstanceType":{},"KernelId":{},"RamdiskId":{},"BlockDeviceMappings":{"shape":"S1z"},"InstanceMonitoring":{"shape":"S28"},"SpotPrice":{},"IamInstanceProfile":{},"EbsOptimized":{"type":"boolean"},"AssociatePublicIpAddress":{"type":"boolean"},"PlacementTenancy":{},"MetadataOptions":{"shape":"S2d"}}}},"CreateOrUpdateTags":{"input":{"type":"structure","required":["Tags"],"members":{"Tags":{"shape":"S1p"}}}},"DeleteAutoScalingGroup":{"input":{"type":"structure","required":["AutoScalingGroupName"],"members":{"AutoScalingGroupName":{},"ForceDelete":{"type":"boolean"}}}},"DeleteLaunchConfiguration":{"input":{"type":"structure","required":["LaunchConfigurationName"],"members":{"LaunchConfigurationName":{}}}},"DeleteLifecycleHook":{"input":{"type":"structure","required":["LifecycleHookName","AutoScalingGroupName"],"members":{"LifecycleHookName":{},"AutoScalingGroupName":{}}},"output":{"resultWrapper":"DeleteLifecycleHookResult","type":"structure","members":{}}},"DeleteNotificationConfiguration":{"input":{"type":"structure","required":["AutoScalingGroupName","TopicARN"],"members":{"AutoScalingGroupName":{},"TopicARN":{}}}},"DeletePolicy":{"input":{"type":"structure","required":["PolicyName"],"members":{"AutoScalingGroupName":{},"PolicyName":{}}}},"DeleteScheduledAction":{"input":{"type":"structure","required":["AutoScalingGroupName","ScheduledActionName"],"members":{"AutoScalingGroupName":{},"ScheduledActionName":{}}}},"DeleteTags":{"input":{"type":"structure","required":["Tags"],"members":{"Tags":{"shape":"S1p"}}}},"DescribeAccountLimits":{"output":{"resultWrapper":"DescribeAccountLimitsResult","type":"structure","members":{"MaxNumberOfAutoScalingGroups":{"type":"integer"},"MaxNumberOfLaunchConfigurations":{"type":"integer"},"NumberOfAutoScalingGroups":{"type":"integer"},"NumberOfLaunchConfigurations":{"type":"integer"}}}},"DescribeAdjustmentTypes":{"output":{"resultWrapper":"DescribeAdjustmentTypesResult","type":"structure","members":{"AdjustmentTypes":{"type":"list","member":{"type":"structure","members":{"AdjustmentType":{}}}}}}},"DescribeAutoScalingGroups":{"input":{"type":"structure","members":{"AutoScalingGroupNames":{"shape":"S30"},"NextToken":{},"MaxRecords":{"type":"integer"}}},"output":{"resultWrapper":"DescribeAutoScalingGroupsResult","type":"structure","required":["AutoScalingGroups"],"members":{"AutoScalingGroups":{"type":"list","member":{"type":"structure","required":["AutoScalingGroupName","MinSize","MaxSize","DesiredCapacity","DefaultCooldown","AvailabilityZones","HealthCheckType","CreatedTime"],"members":{"AutoScalingGroupName":{},"AutoScalingGroupARN":{},"LaunchConfigurationName":{},"LaunchTemplate":{"shape":"S10"},"MixedInstancesPolicy":{"shape":"S12"},"MinSize":{"type":"integer"},"MaxSize":{"type":"integer"},"DesiredCapacity":{"type":"integer"},"DefaultCooldown":{"type":"integer"},"AvailabilityZones":{"shape":"S1d"},"LoadBalancerNames":{"shape":"Sa"},"TargetGroupARNs":{"shape":"S6"},"HealthCheckType":{},"HealthCheckGracePeriod":{"type":"integer"},"Instances":{"type":"list","member":{"type":"structure","required":["InstanceId","AvailabilityZone","LifecycleState","HealthStatus","ProtectedFromScaleIn"],"members":{"InstanceId":{},"InstanceType":{},"AvailabilityZone":{},"LifecycleState":{},"HealthStatus":{},"LaunchConfigurationName":{},"LaunchTemplate":{"shape":"S10"},"ProtectedFromScaleIn":{"type":"boolean"},"WeightedCapacity":{}}}},"CreatedTime":{"type":"timestamp"},"SuspendedProcesses":{"type":"list","member":{"type":"structure","members":{"ProcessName":{},"SuspensionReason":{}}}},"PlacementGroup":{},"VPCZoneIdentifier":{},"EnabledMetrics":{"type":"list","member":{"type":"structure","members":{"Metric":{},"Granularity":{}}}},"Status":{},"Tags":{"shape":"S3c"},"TerminationPolicies":{"shape":"S1g"},"NewInstancesProtectedFromScaleIn":{"type":"boolean"},"ServiceLinkedRoleARN":{},"MaxInstanceLifetime":{"type":"integer"}}}},"NextToken":{}}}},"DescribeAutoScalingInstances":{"input":{"type":"structure","members":{"InstanceIds":{"shape":"S2"},"MaxRecords":{"type":"integer"},"NextToken":{}}},"output":{"resultWrapper":"DescribeAutoScalingInstancesResult","type":"structure","members":{"AutoScalingInstances":{"type":"list","member":{"type":"structure","required":["InstanceId","AutoScalingGroupName","AvailabilityZone","LifecycleState","HealthStatus","ProtectedFromScaleIn"],"members":{"InstanceId":{},"InstanceType":{},"AutoScalingGroupName":{},"AvailabilityZone":{},"LifecycleState":{},"HealthStatus":{},"LaunchConfigurationName":{},"LaunchTemplate":{"shape":"S10"},"ProtectedFromScaleIn":{"type":"boolean"},"WeightedCapacity":{}}}},"NextToken":{}}}},"DescribeAutoScalingNotificationTypes":{"output":{"resultWrapper":"DescribeAutoScalingNotificationTypesResult","type":"structure","members":{"AutoScalingNotificationTypes":{"shape":"S3j"}}}},"DescribeInstanceRefreshes":{"input":{"type":"structure","required":["AutoScalingGroupName"],"members":{"AutoScalingGroupName":{},"InstanceRefreshIds":{"type":"list","member":{}},"NextToken":{},"MaxRecords":{"type":"integer"}}},"output":{"resultWrapper":"DescribeInstanceRefreshesResult","type":"structure","members":{"InstanceRefreshes":{"type":"list","member":{"type":"structure","members":{"InstanceRefreshId":{},"AutoScalingGroupName":{},"Status":{},"StatusReason":{},"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"PercentageComplete":{"type":"integer"},"InstancesToUpdate":{"type":"integer"}}}},"NextToken":{}}}},"DescribeLaunchConfigurations":{"input":{"type":"structure","members":{"LaunchConfigurationNames":{"type":"list","member":{}},"NextToken":{},"MaxRecords":{"type":"integer"}}},"output":{"resultWrapper":"DescribeLaunchConfigurationsResult","type":"structure","required":["LaunchConfigurations"],"members":{"LaunchConfigurations":{"type":"list","member":{"type":"structure","required":["LaunchConfigurationName","ImageId","InstanceType","CreatedTime"],"members":{"LaunchConfigurationName":{},"LaunchConfigurationARN":{},"ImageId":{},"KeyName":{},"SecurityGroups":{"shape":"S1w"},"ClassicLinkVPCId":{},"ClassicLinkVPCSecurityGroups":{"shape":"S1x"},"UserData":{},"InstanceType":{},"KernelId":{},"RamdiskId":{},"BlockDeviceMappings":{"shape":"S1z"},"InstanceMonitoring":{"shape":"S28"},"SpotPrice":{},"IamInstanceProfile":{},"CreatedTime":{"type":"timestamp"},"EbsOptimized":{"type":"boolean"},"AssociatePublicIpAddress":{"type":"boolean"},"PlacementTenancy":{},"MetadataOptions":{"shape":"S2d"}}}},"NextToken":{}}}},"DescribeLifecycleHookTypes":{"output":{"resultWrapper":"DescribeLifecycleHookTypesResult","type":"structure","members":{"LifecycleHookTypes":{"shape":"S3j"}}}},"DescribeLifecycleHooks":{"input":{"type":"structure","required":["AutoScalingGroupName"],"members":{"AutoScalingGroupName":{},"LifecycleHookNames":{"type":"list","member":{}}}},"output":{"resultWrapper":"DescribeLifecycleHooksResult","type":"structure","members":{"LifecycleHooks":{"type":"list","member":{"type":"structure","members":{"LifecycleHookName":{},"AutoScalingGroupName":{},"LifecycleTransition":{},"NotificationTargetARN":{},"RoleARN":{},"NotificationMetadata":{},"HeartbeatTimeout":{"type":"integer"},"GlobalTimeout":{"type":"integer"},"DefaultResult":{}}}}}}},"DescribeLoadBalancerTargetGroups":{"input":{"type":"structure","required":["AutoScalingGroupName"],"members":{"AutoScalingGroupName":{},"NextToken":{},"MaxRecords":{"type":"integer"}}},"output":{"resultWrapper":"DescribeLoadBalancerTargetGroupsResult","type":"structure","members":{"LoadBalancerTargetGroups":{"type":"list","member":{"type":"structure","members":{"LoadBalancerTargetGroupARN":{},"State":{}}}},"NextToken":{}}}},"DescribeLoadBalancers":{"input":{"type":"structure","required":["AutoScalingGroupName"],"members":{"AutoScalingGroupName":{},"NextToken":{},"MaxRecords":{"type":"integer"}}},"output":{"resultWrapper":"DescribeLoadBalancersResult","type":"structure","members":{"LoadBalancers":{"type":"list","member":{"type":"structure","members":{"LoadBalancerName":{},"State":{}}}},"NextToken":{}}}},"DescribeMetricCollectionTypes":{"output":{"resultWrapper":"DescribeMetricCollectionTypesResult","type":"structure","members":{"Metrics":{"type":"list","member":{"type":"structure","members":{"Metric":{}}}},"Granularities":{"type":"list","member":{"type":"structure","members":{"Granularity":{}}}}}}},"DescribeNotificationConfigurations":{"input":{"type":"structure","members":{"AutoScalingGroupNames":{"shape":"S30"},"NextToken":{},"MaxRecords":{"type":"integer"}}},"output":{"resultWrapper":"DescribeNotificationConfigurationsResult","type":"structure","required":["NotificationConfigurations"],"members":{"NotificationConfigurations":{"type":"list","member":{"type":"structure","members":{"AutoScalingGroupName":{},"TopicARN":{},"NotificationType":{}}}},"NextToken":{}}}},"DescribePolicies":{"input":{"type":"structure","members":{"AutoScalingGroupName":{},"PolicyNames":{"type":"list","member":{}},"PolicyTypes":{"type":"list","member":{}},"NextToken":{},"MaxRecords":{"type":"integer"}}},"output":{"resultWrapper":"DescribePoliciesResult","type":"structure","members":{"ScalingPolicies":{"type":"list","member":{"type":"structure","members":{"AutoScalingGroupName":{},"PolicyName":{},"PolicyARN":{},"PolicyType":{},"AdjustmentType":{},"MinAdjustmentStep":{"shape":"S4r"},"MinAdjustmentMagnitude":{"type":"integer"},"ScalingAdjustment":{"type":"integer"},"Cooldown":{"type":"integer"},"StepAdjustments":{"shape":"S4u"},"MetricAggregationType":{},"EstimatedInstanceWarmup":{"type":"integer"},"Alarms":{"shape":"S4y"},"TargetTrackingConfiguration":{"shape":"S50"},"Enabled":{"type":"boolean"}}}},"NextToken":{}}}},"DescribeScalingActivities":{"input":{"type":"structure","members":{"ActivityIds":{"type":"list","member":{}},"AutoScalingGroupName":{},"MaxRecords":{"type":"integer"},"NextToken":{}}},"output":{"resultWrapper":"DescribeScalingActivitiesResult","type":"structure","required":["Activities"],"members":{"Activities":{"shape":"S5h"},"NextToken":{}}}},"DescribeScalingProcessTypes":{"output":{"resultWrapper":"DescribeScalingProcessTypesResult","type":"structure","members":{"Processes":{"type":"list","member":{"type":"structure","required":["ProcessName"],"members":{"ProcessName":{}}}}}}},"DescribeScheduledActions":{"input":{"type":"structure","members":{"AutoScalingGroupName":{},"ScheduledActionNames":{"shape":"Se"},"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"NextToken":{},"MaxRecords":{"type":"integer"}}},"output":{"resultWrapper":"DescribeScheduledActionsResult","type":"structure","members":{"ScheduledUpdateGroupActions":{"type":"list","member":{"type":"structure","members":{"AutoScalingGroupName":{},"ScheduledActionName":{},"ScheduledActionARN":{},"Time":{"type":"timestamp"},"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"Recurrence":{},"MinSize":{"type":"integer"},"MaxSize":{"type":"integer"},"DesiredCapacity":{"type":"integer"}}}},"NextToken":{}}}},"DescribeTags":{"input":{"type":"structure","members":{"Filters":{"type":"list","member":{"type":"structure","members":{"Name":{},"Values":{"type":"list","member":{}}}}},"NextToken":{},"MaxRecords":{"type":"integer"}}},"output":{"resultWrapper":"DescribeTagsResult","type":"structure","members":{"Tags":{"shape":"S3c"},"NextToken":{}}}},"DescribeTerminationPolicyTypes":{"output":{"resultWrapper":"DescribeTerminationPolicyTypesResult","type":"structure","members":{"TerminationPolicyTypes":{"shape":"S1g"}}}},"DetachInstances":{"input":{"type":"structure","required":["AutoScalingGroupName","ShouldDecrementDesiredCapacity"],"members":{"InstanceIds":{"shape":"S2"},"AutoScalingGroupName":{},"ShouldDecrementDesiredCapacity":{"type":"boolean"}}},"output":{"resultWrapper":"DetachInstancesResult","type":"structure","members":{"Activities":{"shape":"S5h"}}}},"DetachLoadBalancerTargetGroups":{"input":{"type":"structure","required":["AutoScalingGroupName","TargetGroupARNs"],"members":{"AutoScalingGroupName":{},"TargetGroupARNs":{"shape":"S6"}}},"output":{"resultWrapper":"DetachLoadBalancerTargetGroupsResult","type":"structure","members":{}}},"DetachLoadBalancers":{"input":{"type":"structure","required":["AutoScalingGroupName","LoadBalancerNames"],"members":{"AutoScalingGroupName":{},"LoadBalancerNames":{"shape":"Sa"}}},"output":{"resultWrapper":"DetachLoadBalancersResult","type":"structure","members":{}}},"DisableMetricsCollection":{"input":{"type":"structure","required":["AutoScalingGroupName"],"members":{"AutoScalingGroupName":{},"Metrics":{"shape":"S66"}}}},"EnableMetricsCollection":{"input":{"type":"structure","required":["AutoScalingGroupName","Granularity"],"members":{"AutoScalingGroupName":{},"Metrics":{"shape":"S66"},"Granularity":{}}}},"EnterStandby":{"input":{"type":"structure","required":["AutoScalingGroupName","ShouldDecrementDesiredCapacity"],"members":{"InstanceIds":{"shape":"S2"},"AutoScalingGroupName":{},"ShouldDecrementDesiredCapacity":{"type":"boolean"}}},"output":{"resultWrapper":"EnterStandbyResult","type":"structure","members":{"Activities":{"shape":"S5h"}}}},"ExecutePolicy":{"input":{"type":"structure","required":["PolicyName"],"members":{"AutoScalingGroupName":{},"PolicyName":{},"HonorCooldown":{"type":"boolean"},"MetricValue":{"type":"double"},"BreachThreshold":{"type":"double"}}}},"ExitStandby":{"input":{"type":"structure","required":["AutoScalingGroupName"],"members":{"InstanceIds":{"shape":"S2"},"AutoScalingGroupName":{}}},"output":{"resultWrapper":"ExitStandbyResult","type":"structure","members":{"Activities":{"shape":"S5h"}}}},"PutLifecycleHook":{"input":{"type":"structure","required":["LifecycleHookName","AutoScalingGroupName"],"members":{"LifecycleHookName":{},"AutoScalingGroupName":{},"LifecycleTransition":{},"RoleARN":{},"NotificationTargetARN":{},"NotificationMetadata":{},"HeartbeatTimeout":{"type":"integer"},"DefaultResult":{}}},"output":{"resultWrapper":"PutLifecycleHookResult","type":"structure","members":{}}},"PutNotificationConfiguration":{"input":{"type":"structure","required":["AutoScalingGroupName","TopicARN","NotificationTypes"],"members":{"AutoScalingGroupName":{},"TopicARN":{},"NotificationTypes":{"shape":"S3j"}}}},"PutScalingPolicy":{"input":{"type":"structure","required":["AutoScalingGroupName","PolicyName"],"members":{"AutoScalingGroupName":{},"PolicyName":{},"PolicyType":{},"AdjustmentType":{},"MinAdjustmentStep":{"shape":"S4r"},"MinAdjustmentMagnitude":{"type":"integer"},"ScalingAdjustment":{"type":"integer"},"Cooldown":{"type":"integer"},"MetricAggregationType":{},"StepAdjustments":{"shape":"S4u"},"EstimatedInstanceWarmup":{"type":"integer"},"TargetTrackingConfiguration":{"shape":"S50"},"Enabled":{"type":"boolean"}}},"output":{"resultWrapper":"PutScalingPolicyResult","type":"structure","members":{"PolicyARN":{},"Alarms":{"shape":"S4y"}}}},"PutScheduledUpdateGroupAction":{"input":{"type":"structure","required":["AutoScalingGroupName","ScheduledActionName"],"members":{"AutoScalingGroupName":{},"ScheduledActionName":{},"Time":{"type":"timestamp"},"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"Recurrence":{},"MinSize":{"type":"integer"},"MaxSize":{"type":"integer"},"DesiredCapacity":{"type":"integer"}}}},"RecordLifecycleActionHeartbeat":{"input":{"type":"structure","required":["LifecycleHookName","AutoScalingGroupName"],"members":{"LifecycleHookName":{},"AutoScalingGroupName":{},"LifecycleActionToken":{},"InstanceId":{}}},"output":{"resultWrapper":"RecordLifecycleActionHeartbeatResult","type":"structure","members":{}}},"ResumeProcesses":{"input":{"shape":"S6m"}},"SetDesiredCapacity":{"input":{"type":"structure","required":["AutoScalingGroupName","DesiredCapacity"],"members":{"AutoScalingGroupName":{},"DesiredCapacity":{"type":"integer"},"HonorCooldown":{"type":"boolean"}}}},"SetInstanceHealth":{"input":{"type":"structure","required":["InstanceId","HealthStatus"],"members":{"InstanceId":{},"HealthStatus":{},"ShouldRespectGracePeriod":{"type":"boolean"}}}},"SetInstanceProtection":{"input":{"type":"structure","required":["InstanceIds","AutoScalingGroupName","ProtectedFromScaleIn"],"members":{"InstanceIds":{"shape":"S2"},"AutoScalingGroupName":{},"ProtectedFromScaleIn":{"type":"boolean"}}},"output":{"resultWrapper":"SetInstanceProtectionResult","type":"structure","members":{}}},"StartInstanceRefresh":{"input":{"type":"structure","required":["AutoScalingGroupName"],"members":{"AutoScalingGroupName":{},"Strategy":{},"Preferences":{"type":"structure","members":{"MinHealthyPercentage":{"type":"integer"},"InstanceWarmup":{"type":"integer"}}}}},"output":{"resultWrapper":"StartInstanceRefreshResult","type":"structure","members":{"InstanceRefreshId":{}}}},"SuspendProcesses":{"input":{"shape":"S6m"}},"TerminateInstanceInAutoScalingGroup":{"input":{"type":"structure","required":["InstanceId","ShouldDecrementDesiredCapacity"],"members":{"InstanceId":{},"ShouldDecrementDesiredCapacity":{"type":"boolean"}}},"output":{"resultWrapper":"TerminateInstanceInAutoScalingGroupResult","type":"structure","members":{"Activity":{"shape":"S5i"}}}},"UpdateAutoScalingGroup":{"input":{"type":"structure","required":["AutoScalingGroupName"],"members":{"AutoScalingGroupName":{},"LaunchConfigurationName":{},"LaunchTemplate":{"shape":"S10"},"MixedInstancesPolicy":{"shape":"S12"},"MinSize":{"type":"integer"},"MaxSize":{"type":"integer"},"DesiredCapacity":{"type":"integer"},"DefaultCooldown":{"type":"integer"},"AvailabilityZones":{"shape":"S1d"},"HealthCheckType":{},"HealthCheckGracePeriod":{"type":"integer"},"PlacementGroup":{},"VPCZoneIdentifier":{},"TerminationPolicies":{"shape":"S1g"},"NewInstancesProtectedFromScaleIn":{"type":"boolean"},"ServiceLinkedRoleARN":{},"MaxInstanceLifetime":{"type":"integer"}}}}},"shapes":{"S2":{"type":"list","member":{}},"S6":{"type":"list","member":{}},"Sa":{"type":"list","member":{}},"Se":{"type":"list","member":{}},"Sg":{"type":"list","member":{"type":"structure","required":["ScheduledActionName"],"members":{"ScheduledActionName":{},"ErrorCode":{},"ErrorMessage":{}}}},"S10":{"type":"structure","members":{"LaunchTemplateId":{},"LaunchTemplateName":{},"Version":{}}},"S12":{"type":"structure","members":{"LaunchTemplate":{"type":"structure","members":{"LaunchTemplateSpecification":{"shape":"S10"},"Overrides":{"type":"list","member":{"type":"structure","members":{"InstanceType":{},"WeightedCapacity":{}}}}}},"InstancesDistribution":{"type":"structure","members":{"OnDemandAllocationStrategy":{},"OnDemandBaseCapacity":{"type":"integer"},"OnDemandPercentageAboveBaseCapacity":{"type":"integer"},"SpotAllocationStrategy":{},"SpotInstancePools":{"type":"integer"},"SpotMaxPrice":{}}}}},"S1d":{"type":"list","member":{}},"S1g":{"type":"list","member":{}},"S1p":{"type":"list","member":{"type":"structure","required":["Key"],"members":{"ResourceId":{},"ResourceType":{},"Key":{},"Value":{},"PropagateAtLaunch":{"type":"boolean"}}}},"S1w":{"type":"list","member":{}},"S1x":{"type":"list","member":{}},"S1z":{"type":"list","member":{"type":"structure","required":["DeviceName"],"members":{"VirtualName":{},"DeviceName":{},"Ebs":{"type":"structure","members":{"SnapshotId":{},"VolumeSize":{"type":"integer"},"VolumeType":{},"DeleteOnTermination":{"type":"boolean"},"Iops":{"type":"integer"},"Encrypted":{"type":"boolean"}}},"NoDevice":{"type":"boolean"}}}},"S28":{"type":"structure","members":{"Enabled":{"type":"boolean"}}},"S2d":{"type":"structure","members":{"HttpTokens":{},"HttpPutResponseHopLimit":{"type":"integer"},"HttpEndpoint":{}}},"S30":{"type":"list","member":{}},"S3c":{"type":"list","member":{"type":"structure","members":{"ResourceId":{},"ResourceType":{},"Key":{},"Value":{},"PropagateAtLaunch":{"type":"boolean"}}}},"S3j":{"type":"list","member":{}},"S4r":{"type":"integer","deprecated":true},"S4u":{"type":"list","member":{"type":"structure","required":["ScalingAdjustment"],"members":{"MetricIntervalLowerBound":{"type":"double"},"MetricIntervalUpperBound":{"type":"double"},"ScalingAdjustment":{"type":"integer"}}}},"S4y":{"type":"list","member":{"type":"structure","members":{"AlarmName":{},"AlarmARN":{}}}},"S50":{"type":"structure","required":["TargetValue"],"members":{"PredefinedMetricSpecification":{"type":"structure","required":["PredefinedMetricType"],"members":{"PredefinedMetricType":{},"ResourceLabel":{}}},"CustomizedMetricSpecification":{"type":"structure","required":["MetricName","Namespace","Statistic"],"members":{"MetricName":{},"Namespace":{},"Dimensions":{"type":"list","member":{"type":"structure","required":["Name","Value"],"members":{"Name":{},"Value":{}}}},"Statistic":{},"Unit":{}}},"TargetValue":{"type":"double"},"DisableScaleIn":{"type":"boolean"}}},"S5h":{"type":"list","member":{"shape":"S5i"}},"S5i":{"type":"structure","required":["ActivityId","AutoScalingGroupName","Cause","StartTime","StatusCode"],"members":{"ActivityId":{},"AutoScalingGroupName":{},"Description":{},"Cause":{},"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"StatusCode":{},"StatusMessage":{},"Progress":{"type":"integer"},"Details":{}}},"S66":{"type":"list","member":{}},"S6m":{"type":"structure","required":["AutoScalingGroupName"],"members":{"AutoScalingGroupName":{},"ScalingProcesses":{"type":"list","member":{}}}}}}; + // Should have digits and should not end with `_` + if (!hasDigits || ch === '_') return false; -/***/ }), + return true; +} -/***/ 3694: -/***/ (function(module, __unusedexports, __webpack_require__) { +function constructYamlInteger(data) { + var value = data, sign = 1, ch; -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; + if (value.indexOf('_') !== -1) { + value = value.replace(/_/g, ''); + } -apiLoader.services['schemas'] = {}; -AWS.Schemas = Service.defineService('schemas', ['2019-12-02']); -Object.defineProperty(apiLoader.services['schemas'], '2019-12-02', { - get: function get() { - var model = __webpack_require__(1176); - model.paginators = __webpack_require__(8116).pagination; - model.waiters = __webpack_require__(9999).waiters; - return model; - }, - enumerable: true, - configurable: true -}); + ch = value[0]; -module.exports = AWS.Schemas; + if (ch === '-' || ch === '+') { + if (ch === '-') sign = -1; + value = value.slice(1); + ch = value[0]; + } + if (value === '0') return 0; -/***/ }), + if (ch === '0') { + if (value[1] === 'b') return sign * parseInt(value.slice(2), 2); + if (value[1] === 'x') return sign * parseInt(value.slice(2), 16); + if (value[1] === 'o') return sign * parseInt(value.slice(2), 8); + } -/***/ 3696: -/***/ (function(module) { + return sign * parseInt(value, 10); +} -function AcceptorStateMachine(states, state) { - this.currentState = state || null; - this.states = states || {}; +function isInteger(object) { + return (Object.prototype.toString.call(object)) === '[object Number]' && + (object % 1 === 0 && !common.isNegativeZero(object)); } -AcceptorStateMachine.prototype.runTo = function runTo(finalState, done, bindObject, inputError) { - if (typeof finalState === 'function') { - inputError = bindObject; bindObject = done; - done = finalState; finalState = null; +module.exports = new Type('tag:yaml.org,2002:int', { + kind: 'scalar', + resolve: resolveYamlInteger, + construct: constructYamlInteger, + predicate: isInteger, + represent: { + binary: function (obj) { return obj >= 0 ? '0b' + obj.toString(2) : '-0b' + obj.toString(2).slice(1); }, + octal: function (obj) { return obj >= 0 ? '0o' + obj.toString(8) : '-0o' + obj.toString(8).slice(1); }, + decimal: function (obj) { return obj.toString(10); }, + /* eslint-disable max-len */ + hexadecimal: function (obj) { return obj >= 0 ? '0x' + obj.toString(16).toUpperCase() : '-0x' + obj.toString(16).toUpperCase().slice(1); } + }, + defaultStyle: 'decimal', + styleAliases: { + binary: [ 2, 'bin' ], + octal: [ 8, 'oct' ], + decimal: [ 10, 'dec' ], + hexadecimal: [ 16, 'hex' ] } +}); - var self = this; - var state = self.states[self.currentState]; - state.fn.call(bindObject || self, inputError, function(err) { - if (err) { - if (state.fail) self.currentState = state.fail; - else return done ? done.call(bindObject, err) : null; - } else { - if (state.accept) self.currentState = state.accept; - else return done ? done.call(bindObject) : null; - } - if (self.currentState === finalState) { - return done ? done.call(bindObject, err) : null; - } - self.runTo(finalState, done, bindObject, err); - }); -}; +/***/ }), -AcceptorStateMachine.prototype.addState = function addState(name, acceptState, failState, fn) { - if (typeof acceptState === 'function') { - fn = acceptState; acceptState = null; failState = null; - } else if (typeof failState === 'function') { - fn = failState; failState = null; - } +/***/ 7316: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - if (!this.currentState) this.currentState = name; - this.states[name] = { accept: acceptState, fail: failState, fn: fn }; - return this; -}; +"use strict"; -/** - * @api private - */ -module.exports = AcceptorStateMachine; + +var Type = __nccwpck_require__(9557); + +module.exports = new Type('tag:yaml.org,2002:map', { + kind: 'mapping', + construct: function (data) { return data !== null ? data : {}; } +}); /***/ }), -/***/ 3707: -/***/ (function(module, __unusedexports, __webpack_require__) { +/***/ 6854: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +"use strict"; -apiLoader.services['kinesisvideo'] = {}; -AWS.KinesisVideo = Service.defineService('kinesisvideo', ['2017-09-30']); -Object.defineProperty(apiLoader.services['kinesisvideo'], '2017-09-30', { - get: function get() { - var model = __webpack_require__(2766); - model.paginators = __webpack_require__(6207).pagination; - return model; - }, - enumerable: true, - configurable: true -}); -module.exports = AWS.KinesisVideo; +var Type = __nccwpck_require__(9557); +function resolveYamlMerge(data) { + return data === '<<' || data === null; +} -/***/ }), +module.exports = new Type('tag:yaml.org,2002:merge', { + kind: 'scalar', + resolve: resolveYamlMerge +}); -/***/ 3711: -/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) { -var AWS = __webpack_require__(395); -var inherit = AWS.util.inherit; +/***/ }), -/** - * The endpoint that a service will talk to, for example, - * `'https://ec2.ap-southeast-1.amazonaws.com'`. If - * you need to override an endpoint for a service, you can - * set the endpoint on a service by passing the endpoint - * object with the `endpoint` option key: - * - * ```javascript - * var ep = new AWS.Endpoint('awsproxy.example.com'); - * var s3 = new AWS.S3({endpoint: ep}); - * s3.service.endpoint.hostname == 'awsproxy.example.com' - * ``` - * - * Note that if you do not specify a protocol, the protocol will - * be selected based on your current {AWS.config} configuration. - * - * @!attribute protocol - * @return [String] the protocol (http or https) of the endpoint - * URL - * @!attribute hostname - * @return [String] the host portion of the endpoint, e.g., - * example.com - * @!attribute host - * @return [String] the host portion of the endpoint including - * the port, e.g., example.com:80 - * @!attribute port - * @return [Integer] the port of the endpoint - * @!attribute href - * @return [String] the full URL of the endpoint - */ -AWS.Endpoint = inherit({ +/***/ 4333: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - /** - * @overload Endpoint(endpoint) - * Constructs a new endpoint given an endpoint URL. If the - * URL omits a protocol (http or https), the default protocol - * set in the global {AWS.config} will be used. - * @param endpoint [String] the URL to construct an endpoint from - */ - constructor: function Endpoint(endpoint, config) { - AWS.util.hideProperties(this, ['slashes', 'auth', 'hash', 'search', 'query']); +"use strict"; - if (typeof endpoint === 'undefined' || endpoint === null) { - throw new Error('Invalid endpoint: ' + endpoint); - } else if (typeof endpoint !== 'string') { - return AWS.util.copy(endpoint); - } - if (!endpoint.match(/^http/)) { - var useSSL = config && config.sslEnabled !== undefined ? - config.sslEnabled : AWS.config.sslEnabled; - endpoint = (useSSL ? 'https' : 'http') + '://' + endpoint; - } +var Type = __nccwpck_require__(9557); - AWS.util.update(this, AWS.util.urlParse(endpoint)); +function resolveYamlNull(data) { + if (data === null) return true; - // Ensure the port property is set as an integer - if (this.port) { - this.port = parseInt(this.port, 10); - } else { - this.port = this.protocol === 'https:' ? 443 : 80; - } - } + var max = data.length; -}); + return (max === 1 && data === '~') || + (max === 4 && (data === 'null' || data === 'Null' || data === 'NULL')); +} -/** - * The low level HTTP request object, encapsulating all HTTP header - * and body data sent by a service request. - * - * @!attribute method - * @return [String] the HTTP method of the request - * @!attribute path - * @return [String] the path portion of the URI, e.g., - * "/list/?start=5&num=10" - * @!attribute headers - * @return [map] - * a map of header keys and their respective values - * @!attribute body - * @return [String] the request body payload - * @!attribute endpoint - * @return [AWS.Endpoint] the endpoint for the request - * @!attribute region - * @api private - * @return [String] the region, for signing purposes only. - */ -AWS.HttpRequest = inherit({ +function constructYamlNull() { + return null; +} - /** - * @api private - */ - constructor: function HttpRequest(endpoint, region) { - endpoint = new AWS.Endpoint(endpoint); - this.method = 'POST'; - this.path = endpoint.path || '/'; - this.headers = {}; - this.body = ''; - this.endpoint = endpoint; - this.region = region; - this._userAgent = ''; - this.setUserAgent(); - }, +function isNull(object) { + return object === null; +} - /** - * @api private - */ - setUserAgent: function setUserAgent() { - this._userAgent = this.headers[this.getUserAgentHeaderName()] = AWS.util.userAgent(); +module.exports = new Type('tag:yaml.org,2002:null', { + kind: 'scalar', + resolve: resolveYamlNull, + construct: constructYamlNull, + predicate: isNull, + represent: { + canonical: function () { return '~'; }, + lowercase: function () { return 'null'; }, + uppercase: function () { return 'NULL'; }, + camelcase: function () { return 'Null'; }, + empty: function () { return ''; } }, + defaultStyle: 'lowercase' +}); - getUserAgentHeaderName: function getUserAgentHeaderName() { - var prefix = AWS.util.isBrowser() ? 'X-Amz-' : ''; - return prefix + 'User-Agent'; - }, - /** - * @api private - */ - appendToUserAgent: function appendToUserAgent(agentPartial) { - if (typeof agentPartial === 'string' && agentPartial) { - this._userAgent += ' ' + agentPartial; - } - this.headers[this.getUserAgentHeaderName()] = this._userAgent; - }, +/***/ }), - /** - * @api private - */ - getUserAgent: function getUserAgent() { - return this._userAgent; - }, +/***/ 8649: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - /** - * @return [String] the part of the {path} excluding the - * query string - */ - pathname: function pathname() { - return this.path.split('?', 1)[0]; - }, +"use strict"; - /** - * @return [String] the query string portion of the {path} - */ - search: function search() { - var query = this.path.split('?', 2)[1]; - if (query) { - query = AWS.util.queryStringParse(query); - return AWS.util.queryParamsToString(query); - } - return ''; - }, - /** - * @api private - * update httpRequest endpoint with endpoint string - */ - updateEndpoint: function updateEndpoint(endpointStr) { - var newEndpoint = new AWS.Endpoint(endpointStr); - this.endpoint = newEndpoint; - this.path = newEndpoint.path || '/'; - if (this.headers['Host']) { - this.headers['Host'] = newEndpoint.host; - } - } -}); +var Type = __nccwpck_require__(9557); -/** - * The low level HTTP response object, encapsulating all HTTP header - * and body data returned from the request. - * - * @!attribute statusCode - * @return [Integer] the HTTP status code of the response (e.g., 200, 404) - * @!attribute headers - * @return [map] - * a map of response header keys and their respective values - * @!attribute body - * @return [String] the response body payload - * @!attribute [r] streaming - * @return [Boolean] whether this response is being streamed at a low-level. - * Defaults to `false` (buffered reads). Do not modify this manually, use - * {createUnbufferedStream} to convert the stream to unbuffered mode - * instead. - */ -AWS.HttpResponse = inherit({ +var _hasOwnProperty = Object.prototype.hasOwnProperty; +var _toString = Object.prototype.toString; - /** - * @api private - */ - constructor: function HttpResponse() { - this.statusCode = undefined; - this.headers = {}; - this.body = undefined; - this.streaming = false; - this.stream = null; - }, - - /** - * Disables buffering on the HTTP response and returns the stream for reading. - * @return [Stream, XMLHttpRequest, null] the underlying stream object. - * Use this object to directly read data off of the stream. - * @note This object is only available after the {AWS.Request~httpHeaders} - * event has fired. This method must be called prior to - * {AWS.Request~httpData}. - * @example Taking control of a stream - * request.on('httpHeaders', function(statusCode, headers) { - * if (statusCode < 300) { - * if (headers.etag === 'xyz') { - * // pipe the stream, disabling buffering - * var stream = this.response.httpResponse.createUnbufferedStream(); - * stream.pipe(process.stdout); - * } else { // abort this request and set a better error message - * this.abort(); - * this.response.error = new Error('Invalid ETag'); - * } - * } - * }).send(console.log); - */ - createUnbufferedStream: function createUnbufferedStream() { - this.streaming = true; - return this.stream; - } -}); +function resolveYamlOmap(data) { + if (data === null) return true; + var objectKeys = [], index, length, pair, pairKey, pairHasKey, + object = data; -AWS.HttpClient = inherit({}); + for (index = 0, length = object.length; index < length; index += 1) { + pair = object[index]; + pairHasKey = false; -/** - * @api private - */ -AWS.HttpClient.getInstance = function getInstance() { - if (this.singleton === undefined) { - this.singleton = new this(); - } - return this.singleton; -}; + if (_toString.call(pair) !== '[object Object]') return false; + for (pairKey in pair) { + if (_hasOwnProperty.call(pair, pairKey)) { + if (!pairHasKey) pairHasKey = true; + else return false; + } + } -/***/ }), + if (!pairHasKey) return false; -/***/ 3725: -/***/ (function(module) { + if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey); + else return false; + } -module.exports = {"pagination":{"DescribeAccelerators":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults","result_key":"acceleratorSet"}}}; + return true; +} -/***/ }), +function constructYamlOmap(data) { + return data !== null ? data : []; +} -/***/ 3753: -/***/ (function(module) { +module.exports = new Type('tag:yaml.org,2002:omap', { + kind: 'sequence', + resolve: resolveYamlOmap, + construct: constructYamlOmap +}); -module.exports = {"pagination":{"DescribeBackups":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"DescribeDataRepositoryTasks":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"DescribeFileSystems":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"}}}; /***/ }), -/***/ 3754: -/***/ (function(module, __unusedexports, __webpack_require__) { - -var AWS = __webpack_require__(395); -var v4Credentials = __webpack_require__(9819); -var inherit = AWS.util.inherit; - -/** - * @api private - */ -var expiresHeader = 'presigned-expires'; - -/** - * @api private - */ -AWS.Signers.V4 = inherit(AWS.Signers.RequestSigner, { - constructor: function V4(request, serviceName, options) { - AWS.Signers.RequestSigner.call(this, request); - this.serviceName = serviceName; - options = options || {}; - this.signatureCache = typeof options.signatureCache === 'boolean' ? options.signatureCache : true; - this.operation = options.operation; - this.signatureVersion = options.signatureVersion; - }, - - algorithm: 'AWS4-HMAC-SHA256', - - addAuthorization: function addAuthorization(credentials, date) { - var datetime = AWS.util.date.iso8601(date).replace(/[:\-]|\.\d{3}/g, ''); - - if (this.isPresigned()) { - this.updateForPresigned(credentials, datetime); - } else { - this.addHeaders(credentials, datetime); - } - - this.request.headers['Authorization'] = - this.authorization(credentials, datetime); - }, +/***/ 6267: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - addHeaders: function addHeaders(credentials, datetime) { - this.request.headers['X-Amz-Date'] = datetime; - if (credentials.sessionToken) { - this.request.headers['x-amz-security-token'] = credentials.sessionToken; - } - }, +"use strict"; - updateForPresigned: function updateForPresigned(credentials, datetime) { - var credString = this.credentialString(datetime); - var qs = { - 'X-Amz-Date': datetime, - 'X-Amz-Algorithm': this.algorithm, - 'X-Amz-Credential': credentials.accessKeyId + '/' + credString, - 'X-Amz-Expires': this.request.headers[expiresHeader], - 'X-Amz-SignedHeaders': this.signedHeaders() - }; - if (credentials.sessionToken) { - qs['X-Amz-Security-Token'] = credentials.sessionToken; - } +var Type = __nccwpck_require__(9557); - if (this.request.headers['Content-Type']) { - qs['Content-Type'] = this.request.headers['Content-Type']; - } - if (this.request.headers['Content-MD5']) { - qs['Content-MD5'] = this.request.headers['Content-MD5']; - } - if (this.request.headers['Cache-Control']) { - qs['Cache-Control'] = this.request.headers['Cache-Control']; - } +var _toString = Object.prototype.toString; - // need to pull in any other X-Amz-* headers - AWS.util.each.call(this, this.request.headers, function(key, value) { - if (key === expiresHeader) return; - if (this.isSignableHeader(key)) { - var lowerKey = key.toLowerCase(); - // Metadata should be normalized - if (lowerKey.indexOf('x-amz-meta-') === 0) { - qs[lowerKey] = value; - } else if (lowerKey.indexOf('x-amz-') === 0) { - qs[key] = value; - } - } - }); +function resolveYamlPairs(data) { + if (data === null) return true; - var sep = this.request.path.indexOf('?') >= 0 ? '&' : '?'; - this.request.path += sep + AWS.util.queryParamsToString(qs); - }, + var index, length, pair, keys, result, + object = data; - authorization: function authorization(credentials, datetime) { - var parts = []; - var credString = this.credentialString(datetime); - parts.push(this.algorithm + ' Credential=' + - credentials.accessKeyId + '/' + credString); - parts.push('SignedHeaders=' + this.signedHeaders()); - parts.push('Signature=' + this.signature(credentials, datetime)); - return parts.join(', '); - }, + result = new Array(object.length); - signature: function signature(credentials, datetime) { - var signingKey = v4Credentials.getSigningKey( - credentials, - datetime.substr(0, 8), - this.request.region, - this.serviceName, - this.signatureCache - ); - return AWS.util.crypto.hmac(signingKey, this.stringToSign(datetime), 'hex'); - }, + for (index = 0, length = object.length; index < length; index += 1) { + pair = object[index]; - stringToSign: function stringToSign(datetime) { - var parts = []; - parts.push('AWS4-HMAC-SHA256'); - parts.push(datetime); - parts.push(this.credentialString(datetime)); - parts.push(this.hexEncodedHash(this.canonicalString())); - return parts.join('\n'); - }, + if (_toString.call(pair) !== '[object Object]') return false; - canonicalString: function canonicalString() { - var parts = [], pathname = this.request.pathname(); - if (this.serviceName !== 's3' && this.signatureVersion !== 's3v4') pathname = AWS.util.uriEscapePath(pathname); - - parts.push(this.request.method); - parts.push(pathname); - parts.push(this.request.search()); - parts.push(this.canonicalHeaders() + '\n'); - parts.push(this.signedHeaders()); - parts.push(this.hexEncodedBodyHash()); - return parts.join('\n'); - }, + keys = Object.keys(pair); - canonicalHeaders: function canonicalHeaders() { - var headers = []; - AWS.util.each.call(this, this.request.headers, function (key, item) { - headers.push([key, item]); - }); - headers.sort(function (a, b) { - return a[0].toLowerCase() < b[0].toLowerCase() ? -1 : 1; - }); - var parts = []; - AWS.util.arrayEach.call(this, headers, function (item) { - var key = item[0].toLowerCase(); - if (this.isSignableHeader(key)) { - var value = item[1]; - if (typeof value === 'undefined' || value === null || typeof value.toString !== 'function') { - throw AWS.util.error(new Error('Header ' + key + ' contains invalid value'), { - code: 'InvalidHeader' - }); - } - parts.push(key + ':' + - this.canonicalHeaderValues(value.toString())); - } - }); - return parts.join('\n'); - }, + if (keys.length !== 1) return false; - canonicalHeaderValues: function canonicalHeaderValues(values) { - return values.replace(/\s+/g, ' ').replace(/^\s+|\s+$/g, ''); - }, + result[index] = [ keys[0], pair[keys[0]] ]; + } - signedHeaders: function signedHeaders() { - var keys = []; - AWS.util.each.call(this, this.request.headers, function (key) { - key = key.toLowerCase(); - if (this.isSignableHeader(key)) keys.push(key); - }); - return keys.sort().join(';'); - }, + return true; +} - credentialString: function credentialString(datetime) { - return v4Credentials.createScope( - datetime.substr(0, 8), - this.request.region, - this.serviceName - ); - }, +function constructYamlPairs(data) { + if (data === null) return []; - hexEncodedHash: function hash(string) { - return AWS.util.crypto.sha256(string, 'hex'); - }, + var index, length, pair, keys, result, + object = data; - hexEncodedBodyHash: function hexEncodedBodyHash() { - var request = this.request; - if (this.isPresigned() && this.serviceName === 's3' && !request.body) { - return 'UNSIGNED-PAYLOAD'; - } else if (request.headers['X-Amz-Content-Sha256']) { - return request.headers['X-Amz-Content-Sha256']; - } else { - return this.hexEncodedHash(this.request.body || ''); - } - }, + result = new Array(object.length); - unsignableHeaders: [ - 'authorization', - 'content-type', - 'content-length', - 'user-agent', - expiresHeader, - 'expect', - 'x-amzn-trace-id' - ], + for (index = 0, length = object.length; index < length; index += 1) { + pair = object[index]; - isSignableHeader: function isSignableHeader(key) { - if (key.toLowerCase().indexOf('x-amz-') === 0) return true; - return this.unsignableHeaders.indexOf(key) < 0; - }, + keys = Object.keys(pair); - isPresigned: function isPresigned() { - return this.request.headers[expiresHeader] ? true : false; + result[index] = [ keys[0], pair[keys[0]] ]; } -}); + return result; +} -/** - * @api private - */ -module.exports = AWS.Signers.V4; +module.exports = new Type('tag:yaml.org,2002:pairs', { + kind: 'sequence', + resolve: resolveYamlPairs, + construct: constructYamlPairs +}); /***/ }), -/***/ 3756: -/***/ (function(module) { - -module.exports = {"pagination":{"DescribeDBEngineVersions":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DBEngineVersions"},"DescribeDBInstances":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DBInstances"},"DescribeDBLogFiles":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DescribeDBLogFiles"},"DescribeDBParameterGroups":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DBParameterGroups"},"DescribeDBParameters":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"Parameters"},"DescribeDBSecurityGroups":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DBSecurityGroups"},"DescribeDBSnapshots":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DBSnapshots"},"DescribeDBSubnetGroups":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DBSubnetGroups"},"DescribeEngineDefaultParameters":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"EngineDefaults.Marker","result_key":"EngineDefaults.Parameters"},"DescribeEventSubscriptions":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"EventSubscriptionsList"},"DescribeEvents":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"Events"},"DescribeOptionGroupOptions":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"OptionGroupOptions"},"DescribeOptionGroups":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"OptionGroupsList"},"DescribeOrderableDBInstanceOptions":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"OrderableDBInstanceOptions"},"DescribeReservedDBInstances":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"ReservedDBInstances"},"DescribeReservedDBInstancesOfferings":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"ReservedDBInstancesOfferings"},"DownloadDBLogFilePortion":{"input_token":"Marker","limit_key":"NumberOfLines","more_results":"AdditionalDataPending","output_token":"Marker","result_key":"LogFileData"},"ListTagsForResource":{"result_key":"TagList"}}}; - -/***/ }), +/***/ 7161: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -/***/ 3762: -/***/ (function(module) { +"use strict"; -module.exports = {"version":"2.0","metadata":{"apiVersion":"2018-09-24","endpointPrefix":"managedblockchain","jsonVersion":"1.1","protocol":"rest-json","serviceAbbreviation":"ManagedBlockchain","serviceFullName":"Amazon Managed Blockchain","serviceId":"ManagedBlockchain","signatureVersion":"v4","signingName":"managedblockchain","uid":"managedblockchain-2018-09-24"},"operations":{"CreateMember":{"http":{"requestUri":"/networks/{networkId}/members"},"input":{"type":"structure","required":["ClientRequestToken","InvitationId","NetworkId","MemberConfiguration"],"members":{"ClientRequestToken":{"idempotencyToken":true},"InvitationId":{},"NetworkId":{"location":"uri","locationName":"networkId"},"MemberConfiguration":{"shape":"S4"}}},"output":{"type":"structure","members":{"MemberId":{}}}},"CreateNetwork":{"http":{"requestUri":"/networks"},"input":{"type":"structure","required":["ClientRequestToken","Name","Framework","FrameworkVersion","VotingPolicy","MemberConfiguration"],"members":{"ClientRequestToken":{"idempotencyToken":true},"Name":{},"Description":{},"Framework":{},"FrameworkVersion":{},"FrameworkConfiguration":{"type":"structure","members":{"Fabric":{"type":"structure","required":["Edition"],"members":{"Edition":{}}}}},"VotingPolicy":{"shape":"So"},"MemberConfiguration":{"shape":"S4"}}},"output":{"type":"structure","members":{"NetworkId":{},"MemberId":{}}}},"CreateNode":{"http":{"requestUri":"/networks/{networkId}/members/{memberId}/nodes"},"input":{"type":"structure","required":["ClientRequestToken","NetworkId","MemberId","NodeConfiguration"],"members":{"ClientRequestToken":{"idempotencyToken":true},"NetworkId":{"location":"uri","locationName":"networkId"},"MemberId":{"location":"uri","locationName":"memberId"},"NodeConfiguration":{"type":"structure","required":["InstanceType","AvailabilityZone"],"members":{"InstanceType":{},"AvailabilityZone":{},"LogPublishingConfiguration":{"shape":"Sy"}}}}},"output":{"type":"structure","members":{"NodeId":{}}}},"CreateProposal":{"http":{"requestUri":"/networks/{networkId}/proposals"},"input":{"type":"structure","required":["ClientRequestToken","NetworkId","MemberId","Actions"],"members":{"ClientRequestToken":{"idempotencyToken":true},"NetworkId":{"location":"uri","locationName":"networkId"},"MemberId":{},"Actions":{"shape":"S12"},"Description":{}}},"output":{"type":"structure","members":{"ProposalId":{}}}},"DeleteMember":{"http":{"method":"DELETE","requestUri":"/networks/{networkId}/members/{memberId}"},"input":{"type":"structure","required":["NetworkId","MemberId"],"members":{"NetworkId":{"location":"uri","locationName":"networkId"},"MemberId":{"location":"uri","locationName":"memberId"}}},"output":{"type":"structure","members":{}}},"DeleteNode":{"http":{"method":"DELETE","requestUri":"/networks/{networkId}/members/{memberId}/nodes/{nodeId}"},"input":{"type":"structure","required":["NetworkId","MemberId","NodeId"],"members":{"NetworkId":{"location":"uri","locationName":"networkId"},"MemberId":{"location":"uri","locationName":"memberId"},"NodeId":{"location":"uri","locationName":"nodeId"}}},"output":{"type":"structure","members":{}}},"GetMember":{"http":{"method":"GET","requestUri":"/networks/{networkId}/members/{memberId}"},"input":{"type":"structure","required":["NetworkId","MemberId"],"members":{"NetworkId":{"location":"uri","locationName":"networkId"},"MemberId":{"location":"uri","locationName":"memberId"}}},"output":{"type":"structure","members":{"Member":{"type":"structure","members":{"NetworkId":{},"Id":{},"Name":{},"Description":{},"FrameworkAttributes":{"type":"structure","members":{"Fabric":{"type":"structure","members":{"AdminUsername":{},"CaEndpoint":{}}}}},"LogPublishingConfiguration":{"shape":"Sb"},"Status":{},"CreationDate":{"shape":"S1k"}}}}}},"GetNetwork":{"http":{"method":"GET","requestUri":"/networks/{networkId}"},"input":{"type":"structure","required":["NetworkId"],"members":{"NetworkId":{"location":"uri","locationName":"networkId"}}},"output":{"type":"structure","members":{"Network":{"type":"structure","members":{"Id":{},"Name":{},"Description":{},"Framework":{},"FrameworkVersion":{},"FrameworkAttributes":{"type":"structure","members":{"Fabric":{"type":"structure","members":{"OrderingServiceEndpoint":{},"Edition":{}}}}},"VpcEndpointServiceName":{},"VotingPolicy":{"shape":"So"},"Status":{},"CreationDate":{"shape":"S1k"}}}}}},"GetNode":{"http":{"method":"GET","requestUri":"/networks/{networkId}/members/{memberId}/nodes/{nodeId}"},"input":{"type":"structure","required":["NetworkId","MemberId","NodeId"],"members":{"NetworkId":{"location":"uri","locationName":"networkId"},"MemberId":{"location":"uri","locationName":"memberId"},"NodeId":{"location":"uri","locationName":"nodeId"}}},"output":{"type":"structure","members":{"Node":{"type":"structure","members":{"NetworkId":{},"MemberId":{},"Id":{},"InstanceType":{},"AvailabilityZone":{},"FrameworkAttributes":{"type":"structure","members":{"Fabric":{"type":"structure","members":{"PeerEndpoint":{},"PeerEventEndpoint":{}}}}},"LogPublishingConfiguration":{"shape":"Sy"},"Status":{},"CreationDate":{"shape":"S1k"}}}}}},"GetProposal":{"http":{"method":"GET","requestUri":"/networks/{networkId}/proposals/{proposalId}"},"input":{"type":"structure","required":["NetworkId","ProposalId"],"members":{"NetworkId":{"location":"uri","locationName":"networkId"},"ProposalId":{"location":"uri","locationName":"proposalId"}}},"output":{"type":"structure","members":{"Proposal":{"type":"structure","members":{"ProposalId":{},"NetworkId":{},"Description":{},"Actions":{"shape":"S12"},"ProposedByMemberId":{},"ProposedByMemberName":{},"Status":{},"CreationDate":{"shape":"S1k"},"ExpirationDate":{"shape":"S1k"},"YesVoteCount":{"type":"integer"},"NoVoteCount":{"type":"integer"},"OutstandingVoteCount":{"type":"integer"}}}}}},"ListInvitations":{"http":{"method":"GET","requestUri":"/invitations"},"input":{"type":"structure","members":{"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"Invitations":{"type":"list","member":{"type":"structure","members":{"InvitationId":{},"CreationDate":{"shape":"S1k"},"ExpirationDate":{"shape":"S1k"},"Status":{},"NetworkSummary":{"shape":"S29"}}}},"NextToken":{}}}},"ListMembers":{"http":{"method":"GET","requestUri":"/networks/{networkId}/members"},"input":{"type":"structure","required":["NetworkId"],"members":{"NetworkId":{"location":"uri","locationName":"networkId"},"Name":{"location":"querystring","locationName":"name"},"Status":{"location":"querystring","locationName":"status"},"IsOwned":{"location":"querystring","locationName":"isOwned","type":"boolean"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"Members":{"type":"list","member":{"type":"structure","members":{"Id":{},"Name":{},"Description":{},"Status":{},"CreationDate":{"shape":"S1k"},"IsOwned":{"type":"boolean"}}}},"NextToken":{}}}},"ListNetworks":{"http":{"method":"GET","requestUri":"/networks"},"input":{"type":"structure","members":{"Name":{"location":"querystring","locationName":"name"},"Framework":{"location":"querystring","locationName":"framework"},"Status":{"location":"querystring","locationName":"status"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"Networks":{"type":"list","member":{"shape":"S29"}},"NextToken":{}}}},"ListNodes":{"http":{"method":"GET","requestUri":"/networks/{networkId}/members/{memberId}/nodes"},"input":{"type":"structure","required":["NetworkId","MemberId"],"members":{"NetworkId":{"location":"uri","locationName":"networkId"},"MemberId":{"location":"uri","locationName":"memberId"},"Status":{"location":"querystring","locationName":"status"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"Nodes":{"type":"list","member":{"type":"structure","members":{"Id":{},"Status":{},"CreationDate":{"shape":"S1k"},"AvailabilityZone":{},"InstanceType":{}}}},"NextToken":{}}}},"ListProposalVotes":{"http":{"method":"GET","requestUri":"/networks/{networkId}/proposals/{proposalId}/votes"},"input":{"type":"structure","required":["NetworkId","ProposalId"],"members":{"NetworkId":{"location":"uri","locationName":"networkId"},"ProposalId":{"location":"uri","locationName":"proposalId"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"ProposalVotes":{"type":"list","member":{"type":"structure","members":{"Vote":{},"MemberName":{},"MemberId":{}}}},"NextToken":{}}}},"ListProposals":{"http":{"method":"GET","requestUri":"/networks/{networkId}/proposals"},"input":{"type":"structure","required":["NetworkId"],"members":{"NetworkId":{"location":"uri","locationName":"networkId"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"Proposals":{"type":"list","member":{"type":"structure","members":{"ProposalId":{},"Description":{},"ProposedByMemberId":{},"ProposedByMemberName":{},"Status":{},"CreationDate":{"shape":"S1k"},"ExpirationDate":{"shape":"S1k"}}}},"NextToken":{}}}},"RejectInvitation":{"http":{"method":"DELETE","requestUri":"/invitations/{invitationId}"},"input":{"type":"structure","required":["InvitationId"],"members":{"InvitationId":{"location":"uri","locationName":"invitationId"}}},"output":{"type":"structure","members":{}}},"UpdateMember":{"http":{"method":"PATCH","requestUri":"/networks/{networkId}/members/{memberId}"},"input":{"type":"structure","required":["NetworkId","MemberId"],"members":{"NetworkId":{"location":"uri","locationName":"networkId"},"MemberId":{"location":"uri","locationName":"memberId"},"LogPublishingConfiguration":{"shape":"Sb"}}},"output":{"type":"structure","members":{}}},"UpdateNode":{"http":{"method":"PATCH","requestUri":"/networks/{networkId}/members/{memberId}/nodes/{nodeId}"},"input":{"type":"structure","required":["NetworkId","MemberId","NodeId"],"members":{"NetworkId":{"location":"uri","locationName":"networkId"},"MemberId":{"location":"uri","locationName":"memberId"},"NodeId":{"location":"uri","locationName":"nodeId"},"LogPublishingConfiguration":{"shape":"Sy"}}},"output":{"type":"structure","members":{}}},"VoteOnProposal":{"http":{"requestUri":"/networks/{networkId}/proposals/{proposalId}/votes"},"input":{"type":"structure","required":["NetworkId","ProposalId","VoterMemberId","Vote"],"members":{"NetworkId":{"location":"uri","locationName":"networkId"},"ProposalId":{"location":"uri","locationName":"proposalId"},"VoterMemberId":{},"Vote":{}}},"output":{"type":"structure","members":{}}}},"shapes":{"S4":{"type":"structure","required":["Name","FrameworkConfiguration"],"members":{"Name":{},"Description":{},"FrameworkConfiguration":{"type":"structure","members":{"Fabric":{"type":"structure","required":["AdminUsername","AdminPassword"],"members":{"AdminUsername":{},"AdminPassword":{"type":"string","sensitive":true}}}}},"LogPublishingConfiguration":{"shape":"Sb"}}},"Sb":{"type":"structure","members":{"Fabric":{"type":"structure","members":{"CaLogs":{"shape":"Sd"}}}}},"Sd":{"type":"structure","members":{"Cloudwatch":{"type":"structure","members":{"Enabled":{"type":"boolean"}}}}},"So":{"type":"structure","members":{"ApprovalThresholdPolicy":{"type":"structure","members":{"ThresholdPercentage":{"type":"integer"},"ProposalDurationInHours":{"type":"integer"},"ThresholdComparator":{}}}}},"Sy":{"type":"structure","members":{"Fabric":{"type":"structure","members":{"ChaincodeLogs":{"shape":"Sd"},"PeerLogs":{"shape":"Sd"}}}}},"S12":{"type":"structure","members":{"Invitations":{"type":"list","member":{"type":"structure","required":["Principal"],"members":{"Principal":{}}}},"Removals":{"type":"list","member":{"type":"structure","required":["MemberId"],"members":{"MemberId":{}}}}}},"S1k":{"type":"timestamp","timestampFormat":"iso8601"},"S29":{"type":"structure","members":{"Id":{},"Name":{},"Description":{},"Framework":{},"FrameworkVersion":{},"Status":{},"CreationDate":{"shape":"S1k"}}}}}; -/***/ }), +var Type = __nccwpck_require__(9557); -/***/ 3763: -/***/ (function(module) { +module.exports = new Type('tag:yaml.org,2002:seq', { + kind: 'sequence', + construct: function (data) { return data !== null ? data : []; } +}); -module.exports = {"pagination":{}}; /***/ }), -/***/ 3788: -/***/ (function(module) { +/***/ 8758: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = {"pagination":{"GetComplianceSummary":{"input_token":"PaginationToken","limit_key":"MaxResults","output_token":"PaginationToken","result_key":"SummaryList"},"GetResources":{"input_token":"PaginationToken","limit_key":"ResourcesPerPage","output_token":"PaginationToken","result_key":"ResourceTagMappingList"},"GetTagKeys":{"input_token":"PaginationToken","output_token":"PaginationToken","result_key":"TagKeys"},"GetTagValues":{"input_token":"PaginationToken","output_token":"PaginationToken","result_key":"TagValues"}}}; +"use strict"; -/***/ }), -/***/ 3801: -/***/ (function(module, __unusedexports, __webpack_require__) { +var Type = __nccwpck_require__(9557); -// Generated by CoffeeScript 1.12.7 -(function() { - var XMLDTDAttList, XMLNode, - extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, - hasProp = {}.hasOwnProperty; +var _hasOwnProperty = Object.prototype.hasOwnProperty; - XMLNode = __webpack_require__(6855); +function resolveYamlSet(data) { + if (data === null) return true; - module.exports = XMLDTDAttList = (function(superClass) { - extend(XMLDTDAttList, superClass); + var key, object = data; - function XMLDTDAttList(parent, elementName, attributeName, attributeType, defaultValueType, defaultValue) { - XMLDTDAttList.__super__.constructor.call(this, parent); - if (elementName == null) { - throw new Error("Missing DTD element name"); - } - if (attributeName == null) { - throw new Error("Missing DTD attribute name"); - } - if (!attributeType) { - throw new Error("Missing DTD attribute type"); - } - if (!defaultValueType) { - throw new Error("Missing DTD attribute default"); - } - if (defaultValueType.indexOf('#') !== 0) { - defaultValueType = '#' + defaultValueType; - } - if (!defaultValueType.match(/^(#REQUIRED|#IMPLIED|#FIXED|#DEFAULT)$/)) { - throw new Error("Invalid default value type; expected: #REQUIRED, #IMPLIED, #FIXED or #DEFAULT"); - } - if (defaultValue && !defaultValueType.match(/^(#FIXED|#DEFAULT)$/)) { - throw new Error("Default value only applies to #FIXED or #DEFAULT"); - } - this.elementName = this.stringify.eleName(elementName); - this.attributeName = this.stringify.attName(attributeName); - this.attributeType = this.stringify.dtdAttType(attributeType); - this.defaultValue = this.stringify.dtdAttDefault(defaultValue); - this.defaultValueType = defaultValueType; + for (key in object) { + if (_hasOwnProperty.call(object, key)) { + if (object[key] !== null) return false; } + } - XMLDTDAttList.prototype.toString = function(options) { - return this.options.writer.set(options).dtdAttList(this); - }; - - return XMLDTDAttList; - - })(XMLNode); - -}).call(this); - + return true; +} -/***/ }), +function constructYamlSet(data) { + return data !== null ? data : {}; +} -/***/ 3814: -/***/ (function(module) { +module.exports = new Type('tag:yaml.org,2002:set', { + kind: 'mapping', + resolve: resolveYamlSet, + construct: constructYamlSet +}); -module.exports = {"pagination":{"GetDedicatedIps":{"input_token":"NextToken","output_token":"NextToken","limit_key":"PageSize"},"ListConfigurationSets":{"input_token":"NextToken","output_token":"NextToken","limit_key":"PageSize"},"ListDedicatedIpPools":{"input_token":"NextToken","output_token":"NextToken","limit_key":"PageSize"},"ListDeliverabilityTestReports":{"input_token":"NextToken","output_token":"NextToken","limit_key":"PageSize"},"ListDomainDeliverabilityCampaigns":{"input_token":"NextToken","output_token":"NextToken","limit_key":"PageSize"},"ListEmailIdentities":{"input_token":"NextToken","output_token":"NextToken","limit_key":"PageSize"}}}; /***/ }), -/***/ 3815: -/***/ (function(module, __unusedexports, __webpack_require__) { +/***/ 3929: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -var util = __webpack_require__(395).util; -var typeOf = __webpack_require__(8194).typeOf; +"use strict"; -/** - * @api private - */ -var memberTypeToSetType = { - 'String': 'String', - 'Number': 'Number', - 'NumberValue': 'Number', - 'Binary': 'Binary' -}; -/** - * @api private - */ -var DynamoDBSet = util.inherit({ +var Type = __nccwpck_require__(9557); - constructor: function Set(list, options) { - options = options || {}; - this.wrapperName = 'Set'; - this.initialize(list, options.validate); - }, +module.exports = new Type('tag:yaml.org,2002:str', { + kind: 'scalar', + construct: function (data) { return data !== null ? data : ''; } +}); - initialize: function(list, validate) { - var self = this; - self.values = [].concat(list); - self.detectType(); - if (validate) { - self.validate(); - } - }, - detectType: function() { - this.type = memberTypeToSetType[typeOf(this.values[0])]; - if (!this.type) { - throw util.error(new Error(), { - code: 'InvalidSetType', - message: 'Sets can contain string, number, or binary values' - }); - } - }, +/***/ }), - validate: function() { - var self = this; - var length = self.values.length; - var values = self.values; - for (var i = 0; i < length; i++) { - if (memberTypeToSetType[typeOf(values[i])] !== self.type) { - throw util.error(new Error(), { - code: 'InvalidType', - message: self.type + ' Set contains ' + typeOf(values[i]) + ' value' - }); - } - } - }, +/***/ 8966: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - /** - * Render the underlying values only when converting to JSON. - */ - toJSON: function() { - var self = this; - return self.values; - } +"use strict"; -}); -/** - * @api private - */ -module.exports = DynamoDBSet; +var Type = __nccwpck_require__(9557); +var YAML_DATE_REGEXP = new RegExp( + '^([0-9][0-9][0-9][0-9])' + // [1] year + '-([0-9][0-9])' + // [2] month + '-([0-9][0-9])$'); // [3] day -/***/ }), +var YAML_TIMESTAMP_REGEXP = new RegExp( + '^([0-9][0-9][0-9][0-9])' + // [1] year + '-([0-9][0-9]?)' + // [2] month + '-([0-9][0-9]?)' + // [3] day + '(?:[Tt]|[ \\t]+)' + // ... + '([0-9][0-9]?)' + // [4] hour + ':([0-9][0-9])' + // [5] minute + ':([0-9][0-9])' + // [6] second + '(?:\\.([0-9]*))?' + // [7] fraction + '(?:[ \\t]*(Z|([-+])([0-9][0-9]?)' + // [8] tz [9] tz_sign [10] tz_hour + '(?::([0-9][0-9]))?))?$'); // [11] tz_minute -/***/ 3824: -/***/ (function(module) { +function resolveYamlTimestamp(data) { + if (data === null) return false; + if (YAML_DATE_REGEXP.exec(data) !== null) return true; + if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true; + return false; +} -module.exports = {"pagination":{"ListMedicalTranscriptionJobs":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListMedicalVocabularies":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListTranscriptionJobs":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListVocabularies":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListVocabularyFilters":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"}}}; +function constructYamlTimestamp(data) { + var match, year, month, day, hour, minute, second, fraction = 0, + delta = null, tz_hour, tz_minute, date; -/***/ }), + match = YAML_DATE_REGEXP.exec(data); + if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data); -/***/ 3826: -/***/ (function(module, __unusedexports, __webpack_require__) { + if (match === null) throw new Error('Date resolve error'); -var rng = __webpack_require__(6139); -var bytesToUuid = __webpack_require__(1722); + // match: [1] year [2] month [3] day -function v4(options, buf, offset) { - var i = buf && offset || 0; + year = +(match[1]); + month = +(match[2]) - 1; // JS month starts with 0 + day = +(match[3]); - if (typeof(options) == 'string') { - buf = options === 'binary' ? new Array(16) : null; - options = null; + if (!match[4]) { // no hour + return new Date(Date.UTC(year, month, day)); } - options = options || {}; - var rnds = options.random || (options.rng || rng)(); + // match: [4] hour [5] minute [6] second [7] fraction - // Per 4.4, set bits for version and `clock_seq_hi_and_reserved` - rnds[6] = (rnds[6] & 0x0f) | 0x40; - rnds[8] = (rnds[8] & 0x3f) | 0x80; + hour = +(match[4]); + minute = +(match[5]); + second = +(match[6]); - // Copy bytes to buffer, if provided - if (buf) { - for (var ii = 0; ii < 16; ++ii) { - buf[i + ii] = rnds[ii]; + if (match[7]) { + fraction = match[7].slice(0, 3); + while (fraction.length < 3) { // milli-seconds + fraction += '0'; } + fraction = +fraction; } - return buf || bytesToUuid(rnds); -} + // match: [8] tz [9] tz_sign [10] tz_hour [11] tz_minute -module.exports = v4; + if (match[9]) { + tz_hour = +(match[10]); + tz_minute = +(match[11] || 0); + delta = (tz_hour * 60 + tz_minute) * 60000; // delta in mili-seconds + if (match[9] === '-') delta = -delta; + } + date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction)); -/***/ }), + if (delta) date.setTime(date.getTime() - delta); -/***/ 3853: -/***/ (function(module, __unusedexports, __webpack_require__) { + return date; +} -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +function representYamlTimestamp(object /*, style*/) { + return object.toISOString(); +} -apiLoader.services['codestarnotifications'] = {}; -AWS.CodeStarNotifications = Service.defineService('codestarnotifications', ['2019-10-15']); -Object.defineProperty(apiLoader.services['codestarnotifications'], '2019-10-15', { - get: function get() { - var model = __webpack_require__(7913); - model.paginators = __webpack_require__(4409).pagination; - return model; - }, - enumerable: true, - configurable: true +module.exports = new Type('tag:yaml.org,2002:timestamp', { + kind: 'scalar', + resolve: resolveYamlTimestamp, + construct: constructYamlTimestamp, + instanceOf: Date, + represent: representYamlTimestamp }); -module.exports = AWS.CodeStarNotifications; - /***/ }), -/***/ 3861: -/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) { +/***/ 744: +/***/ ((module) => { -var AWS = __webpack_require__(395); -var resolveRegionalEndpointsFlag = __webpack_require__(6232); -var ENV_REGIONAL_ENDPOINT_ENABLED = 'AWS_STS_REGIONAL_ENDPOINTS'; -var CONFIG_REGIONAL_ENDPOINT_ENABLED = 'sts_regional_endpoints'; +/** + * Helpers. + */ -AWS.util.update(AWS.STS.prototype, { - /** - * @overload credentialsFrom(data, credentials = null) - * Creates a credentials object from STS response data containing - * credentials information. Useful for quickly setting AWS credentials. - * - * @note This is a low-level utility function. If you want to load temporary - * credentials into your process for subsequent requests to AWS resources, - * you should use {AWS.TemporaryCredentials} instead. - * @param data [map] data retrieved from a call to {getFederatedToken}, - * {getSessionToken}, {assumeRole}, or {assumeRoleWithWebIdentity}. - * @param credentials [AWS.Credentials] an optional credentials object to - * fill instead of creating a new object. Useful when modifying an - * existing credentials object from a refresh call. - * @return [AWS.TemporaryCredentials] the set of temporary credentials - * loaded from a raw STS operation response. - * @example Using credentialsFrom to load global AWS credentials - * var sts = new AWS.STS(); - * sts.getSessionToken(function (err, data) { - * if (err) console.log("Error getting credentials"); - * else { - * AWS.config.credentials = sts.credentialsFrom(data); - * } - * }); - * @see AWS.TemporaryCredentials - */ - credentialsFrom: function credentialsFrom(data, credentials) { - if (!data) return null; - if (!credentials) credentials = new AWS.TemporaryCredentials(); - credentials.expired = false; - credentials.accessKeyId = data.Credentials.AccessKeyId; - credentials.secretAccessKey = data.Credentials.SecretAccessKey; - credentials.sessionToken = data.Credentials.SessionToken; - credentials.expireTime = data.Credentials.Expiration; - return credentials; - }, +var s = 1000; +var m = s * 60; +var h = m * 60; +var d = h * 24; +var w = d * 7; +var y = d * 365.25; - assumeRoleWithWebIdentity: function assumeRoleWithWebIdentity(params, callback) { - return this.makeUnauthenticatedRequest('assumeRoleWithWebIdentity', params, callback); - }, +/** + * Parse or format the given `val`. + * + * Options: + * + * - `long` verbose formatting [false] + * + * @param {String|Number} val + * @param {Object} [options] + * @throws {Error} throw an error if val is not a non-empty string or a number + * @return {String|Number} + * @api public + */ - assumeRoleWithSAML: function assumeRoleWithSAML(params, callback) { - return this.makeUnauthenticatedRequest('assumeRoleWithSAML', params, callback); - }, +module.exports = function (val, options) { + options = options || {}; + var type = typeof val; + if (type === 'string' && val.length > 0) { + return parse(val); + } else if (type === 'number' && isFinite(val)) { + return options.long ? fmtLong(val) : fmtShort(val); + } + throw new Error( + 'val is not a non-empty string or a valid number. val=' + + JSON.stringify(val) + ); +}; - /** - * @api private - */ - setupRequestListeners: function setupRequestListeners(request) { - request.addListener('validate', this.optInRegionalEndpoint, true); - }, +/** + * Parse the given `str` and return milliseconds. + * + * @param {String} str + * @return {Number} + * @api private + */ - /** - * @api private - */ - optInRegionalEndpoint: function optInRegionalEndpoint(req) { - var service = req.service; - var config = service.config; - config.stsRegionalEndpoints = resolveRegionalEndpointsFlag(service._originalConfig, { - env: ENV_REGIONAL_ENDPOINT_ENABLED, - sharedConfig: CONFIG_REGIONAL_ENDPOINT_ENABLED, - clientConfig: 'stsRegionalEndpoints' - }); - if ( - config.stsRegionalEndpoints === 'regional' && - service.isGlobalEndpoint - ) { - //client will throw if region is not supplied; request will be signed with specified region - if (!config.region) { - throw AWS.util.error(new Error(), - {code: 'ConfigError', message: 'Missing region in config'}); - } - var insertPoint = config.endpoint.indexOf('.amazonaws.com'); - var regionalEndpoint = config.endpoint.substring(0, insertPoint) + - '.' + config.region + config.endpoint.substring(insertPoint); - req.httpRequest.updateEndpoint(regionalEndpoint); - req.httpRequest.region = config.region; - } +function parse(str) { + str = String(str); + if (str.length > 100) { + return; + } + var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec( + str + ); + if (!match) { + return; + } + var n = parseFloat(match[1]); + var type = (match[2] || 'ms').toLowerCase(); + switch (type) { + case 'years': + case 'year': + case 'yrs': + case 'yr': + case 'y': + return n * y; + case 'weeks': + case 'week': + case 'w': + return n * w; + case 'days': + case 'day': + case 'd': + return n * d; + case 'hours': + case 'hour': + case 'hrs': + case 'hr': + case 'h': + return n * h; + case 'minutes': + case 'minute': + case 'mins': + case 'min': + case 'm': + return n * m; + case 'seconds': + case 'second': + case 'secs': + case 'sec': + case 's': + return n * s; + case 'milliseconds': + case 'millisecond': + case 'msecs': + case 'msec': + case 'ms': + return n; + default: + return undefined; } +} -}); +/** + * Short format for `ms`. + * + * @param {Number} ms + * @return {String} + * @api private + */ +function fmtShort(ms) { + var msAbs = Math.abs(ms); + if (msAbs >= d) { + return Math.round(ms / d) + 'd'; + } + if (msAbs >= h) { + return Math.round(ms / h) + 'h'; + } + if (msAbs >= m) { + return Math.round(ms / m) + 'm'; + } + if (msAbs >= s) { + return Math.round(ms / s) + 's'; + } + return ms + 'ms'; +} -/***/ }), +/** + * Long format for `ms`. + * + * @param {Number} ms + * @return {String} + * @api private + */ -/***/ 3862: -/***/ (function(module, __unusedexports, __webpack_require__) { +function fmtLong(ms) { + var msAbs = Math.abs(ms); + if (msAbs >= d) { + return plural(ms, msAbs, d, 'day'); + } + if (msAbs >= h) { + return plural(ms, msAbs, h, 'hour'); + } + if (msAbs >= m) { + return plural(ms, msAbs, m, 'minute'); + } + if (msAbs >= s) { + return plural(ms, msAbs, s, 'second'); + } + return ms + ' ms'; +} -var util = __webpack_require__(395).util; -var Transform = __webpack_require__(2413).Transform; -var allocBuffer = util.buffer.alloc; +/** + * Pluralization helper. + */ -/** @type {Transform} */ -function EventMessageChunkerStream(options) { - Transform.call(this, options); +function plural(ms, msAbs, n, name) { + var isPlural = msAbs >= n * 1.5; + return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : ''); +} - this.currentMessageTotalLength = 0; - this.currentMessagePendingLength = 0; - /** @type {Buffer} */ - this.currentMessage = null; - /** @type {Buffer} */ - this.messageLengthBuffer = null; -} +/***/ }), -EventMessageChunkerStream.prototype = Object.create(Transform.prototype); +/***/ 1450: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -/** - * - * @param {Buffer} chunk - * @param {string} encoding - * @param {*} callback - */ -EventMessageChunkerStream.prototype._transform = function(chunk, encoding, callback) { - var chunkLength = chunk.length; - var currentOffset = 0; - - while (currentOffset < chunkLength) { - // create new message if necessary - if (!this.currentMessage) { - // working on a new message, determine total length - var bytesRemaining = chunkLength - currentOffset; - // prevent edge case where total length spans 2 chunks - if (!this.messageLengthBuffer) { - this.messageLengthBuffer = allocBuffer(4); - } - var numBytesForTotal = Math.min( - 4 - this.currentMessagePendingLength, // remaining bytes to fill the messageLengthBuffer - bytesRemaining // bytes left in chunk - ); - - chunk.copy( - this.messageLengthBuffer, - this.currentMessagePendingLength, - currentOffset, - currentOffset + numBytesForTotal - ); - - this.currentMessagePendingLength += numBytesForTotal; - currentOffset += numBytesForTotal; - - if (this.currentMessagePendingLength < 4) { - // not enough information to create the current message - break; - } - this.allocateMessage(this.messageLengthBuffer.readUInt32BE(0)); - this.messageLengthBuffer = null; - } +"use strict"; - // write data into current message - var numBytesToWrite = Math.min( - this.currentMessageTotalLength - this.currentMessagePendingLength, // number of bytes left to complete message - chunkLength - currentOffset // number of bytes left in the original chunk - ); - chunk.copy( - this.currentMessage, // target buffer - this.currentMessagePendingLength, // target offset - currentOffset, // chunk offset - currentOffset + numBytesToWrite // chunk end to write - ); - this.currentMessagePendingLength += numBytesToWrite; - currentOffset += numBytesToWrite; +const os = __nccwpck_require__(857); +const tty = __nccwpck_require__(2018); +const hasFlag = __nccwpck_require__(3813); + +const {env} = process; + +let forceColor; +if (hasFlag('no-color') || + hasFlag('no-colors') || + hasFlag('color=false') || + hasFlag('color=never')) { + forceColor = 0; +} else if (hasFlag('color') || + hasFlag('colors') || + hasFlag('color=true') || + hasFlag('color=always')) { + forceColor = 1; +} - // check if a message is ready to be pushed - if (this.currentMessageTotalLength && this.currentMessageTotalLength === this.currentMessagePendingLength) { - // push out the message - this.push(this.currentMessage); - // cleanup - this.currentMessage = null; - this.currentMessageTotalLength = 0; - this.currentMessagePendingLength = 0; - } - } +if ('FORCE_COLOR' in env) { + if (env.FORCE_COLOR === 'true') { + forceColor = 1; + } else if (env.FORCE_COLOR === 'false') { + forceColor = 0; + } else { + forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3); + } +} - callback(); -}; +function translateLevel(level) { + if (level === 0) { + return false; + } + + return { + level, + hasBasic: true, + has256: level >= 2, + has16m: level >= 3 + }; +} -EventMessageChunkerStream.prototype._flush = function(callback) { - if (this.currentMessageTotalLength) { - if (this.currentMessageTotalLength === this.currentMessagePendingLength) { - callback(null, this.currentMessage); - } else { - callback(new Error('Truncated event message received.')); - } - } else { - callback(); - } -}; +function supportsColor(haveStream, streamIsTTY) { + if (forceColor === 0) { + return 0; + } + + if (hasFlag('color=16m') || + hasFlag('color=full') || + hasFlag('color=truecolor')) { + return 3; + } + + if (hasFlag('color=256')) { + return 2; + } + + if (haveStream && !streamIsTTY && forceColor === undefined) { + return 0; + } + + const min = forceColor || 0; + + if (env.TERM === 'dumb') { + return min; + } + + if (process.platform === 'win32') { + // Windows 10 build 10586 is the first Windows release that supports 256 colors. + // Windows 10 build 14931 is the first release that supports 16m/TrueColor. + const osRelease = os.release().split('.'); + if ( + Number(osRelease[0]) >= 10 && + Number(osRelease[2]) >= 10586 + ) { + return Number(osRelease[2]) >= 14931 ? 3 : 2; + } + + return 1; + } + + if ('CI' in env) { + if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'GITHUB_ACTIONS', 'BUILDKITE'].some(sign => sign in env) || env.CI_NAME === 'codeship') { + return 1; + } + + return min; + } + + if ('TEAMCITY_VERSION' in env) { + return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0; + } + + if (env.COLORTERM === 'truecolor') { + return 3; + } + + if ('TERM_PROGRAM' in env) { + const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10); + + switch (env.TERM_PROGRAM) { + case 'iTerm.app': + return version >= 3 ? 3 : 2; + case 'Apple_Terminal': + return 2; + // No default + } + } + + if (/-256(color)?$/i.test(env.TERM)) { + return 2; + } + + if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) { + return 1; + } + + if ('COLORTERM' in env) { + return 1; + } + + return min; +} -/** - * @param {number} size Size of the message to be allocated. - * @api private - */ -EventMessageChunkerStream.prototype.allocateMessage = function(size) { - if (typeof size !== 'number') { - throw new Error('Attempted to allocate an event message where size was not a number: ' + size); - } - this.currentMessageTotalLength = size; - this.currentMessagePendingLength = 4; - this.currentMessage = allocBuffer(size); - this.currentMessage.writeUInt32BE(size, 0); -}; +function getSupportLevel(stream) { + const level = supportsColor(stream, stream && stream.isTTY); + return translateLevel(level); +} -/** - * @api private - */ module.exports = { - EventMessageChunkerStream: EventMessageChunkerStream + supportsColor: getSupportLevel, + stdout: translateLevel(supportsColor(true, tty.isatty(1))), + stderr: translateLevel(supportsColor(true, tty.isatty(2))) }; /***/ }), -/***/ 3877: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['ec2'] = {}; -AWS.EC2 = Service.defineService('ec2', ['2013-06-15*', '2013-10-15*', '2014-02-01*', '2014-05-01*', '2014-06-15*', '2014-09-01*', '2014-10-01*', '2015-03-01*', '2015-04-15*', '2015-10-01*', '2016-04-01*', '2016-09-15*', '2016-11-15']); -__webpack_require__(6925); -Object.defineProperty(apiLoader.services['ec2'], '2016-11-15', { - get: function get() { - var model = __webpack_require__(9206); - model.paginators = __webpack_require__(47).pagination; - model.waiters = __webpack_require__(1511).waiters; - return model; - }, - enumerable: true, - configurable: true -}); +/***/ 1860: +/***/ ((module) => { + +/****************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ +/* global global, define, Symbol, Reflect, Promise, SuppressedError, Iterator */ +var __extends; +var __assign; +var __rest; +var __decorate; +var __param; +var __esDecorate; +var __runInitializers; +var __propKey; +var __setFunctionName; +var __metadata; +var __awaiter; +var __generator; +var __exportStar; +var __values; +var __read; +var __spread; +var __spreadArrays; +var __spreadArray; +var __await; +var __asyncGenerator; +var __asyncDelegator; +var __asyncValues; +var __makeTemplateObject; +var __importStar; +var __importDefault; +var __classPrivateFieldGet; +var __classPrivateFieldSet; +var __classPrivateFieldIn; +var __createBinding; +var __addDisposableResource; +var __disposeResources; +var __rewriteRelativeImportExtension; +(function (factory) { + var root = typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : {}; + if (typeof define === "function" && define.amd) { + define("tslib", ["exports"], function (exports) { factory(createExporter(root, createExporter(exports))); }); + } + else if ( true && typeof module.exports === "object") { + factory(createExporter(root, createExporter(module.exports))); + } + else { + factory(createExporter(root)); + } + function createExporter(exports, previous) { + if (exports !== root) { + if (typeof Object.create === "function") { + Object.defineProperty(exports, "__esModule", { value: true }); + } + else { + exports.__esModule = true; + } + } + return function (id, v) { return exports[id] = previous ? previous(id, v) : v; }; + } +}) +(function (exporter) { + var extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + + __extends = function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; + + __assign = Object.assign || function (t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p]; + } + return t; + }; + + __rest = function (s, e) { + var t = {}; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) + t[p] = s[p]; + if (s != null && typeof Object.getOwnPropertySymbols === "function") + for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { + if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) + t[p[i]] = s[p[i]]; + } + return t; + }; + + __decorate = function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; + }; + + __param = function (paramIndex, decorator) { + return function (target, key) { decorator(target, key, paramIndex); } + }; + + __esDecorate = function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) { + function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; } + var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value"; + var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null; + var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {}); + var _, done = false; + for (var i = decorators.length - 1; i >= 0; i--) { + var context = {}; + for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p]; + for (var p in contextIn.access) context.access[p] = contextIn.access[p]; + context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); }; + var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context); + if (kind === "accessor") { + if (result === void 0) continue; + if (result === null || typeof result !== "object") throw new TypeError("Object expected"); + if (_ = accept(result.get)) descriptor.get = _; + if (_ = accept(result.set)) descriptor.set = _; + if (_ = accept(result.init)) initializers.unshift(_); + } + else if (_ = accept(result)) { + if (kind === "field") initializers.unshift(_); + else descriptor[key] = _; + } + } + if (target) Object.defineProperty(target, contextIn.name, descriptor); + done = true; + }; + + __runInitializers = function (thisArg, initializers, value) { + var useValue = arguments.length > 2; + for (var i = 0; i < initializers.length; i++) { + value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg); + } + return useValue ? value : void 0; + }; + + __propKey = function (x) { + return typeof x === "symbol" ? x : "".concat(x); + }; + + __setFunctionName = function (f, name, prefix) { + if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : ""; + return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name }); + }; + + __metadata = function (metadataKey, metadataValue) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue); + }; + + __awaiter = function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); + }; + + __generator = function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype); + return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (g && (g = 0, op[0] && (_ = 0)), _) try { + if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [op[0] & 2, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } + }; + + __exportStar = function(m, o) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p); + }; + + __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]; + }); + + __values = function (o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); + }; + + __read = function (o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; + }; + + /** @deprecated */ + __spread = function () { + for (var ar = [], i = 0; i < arguments.length; i++) + ar = ar.concat(__read(arguments[i])); + return ar; + }; + + /** @deprecated */ + __spreadArrays = function () { + for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; + for (var r = Array(s), k = 0, i = 0; i < il; i++) + for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) + r[k] = a[j]; + return r; + }; + + __spreadArray = function (to, from, pack) { + if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) { + if (ar || !(i in from)) { + if (!ar) ar = Array.prototype.slice.call(from, 0, i); + ar[i] = from[i]; + } + } + return to.concat(ar || Array.prototype.slice.call(from)); + }; + + __await = function (v) { + return this instanceof __await ? (this.v = v, this) : new __await(v); + }; + + __asyncGenerator = function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var g = generator.apply(thisArg, _arguments || []), i, q = []; + return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i; + function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; } + function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } } + function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); } + }; + + __asyncDelegator = function (o) { + var i, p; + return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i; + function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; } + }; + + __asyncValues = function (o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator], i; + return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i); + function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; } + function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); } + }; + + __makeTemplateObject = function (cooked, raw) { + if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; } + return cooked; + }; + + var __setModuleDefault = Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + }) : function(o, v) { + o["default"] = v; + }; + + 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); + }; + + __importStar = 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; + }; + + __importDefault = function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; + }; + + __classPrivateFieldGet = function (receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); + }; + + __classPrivateFieldSet = function (receiver, state, value, kind, f) { + if (kind === "m") throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value; + }; + + __classPrivateFieldIn = function (state, receiver) { + if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object"); + return typeof state === "function" ? receiver === state : state.has(receiver); + }; + + __addDisposableResource = function (env, value, async) { + if (value !== null && value !== void 0) { + if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected."); + var dispose, inner; + if (async) { + if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined."); + dispose = value[Symbol.asyncDispose]; + } + if (dispose === void 0) { + if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined."); + dispose = value[Symbol.dispose]; + if (async) inner = dispose; + } + if (typeof dispose !== "function") throw new TypeError("Object not disposable."); + if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } }; + env.stack.push({ value: value, dispose: dispose, async: async }); + } + else if (async) { + env.stack.push({ async: true }); + } + return value; + }; + + var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; + }; + + __disposeResources = function (env) { + function fail(e) { + env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e; + env.hasError = true; + } + var r, s = 0; + function next() { + while (r = env.stack.pop()) { + try { + if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next); + if (r.dispose) { + var result = r.dispose.call(r.value); + if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); }); + } + else s |= 1; + } + catch (e) { + fail(e); + } + } + if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve(); + if (env.hasError) throw env.error; + } + return next(); + }; + + __rewriteRelativeImportExtension = function (path, preserveJsx) { + if (typeof path === "string" && /^\.\.?\//.test(path)) { + return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) { + return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js"); + }); + } + return path; + }; + + exporter("__extends", __extends); + exporter("__assign", __assign); + exporter("__rest", __rest); + exporter("__decorate", __decorate); + exporter("__param", __param); + exporter("__esDecorate", __esDecorate); + exporter("__runInitializers", __runInitializers); + exporter("__propKey", __propKey); + exporter("__setFunctionName", __setFunctionName); + exporter("__metadata", __metadata); + exporter("__awaiter", __awaiter); + exporter("__generator", __generator); + exporter("__exportStar", __exportStar); + exporter("__createBinding", __createBinding); + exporter("__values", __values); + exporter("__read", __read); + exporter("__spread", __spread); + exporter("__spreadArrays", __spreadArrays); + exporter("__spreadArray", __spreadArray); + exporter("__await", __await); + exporter("__asyncGenerator", __asyncGenerator); + exporter("__asyncDelegator", __asyncDelegator); + exporter("__asyncValues", __asyncValues); + exporter("__makeTemplateObject", __makeTemplateObject); + exporter("__importStar", __importStar); + exporter("__importDefault", __importDefault); + exporter("__classPrivateFieldGet", __classPrivateFieldGet); + exporter("__classPrivateFieldSet", __classPrivateFieldSet); + exporter("__classPrivateFieldIn", __classPrivateFieldIn); + exporter("__addDisposableResource", __addDisposableResource); + exporter("__disposeResources", __disposeResources); + exporter("__rewriteRelativeImportExtension", __rewriteRelativeImportExtension); +}); + +0 && (0); + + +/***/ }), + +/***/ 770: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +module.exports = __nccwpck_require__(218); + + +/***/ }), + +/***/ 218: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { -module.exports = AWS.EC2; +"use strict"; -/***/ }), +var net = __nccwpck_require__(9278); +var tls = __nccwpck_require__(4756); +var http = __nccwpck_require__(8611); +var https = __nccwpck_require__(5692); +var events = __nccwpck_require__(4434); +var assert = __nccwpck_require__(2613); +var util = __nccwpck_require__(9023); -/***/ 3881: -/***/ (function(module) { -module.exports = {"version":"2.0","metadata":{"apiVersion":"2019-06-10","endpointPrefix":"portal.sso","jsonVersion":"1.1","protocol":"rest-json","serviceAbbreviation":"SSO","serviceFullName":"AWS Single Sign-On","serviceId":"SSO","signatureVersion":"v4","signingName":"awsssoportal","uid":"sso-2019-06-10"},"operations":{"GetRoleCredentials":{"http":{"method":"GET","requestUri":"/federation/credentials"},"input":{"type":"structure","required":["roleName","accountId","accessToken"],"members":{"roleName":{"location":"querystring","locationName":"role_name"},"accountId":{"location":"querystring","locationName":"account_id"},"accessToken":{"shape":"S4","location":"header","locationName":"x-amz-sso_bearer_token"}}},"output":{"type":"structure","members":{"roleCredentials":{"type":"structure","members":{"accessKeyId":{},"secretAccessKey":{"type":"string","sensitive":true},"sessionToken":{"type":"string","sensitive":true},"expiration":{"type":"long"}}}}},"authtype":"none"},"ListAccountRoles":{"http":{"method":"GET","requestUri":"/assignment/roles"},"input":{"type":"structure","required":["accessToken","accountId"],"members":{"nextToken":{"location":"querystring","locationName":"next_token"},"maxResults":{"location":"querystring","locationName":"max_result","type":"integer"},"accessToken":{"shape":"S4","location":"header","locationName":"x-amz-sso_bearer_token"},"accountId":{"location":"querystring","locationName":"account_id"}}},"output":{"type":"structure","members":{"nextToken":{},"roleList":{"type":"list","member":{"type":"structure","members":{"roleName":{},"accountId":{}}}}}},"authtype":"none"},"ListAccounts":{"http":{"method":"GET","requestUri":"/assignment/accounts"},"input":{"type":"structure","required":["accessToken"],"members":{"nextToken":{"location":"querystring","locationName":"next_token"},"maxResults":{"location":"querystring","locationName":"max_result","type":"integer"},"accessToken":{"shape":"S4","location":"header","locationName":"x-amz-sso_bearer_token"}}},"output":{"type":"structure","members":{"nextToken":{},"accountList":{"type":"list","member":{"type":"structure","members":{"accountId":{},"accountName":{},"emailAddress":{}}}}}},"authtype":"none"},"Logout":{"http":{"requestUri":"/logout"},"input":{"type":"structure","required":["accessToken"],"members":{"accessToken":{"shape":"S4","location":"header","locationName":"x-amz-sso_bearer_token"}}},"authtype":"none"}},"shapes":{"S4":{"type":"string","sensitive":true}}}; +exports.httpOverHttp = httpOverHttp; +exports.httpsOverHttp = httpsOverHttp; +exports.httpOverHttps = httpOverHttps; +exports.httpsOverHttps = httpsOverHttps; -/***/ }), -/***/ 3916: -/***/ (function(module) { +function httpOverHttp(options) { + var agent = new TunnelingAgent(options); + agent.request = http.request; + return agent; +} -module.exports = {"pagination":{"DescribeDBEngineVersions":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DBEngineVersions"},"DescribeDBInstances":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DBInstances"},"DescribeDBParameterGroups":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DBParameterGroups"},"DescribeDBParameters":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"Parameters"},"DescribeDBSubnetGroups":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"DBSubnetGroups"},"DescribeEngineDefaultParameters":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"EngineDefaults.Marker","result_key":"EngineDefaults.Parameters"},"DescribeEventSubscriptions":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"EventSubscriptionsList"},"DescribeEvents":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"Events"},"DescribeOrderableDBInstanceOptions":{"input_token":"Marker","limit_key":"MaxRecords","output_token":"Marker","result_key":"OrderableDBInstanceOptions"},"ListTagsForResource":{"result_key":"TagList"}}}; +function httpsOverHttp(options) { + var agent = new TunnelingAgent(options); + agent.request = http.request; + agent.createSocket = createSecureSocket; + agent.defaultPort = 443; + return agent; +} -/***/ }), +function httpOverHttps(options) { + var agent = new TunnelingAgent(options); + agent.request = https.request; + return agent; +} -/***/ 3964: -/***/ (function(module, __unusedexports, __webpack_require__) { +function httpsOverHttps(options) { + var agent = new TunnelingAgent(options); + agent.request = https.request; + agent.createSocket = createSecureSocket; + agent.defaultPort = 443; + return agent; +} -var Shape = __webpack_require__(3682); -var util = __webpack_require__(153); -var property = util.property; -var memoizedProperty = util.memoizedProperty; +function TunnelingAgent(options) { + var self = this; + self.options = options || {}; + self.proxyOptions = self.options.proxy || {}; + self.maxSockets = self.options.maxSockets || http.Agent.defaultMaxSockets; + self.requests = []; + self.sockets = []; + + self.on('free', function onFree(socket, host, port, localAddress) { + var options = toOptions(host, port, localAddress); + for (var i = 0, len = self.requests.length; i < len; ++i) { + var pending = self.requests[i]; + if (pending.host === options.host && pending.port === options.port) { + // Detect the request to connect same origin server, + // reuse the connection. + self.requests.splice(i, 1); + pending.request.onSocket(socket); + return; + } + } + socket.destroy(); + self.removeSocket(socket); + }); +} +util.inherits(TunnelingAgent, events.EventEmitter); -function Operation(name, operation, options) { +TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) { var self = this; - options = options || {}; + var options = mergeOptions({request: req}, self.options, toOptions(host, port, localAddress)); - property(this, 'name', operation.name || name); - property(this, 'api', options.api, false); - - operation.http = operation.http || {}; - property(this, 'endpoint', operation.endpoint); - property(this, 'httpMethod', operation.http.method || 'POST'); - property(this, 'httpPath', operation.http.requestUri || '/'); - property(this, 'authtype', operation.authtype || ''); - property( - this, - 'endpointDiscoveryRequired', - operation.endpointdiscovery ? - (operation.endpointdiscovery.required ? 'REQUIRED' : 'OPTIONAL') : - 'NULL' - ); + if (self.sockets.length >= this.maxSockets) { + // We are over limit so we'll add it to the queue. + self.requests.push(options); + return; + } - memoizedProperty(this, 'input', function() { - if (!operation.input) { - return new Shape.create({type: 'structure'}, options); + // If we are under maxSockets create a new one. + self.createSocket(options, function(socket) { + socket.on('free', onFree); + socket.on('close', onCloseOrRemove); + socket.on('agentRemove', onCloseOrRemove); + req.onSocket(socket); + + function onFree() { + self.emit('free', socket, options); } - return Shape.create(operation.input, options); - }); - memoizedProperty(this, 'output', function() { - if (!operation.output) { - return new Shape.create({type: 'structure'}, options); + function onCloseOrRemove(err) { + self.removeSocket(socket); + socket.removeListener('free', onFree); + socket.removeListener('close', onCloseOrRemove); + socket.removeListener('agentRemove', onCloseOrRemove); } - return Shape.create(operation.output, options); }); +}; - memoizedProperty(this, 'errors', function() { - var list = []; - if (!operation.errors) return null; +TunnelingAgent.prototype.createSocket = function createSocket(options, cb) { + var self = this; + var placeholder = {}; + self.sockets.push(placeholder); - for (var i = 0; i < operation.errors.length; i++) { - list.push(Shape.create(operation.errors[i], options)); + var connectOptions = mergeOptions({}, self.proxyOptions, { + method: 'CONNECT', + path: options.host + ':' + options.port, + agent: false, + headers: { + host: options.host + ':' + options.port } - - return list; }); + if (options.localAddress) { + connectOptions.localAddress = options.localAddress; + } + if (connectOptions.proxyAuth) { + connectOptions.headers = connectOptions.headers || {}; + connectOptions.headers['Proxy-Authorization'] = 'Basic ' + + new Buffer(connectOptions.proxyAuth).toString('base64'); + } - memoizedProperty(this, 'paginator', function() { - return options.api.paginators[name]; - }); + debug('making CONNECT request'); + var connectReq = self.request(connectOptions); + connectReq.useChunkedEncodingByDefault = false; // for v0.6 + connectReq.once('response', onResponse); // for v0.6 + connectReq.once('upgrade', onUpgrade); // for v0.6 + connectReq.once('connect', onConnect); // for v0.7 or later + connectReq.once('error', onError); + connectReq.end(); + + function onResponse(res) { + // Very hacky. This is necessary to avoid http-parser leaks. + res.upgrade = true; + } - if (options.documentation) { - property(this, 'documentation', operation.documentation); - property(this, 'documentationUrl', operation.documentationUrl); + function onUpgrade(res, socket, head) { + // Hacky. + process.nextTick(function() { + onConnect(res, socket, head); + }); } - // idempotentMembers only tracks top-level input shapes - memoizedProperty(this, 'idempotentMembers', function() { - var idempotentMembers = []; - var input = self.input; - var members = input.members; - if (!input.members) { - return idempotentMembers; + function onConnect(res, socket, head) { + connectReq.removeAllListeners(); + socket.removeAllListeners(); + + if (res.statusCode !== 200) { + debug('tunneling socket could not be established, statusCode=%d', + res.statusCode); + socket.destroy(); + var error = new Error('tunneling socket could not be established, ' + + 'statusCode=' + res.statusCode); + error.code = 'ECONNRESET'; + options.request.emit('error', error); + self.removeSocket(placeholder); + return; } - for (var name in members) { - if (!members.hasOwnProperty(name)) { - continue; - } - if (members[name].isIdempotent === true) { - idempotentMembers.push(name); - } + if (head.length > 0) { + debug('got illegal response body from proxy'); + socket.destroy(); + var error = new Error('got illegal response body from proxy'); + error.code = 'ECONNRESET'; + options.request.emit('error', error); + self.removeSocket(placeholder); + return; } - return idempotentMembers; - }); - - memoizedProperty(this, 'hasEventOutput', function() { - var output = self.output; - return hasEventStream(output); - }); -} + debug('tunneling connection has established'); + self.sockets[self.sockets.indexOf(placeholder)] = socket; + return cb(socket); + } -function hasEventStream(topLevelShape) { - var members = topLevelShape.members; - var payload = topLevelShape.payload; + function onError(cause) { + connectReq.removeAllListeners(); - if (!topLevelShape.members) { - return false; + debug('tunneling socket could not be established, cause=%s\n', + cause.message, cause.stack); + var error = new Error('tunneling socket could not be established, ' + + 'cause=' + cause.message); + error.code = 'ECONNRESET'; + options.request.emit('error', error); + self.removeSocket(placeholder); } +}; - if (payload) { - var payloadMember = members[payload]; - return payloadMember.isEventStream; +TunnelingAgent.prototype.removeSocket = function removeSocket(socket) { + var pos = this.sockets.indexOf(socket) + if (pos === -1) { + return; } - - // check if any member is an event stream - for (var name in members) { - if (!members.hasOwnProperty(name)) { - if (members[name].isEventStream === true) { - return true; - } - } + this.sockets.splice(pos, 1); + + var pending = this.requests.shift(); + if (pending) { + // If we have pending requests and a socket gets closed a new one + // needs to be created to take over in the pool for the one that closed. + this.createSocket(pending, function(socket) { + pending.request.onSocket(socket); + }); } - return false; -} - -/** - * @api private - */ -module.exports = Operation; +}; +function createSecureSocket(options, cb) { + var self = this; + TunnelingAgent.prototype.createSocket.call(self, options, function(socket) { + var hostHeader = options.request.getHeader('host'); + var tlsOptions = mergeOptions({}, self.options, { + socket: socket, + servername: hostHeader ? hostHeader.replace(/:.*$/, '') : options.host + }); -/***/ }), + // 0 is dummy port for v0.6 + var secureSocket = tls.connect(0, tlsOptions); + self.sockets[self.sockets.indexOf(socket)] = secureSocket; + cb(secureSocket); + }); +} -/***/ 3977: -/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) { -var AWS = __webpack_require__(395); +function toOptions(host, port, localAddress) { + if (typeof host === 'string') { // since v0.10 + return { + host: host, + port: port, + localAddress: localAddress + }; + } + return host; // for v0.11 or later +} -/** - * @api private - */ -AWS.ParamValidator = AWS.util.inherit({ - /** - * Create a new validator object. - * - * @param validation [Boolean|map] whether input parameters should be - * validated against the operation description before sending the - * request. Pass a map to enable any of the following specific - * validation features: - * - * * **min** [Boolean] — Validates that a value meets the min - * constraint. This is enabled by default when paramValidation is set - * to `true`. - * * **max** [Boolean] — Validates that a value meets the max - * constraint. - * * **pattern** [Boolean] — Validates that a string value matches a - * regular expression. - * * **enum** [Boolean] — Validates that a string value matches one - * of the allowable enum values. - */ - constructor: function ParamValidator(validation) { - if (validation === true || validation === undefined) { - validation = {'min': true}; +function mergeOptions(target) { + for (var i = 1, len = arguments.length; i < len; ++i) { + var overrides = arguments[i]; + if (typeof overrides === 'object') { + var keys = Object.keys(overrides); + for (var j = 0, keyLen = keys.length; j < keyLen; ++j) { + var k = keys[j]; + if (overrides[k] !== undefined) { + target[k] = overrides[k]; + } + } } - this.validation = validation; - }, + } + return target; +} - validate: function validate(shape, params, context) { - this.errors = []; - this.validateMember(shape, params || {}, context || 'params'); - - if (this.errors.length > 1) { - var msg = this.errors.join('\n* '); - msg = 'There were ' + this.errors.length + - ' validation errors:\n* ' + msg; - throw AWS.util.error(new Error(msg), - {code: 'MultipleValidationErrors', errors: this.errors}); - } else if (this.errors.length === 1) { - throw this.errors[0]; + +var debug; +if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) { + debug = function() { + var args = Array.prototype.slice.call(arguments); + if (typeof args[0] === 'string') { + args[0] = 'TUNNEL: ' + args[0]; } else { - return true; + args.unshift('TUNNEL:'); } - }, - - fail: function fail(code, message) { - this.errors.push(AWS.util.error(new Error(message), {code: code})); - }, - - validateStructure: function validateStructure(shape, params, context) { - this.validateType(params, context, ['object'], 'structure'); + console.error.apply(console, args); + } +} else { + debug = function() {}; +} +exports.debug = debug; // for test - var paramName; - for (var i = 0; shape.required && i < shape.required.length; i++) { - paramName = shape.required[i]; - var value = params[paramName]; - if (value === undefined || value === null) { - this.fail('MissingRequiredParameter', - 'Missing required key \'' + paramName + '\' in ' + context); - } - } - // validate hash members - for (paramName in params) { - if (!Object.prototype.hasOwnProperty.call(params, paramName)) continue; +/***/ }), - var paramValue = params[paramName], - memberShape = shape.members[paramName]; +/***/ 6752: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - if (memberShape !== undefined) { - var memberContext = [context, paramName].join('.'); - this.validateMember(memberShape, paramValue, memberContext); - } else { - this.fail('UnexpectedParameter', - 'Unexpected key \'' + paramName + '\' found in ' + context); - } - } +"use strict"; - return true; - }, - validateMember: function validateMember(shape, param, context) { - switch (shape.type) { - case 'structure': - return this.validateStructure(shape, param, context); - case 'list': - return this.validateList(shape, param, context); - case 'map': - return this.validateMap(shape, param, context); - default: - return this.validateScalar(shape, param, context); - } - }, +const Client = __nccwpck_require__(3701) +const Dispatcher = __nccwpck_require__(883) +const Pool = __nccwpck_require__(628) +const BalancedPool = __nccwpck_require__(837) +const Agent = __nccwpck_require__(7405) +const ProxyAgent = __nccwpck_require__(6672) +const EnvHttpProxyAgent = __nccwpck_require__(3137) +const RetryAgent = __nccwpck_require__(50) +const errors = __nccwpck_require__(8707) +const util = __nccwpck_require__(3440) +const { InvalidArgumentError } = errors +const api = __nccwpck_require__(6615) +const buildConnector = __nccwpck_require__(9136) +const MockClient = __nccwpck_require__(7365) +const MockAgent = __nccwpck_require__(7501) +const MockPool = __nccwpck_require__(4004) +const mockErrors = __nccwpck_require__(2429) +const RetryHandler = __nccwpck_require__(7816) +const { getGlobalDispatcher, setGlobalDispatcher } = __nccwpck_require__(2581) +const DecoratorHandler = __nccwpck_require__(8155) +const RedirectHandler = __nccwpck_require__(8754) +const createRedirectInterceptor = __nccwpck_require__(5092) + +Object.assign(Dispatcher.prototype, api) + +module.exports.Dispatcher = Dispatcher +module.exports.Client = Client +module.exports.Pool = Pool +module.exports.BalancedPool = BalancedPool +module.exports.Agent = Agent +module.exports.ProxyAgent = ProxyAgent +module.exports.EnvHttpProxyAgent = EnvHttpProxyAgent +module.exports.RetryAgent = RetryAgent +module.exports.RetryHandler = RetryHandler + +module.exports.DecoratorHandler = DecoratorHandler +module.exports.RedirectHandler = RedirectHandler +module.exports.createRedirectInterceptor = createRedirectInterceptor +module.exports.interceptors = { + redirect: __nccwpck_require__(1514), + retry: __nccwpck_require__(2026), + dump: __nccwpck_require__(8060), + dns: __nccwpck_require__(379) +} - validateList: function validateList(shape, params, context) { - if (this.validateType(params, context, [Array])) { - this.validateRange(shape, params.length, context, 'list member count'); - // validate array members - for (var i = 0; i < params.length; i++) { - this.validateMember(shape.member, params[i], context + '[' + i + ']'); - } - } - }, +module.exports.buildConnector = buildConnector +module.exports.errors = errors +module.exports.util = { + parseHeaders: util.parseHeaders, + headerNameToString: util.headerNameToString +} - validateMap: function validateMap(shape, params, context) { - if (this.validateType(params, context, ['object'], 'map')) { - // Build up a count of map members to validate range traits. - var mapCount = 0; - for (var param in params) { - if (!Object.prototype.hasOwnProperty.call(params, param)) continue; - // Validate any map key trait constraints - this.validateMember(shape.key, param, - context + '[key=\'' + param + '\']'); - this.validateMember(shape.value, params[param], - context + '[\'' + param + '\']'); - mapCount++; - } - this.validateRange(shape, mapCount, context, 'map member count'); +function makeDispatcher (fn) { + return (url, opts, handler) => { + if (typeof opts === 'function') { + handler = opts + opts = null } - }, - validateScalar: function validateScalar(shape, value, context) { - switch (shape.type) { - case null: - case undefined: - case 'string': - return this.validateString(shape, value, context); - case 'base64': - case 'binary': - return this.validatePayload(value, context); - case 'integer': - case 'float': - return this.validateNumber(shape, value, context); - case 'boolean': - return this.validateType(value, context, ['boolean']); - case 'timestamp': - return this.validateType(value, context, [Date, - /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/, 'number'], - 'Date object, ISO-8601 string, or a UNIX timestamp'); - default: - return this.fail('UnkownType', 'Unhandled type ' + - shape.type + ' for ' + context); + if (!url || (typeof url !== 'string' && typeof url !== 'object' && !(url instanceof URL))) { + throw new InvalidArgumentError('invalid url') } - }, - validateString: function validateString(shape, value, context) { - var validTypes = ['string']; - if (shape.isJsonValue) { - validTypes = validTypes.concat(['number', 'object', 'boolean']); + if (opts != null && typeof opts !== 'object') { + throw new InvalidArgumentError('invalid opts') } - if (value !== null && this.validateType(value, context, validTypes)) { - this.validateEnum(shape, value, context); - this.validateRange(shape, value.length, context, 'string length'); - this.validatePattern(shape, value, context); - this.validateUri(shape, value, context); - } - }, - validateUri: function validateUri(shape, value, context) { - if (shape['location'] === 'uri') { - if (value.length === 0) { - this.fail('UriParameterError', 'Expected uri parameter to have length >= 1,' - + ' but found "' + value +'" for ' + context); + if (opts && opts.path != null) { + if (typeof opts.path !== 'string') { + throw new InvalidArgumentError('invalid opts.path') } - } - }, - validatePattern: function validatePattern(shape, value, context) { - if (this.validation['pattern'] && shape['pattern'] !== undefined) { - if (!(new RegExp(shape['pattern'])).test(value)) { - this.fail('PatternMatchError', 'Provided value "' + value + '" ' - + 'does not match regex pattern /' + shape['pattern'] + '/ for ' - + context); + let path = opts.path + if (!opts.path.startsWith('/')) { + path = `/${path}` } - } - }, - validateRange: function validateRange(shape, value, context, descriptor) { - if (this.validation['min']) { - if (shape['min'] !== undefined && value < shape['min']) { - this.fail('MinRangeError', 'Expected ' + descriptor + ' >= ' - + shape['min'] + ', but found ' + value + ' for ' + context); - } - } - if (this.validation['max']) { - if (shape['max'] !== undefined && value > shape['max']) { - this.fail('MaxRangeError', 'Expected ' + descriptor + ' <= ' - + shape['max'] + ', but found ' + value + ' for ' + context); + url = new URL(util.parseOrigin(url).origin + path) + } else { + if (!opts) { + opts = typeof url === 'object' ? url : {} } - } - }, - validateEnum: function validateRange(shape, value, context) { - if (this.validation['enum'] && shape['enum'] !== undefined) { - // Fail if the string value is not present in the enum list - if (shape['enum'].indexOf(value) === -1) { - this.fail('EnumError', 'Found string value of ' + value + ', but ' - + 'expected ' + shape['enum'].join('|') + ' for ' + context); - } + url = util.parseURL(url) } - }, - validateType: function validateType(value, context, acceptedTypes, type) { - // We will not log an error for null or undefined, but we will return - // false so that callers know that the expected type was not strictly met. - if (value === null || value === undefined) return false; - - var foundInvalidType = false; - for (var i = 0; i < acceptedTypes.length; i++) { - if (typeof acceptedTypes[i] === 'string') { - if (typeof value === acceptedTypes[i]) return true; - } else if (acceptedTypes[i] instanceof RegExp) { - if ((value || '').toString().match(acceptedTypes[i])) return true; - } else { - if (value instanceof acceptedTypes[i]) return true; - if (AWS.util.isType(value, acceptedTypes[i])) return true; - if (!type && !foundInvalidType) acceptedTypes = acceptedTypes.slice(); - acceptedTypes[i] = AWS.util.typeName(acceptedTypes[i]); - } - foundInvalidType = true; - } + const { agent, dispatcher = getGlobalDispatcher() } = opts - var acceptedType = type; - if (!acceptedType) { - acceptedType = acceptedTypes.join(', ').replace(/,([^,]+)$/, ', or$1'); + if (agent) { + throw new InvalidArgumentError('unsupported opts.agent. Did you mean opts.client?') } - var vowel = acceptedType.match(/^[aeiou]/i) ? 'n' : ''; - this.fail('InvalidParameterType', 'Expected ' + context + ' to be a' + - vowel + ' ' + acceptedType); - return false; - }, - - validateNumber: function validateNumber(shape, value, context) { - if (value === null || value === undefined) return; - if (typeof value === 'string') { - var castedValue = parseFloat(value); - if (castedValue.toString() === value) value = castedValue; - } - if (this.validateType(value, context, ['number'])) { - this.validateRange(shape, value, context, 'numeric value'); - } - }, + return fn.call(dispatcher, { + ...opts, + origin: url.origin, + path: url.search ? `${url.pathname}${url.search}` : url.pathname, + method: opts.method || (opts.body ? 'PUT' : 'GET') + }, handler) + } +} - validatePayload: function validatePayload(value, context) { - if (value === null || value === undefined) return; - if (typeof value === 'string') return; - if (value && typeof value.byteLength === 'number') return; // typed arrays - if (AWS.util.isNode()) { // special check for buffer/stream in Node.js - var Stream = AWS.util.stream.Stream; - if (AWS.util.Buffer.isBuffer(value) || value instanceof Stream) return; - } else { - if (typeof Blob !== void 0 && value instanceof Blob) return; - } +module.exports.setGlobalDispatcher = setGlobalDispatcher +module.exports.getGlobalDispatcher = getGlobalDispatcher - var types = ['Buffer', 'Stream', 'File', 'Blob', 'ArrayBuffer', 'DataView']; - if (value) { - for (var i = 0; i < types.length; i++) { - if (AWS.util.isType(value, types[i])) return; - if (AWS.util.typeName(value.constructor) === types[i]) return; - } +const fetchImpl = (__nccwpck_require__(4398).fetch) +module.exports.fetch = async function fetch (init, options = undefined) { + try { + return await fetchImpl(init, options) + } catch (err) { + if (err && typeof err === 'object') { + Error.captureStackTrace(err) } - this.fail('InvalidParameterType', 'Expected ' + context + ' to be a ' + - 'string, Buffer, Stream, Blob, or typed array object'); + throw err } -}); +} +module.exports.Headers = __nccwpck_require__(660).Headers +module.exports.Response = __nccwpck_require__(9051).Response +module.exports.Request = __nccwpck_require__(9967).Request +module.exports.FormData = __nccwpck_require__(5910).FormData +module.exports.File = globalThis.File ?? (__nccwpck_require__(4573).File) +module.exports.FileReader = __nccwpck_require__(8355).FileReader +const { setGlobalOrigin, getGlobalOrigin } = __nccwpck_require__(1059) -/***/ }), +module.exports.setGlobalOrigin = setGlobalOrigin +module.exports.getGlobalOrigin = getGlobalOrigin -/***/ 3985: -/***/ (function(module) { +const { CacheStorage } = __nccwpck_require__(3245) +const { kConstruct } = __nccwpck_require__(109) -module.exports = {"version":"2.0","metadata":{"apiVersion":"2010-03-31","endpointPrefix":"sns","protocol":"query","serviceAbbreviation":"Amazon SNS","serviceFullName":"Amazon Simple Notification Service","serviceId":"SNS","signatureVersion":"v4","uid":"sns-2010-03-31","xmlNamespace":"http://sns.amazonaws.com/doc/2010-03-31/"},"operations":{"AddPermission":{"input":{"type":"structure","required":["TopicArn","Label","AWSAccountId","ActionName"],"members":{"TopicArn":{},"Label":{},"AWSAccountId":{"type":"list","member":{}},"ActionName":{"type":"list","member":{}}}}},"CheckIfPhoneNumberIsOptedOut":{"input":{"type":"structure","required":["phoneNumber"],"members":{"phoneNumber":{}}},"output":{"resultWrapper":"CheckIfPhoneNumberIsOptedOutResult","type":"structure","members":{"isOptedOut":{"type":"boolean"}}}},"ConfirmSubscription":{"input":{"type":"structure","required":["TopicArn","Token"],"members":{"TopicArn":{},"Token":{},"AuthenticateOnUnsubscribe":{}}},"output":{"resultWrapper":"ConfirmSubscriptionResult","type":"structure","members":{"SubscriptionArn":{}}}},"CreatePlatformApplication":{"input":{"type":"structure","required":["Name","Platform","Attributes"],"members":{"Name":{},"Platform":{},"Attributes":{"shape":"Sj"}}},"output":{"resultWrapper":"CreatePlatformApplicationResult","type":"structure","members":{"PlatformApplicationArn":{}}}},"CreatePlatformEndpoint":{"input":{"type":"structure","required":["PlatformApplicationArn","Token"],"members":{"PlatformApplicationArn":{},"Token":{},"CustomUserData":{},"Attributes":{"shape":"Sj"}}},"output":{"resultWrapper":"CreatePlatformEndpointResult","type":"structure","members":{"EndpointArn":{}}}},"CreateTopic":{"input":{"type":"structure","required":["Name"],"members":{"Name":{},"Attributes":{"shape":"Sp"},"Tags":{"shape":"Ss"}}},"output":{"resultWrapper":"CreateTopicResult","type":"structure","members":{"TopicArn":{}}}},"DeleteEndpoint":{"input":{"type":"structure","required":["EndpointArn"],"members":{"EndpointArn":{}}}},"DeletePlatformApplication":{"input":{"type":"structure","required":["PlatformApplicationArn"],"members":{"PlatformApplicationArn":{}}}},"DeleteTopic":{"input":{"type":"structure","required":["TopicArn"],"members":{"TopicArn":{}}}},"GetEndpointAttributes":{"input":{"type":"structure","required":["EndpointArn"],"members":{"EndpointArn":{}}},"output":{"resultWrapper":"GetEndpointAttributesResult","type":"structure","members":{"Attributes":{"shape":"Sj"}}}},"GetPlatformApplicationAttributes":{"input":{"type":"structure","required":["PlatformApplicationArn"],"members":{"PlatformApplicationArn":{}}},"output":{"resultWrapper":"GetPlatformApplicationAttributesResult","type":"structure","members":{"Attributes":{"shape":"Sj"}}}},"GetSMSAttributes":{"input":{"type":"structure","members":{"attributes":{"type":"list","member":{}}}},"output":{"resultWrapper":"GetSMSAttributesResult","type":"structure","members":{"attributes":{"shape":"Sj"}}}},"GetSubscriptionAttributes":{"input":{"type":"structure","required":["SubscriptionArn"],"members":{"SubscriptionArn":{}}},"output":{"resultWrapper":"GetSubscriptionAttributesResult","type":"structure","members":{"Attributes":{"shape":"S19"}}}},"GetTopicAttributes":{"input":{"type":"structure","required":["TopicArn"],"members":{"TopicArn":{}}},"output":{"resultWrapper":"GetTopicAttributesResult","type":"structure","members":{"Attributes":{"shape":"Sp"}}}},"ListEndpointsByPlatformApplication":{"input":{"type":"structure","required":["PlatformApplicationArn"],"members":{"PlatformApplicationArn":{},"NextToken":{}}},"output":{"resultWrapper":"ListEndpointsByPlatformApplicationResult","type":"structure","members":{"Endpoints":{"type":"list","member":{"type":"structure","members":{"EndpointArn":{},"Attributes":{"shape":"Sj"}}}},"NextToken":{}}}},"ListPhoneNumbersOptedOut":{"input":{"type":"structure","members":{"nextToken":{}}},"output":{"resultWrapper":"ListPhoneNumbersOptedOutResult","type":"structure","members":{"phoneNumbers":{"type":"list","member":{}},"nextToken":{}}}},"ListPlatformApplications":{"input":{"type":"structure","members":{"NextToken":{}}},"output":{"resultWrapper":"ListPlatformApplicationsResult","type":"structure","members":{"PlatformApplications":{"type":"list","member":{"type":"structure","members":{"PlatformApplicationArn":{},"Attributes":{"shape":"Sj"}}}},"NextToken":{}}}},"ListSubscriptions":{"input":{"type":"structure","members":{"NextToken":{}}},"output":{"resultWrapper":"ListSubscriptionsResult","type":"structure","members":{"Subscriptions":{"shape":"S1r"},"NextToken":{}}}},"ListSubscriptionsByTopic":{"input":{"type":"structure","required":["TopicArn"],"members":{"TopicArn":{},"NextToken":{}}},"output":{"resultWrapper":"ListSubscriptionsByTopicResult","type":"structure","members":{"Subscriptions":{"shape":"S1r"},"NextToken":{}}}},"ListTagsForResource":{"input":{"type":"structure","required":["ResourceArn"],"members":{"ResourceArn":{}}},"output":{"resultWrapper":"ListTagsForResourceResult","type":"structure","members":{"Tags":{"shape":"Ss"}}}},"ListTopics":{"input":{"type":"structure","members":{"NextToken":{}}},"output":{"resultWrapper":"ListTopicsResult","type":"structure","members":{"Topics":{"type":"list","member":{"type":"structure","members":{"TopicArn":{}}}},"NextToken":{}}}},"OptInPhoneNumber":{"input":{"type":"structure","required":["phoneNumber"],"members":{"phoneNumber":{}}},"output":{"resultWrapper":"OptInPhoneNumberResult","type":"structure","members":{}}},"Publish":{"input":{"type":"structure","required":["Message"],"members":{"TopicArn":{},"TargetArn":{},"PhoneNumber":{},"Message":{},"Subject":{},"MessageStructure":{},"MessageAttributes":{"type":"map","key":{"locationName":"Name"},"value":{"locationName":"Value","type":"structure","required":["DataType"],"members":{"DataType":{},"StringValue":{},"BinaryValue":{"type":"blob"}}}}}},"output":{"resultWrapper":"PublishResult","type":"structure","members":{"MessageId":{}}}},"RemovePermission":{"input":{"type":"structure","required":["TopicArn","Label"],"members":{"TopicArn":{},"Label":{}}}},"SetEndpointAttributes":{"input":{"type":"structure","required":["EndpointArn","Attributes"],"members":{"EndpointArn":{},"Attributes":{"shape":"Sj"}}}},"SetPlatformApplicationAttributes":{"input":{"type":"structure","required":["PlatformApplicationArn","Attributes"],"members":{"PlatformApplicationArn":{},"Attributes":{"shape":"Sj"}}}},"SetSMSAttributes":{"input":{"type":"structure","required":["attributes"],"members":{"attributes":{"shape":"Sj"}}},"output":{"resultWrapper":"SetSMSAttributesResult","type":"structure","members":{}}},"SetSubscriptionAttributes":{"input":{"type":"structure","required":["SubscriptionArn","AttributeName"],"members":{"SubscriptionArn":{},"AttributeName":{},"AttributeValue":{}}}},"SetTopicAttributes":{"input":{"type":"structure","required":["TopicArn","AttributeName"],"members":{"TopicArn":{},"AttributeName":{},"AttributeValue":{}}}},"Subscribe":{"input":{"type":"structure","required":["TopicArn","Protocol"],"members":{"TopicArn":{},"Protocol":{},"Endpoint":{},"Attributes":{"shape":"S19"},"ReturnSubscriptionArn":{"type":"boolean"}}},"output":{"resultWrapper":"SubscribeResult","type":"structure","members":{"SubscriptionArn":{}}}},"TagResource":{"input":{"type":"structure","required":["ResourceArn","Tags"],"members":{"ResourceArn":{},"Tags":{"shape":"Ss"}}},"output":{"resultWrapper":"TagResourceResult","type":"structure","members":{}}},"Unsubscribe":{"input":{"type":"structure","required":["SubscriptionArn"],"members":{"SubscriptionArn":{}}}},"UntagResource":{"input":{"type":"structure","required":["ResourceArn","TagKeys"],"members":{"ResourceArn":{},"TagKeys":{"type":"list","member":{}}}},"output":{"resultWrapper":"UntagResourceResult","type":"structure","members":{}}}},"shapes":{"Sj":{"type":"map","key":{},"value":{}},"Sp":{"type":"map","key":{},"value":{}},"Ss":{"type":"list","member":{"type":"structure","required":["Key","Value"],"members":{"Key":{},"Value":{}}}},"S19":{"type":"map","key":{},"value":{}},"S1r":{"type":"list","member":{"type":"structure","members":{"SubscriptionArn":{},"Owner":{},"Protocol":{},"Endpoint":{},"TopicArn":{}}}}}}; +// Cache & CacheStorage are tightly coupled with fetch. Even if it may run +// in an older version of Node, it doesn't have any use without fetch. +module.exports.caches = new CacheStorage(kConstruct) -/***/ }), +const { deleteCookie, getCookies, getSetCookies, setCookie } = __nccwpck_require__(9061) -/***/ 3989: -/***/ (function(module, __unusedexports, __webpack_require__) { +module.exports.deleteCookie = deleteCookie +module.exports.getCookies = getCookies +module.exports.getSetCookies = getSetCookies +module.exports.setCookie = setCookie -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['pricing'] = {}; -AWS.Pricing = Service.defineService('pricing', ['2017-10-15']); -Object.defineProperty(apiLoader.services['pricing'], '2017-10-15', { - get: function get() { - var model = __webpack_require__(2760); - model.paginators = __webpack_require__(5437).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.Pricing; +const { parseMIMEType, serializeAMimeType } = __nccwpck_require__(1900) +module.exports.parseMIMEType = parseMIMEType +module.exports.serializeAMimeType = serializeAMimeType -/***/ }), - -/***/ 3992: -/***/ (function(__unusedmodule, exports, __webpack_require__) { +const { CloseEvent, ErrorEvent, MessageEvent } = __nccwpck_require__(5188) +module.exports.WebSocket = __nccwpck_require__(3726).WebSocket +module.exports.CloseEvent = CloseEvent +module.exports.ErrorEvent = ErrorEvent +module.exports.MessageEvent = MessageEvent -// Generated by CoffeeScript 1.12.7 -(function() { - "use strict"; - var builder, defaults, parser, processors, - extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }, - hasProp = {}.hasOwnProperty; +module.exports.request = makeDispatcher(api.request) +module.exports.stream = makeDispatcher(api.stream) +module.exports.pipeline = makeDispatcher(api.pipeline) +module.exports.connect = makeDispatcher(api.connect) +module.exports.upgrade = makeDispatcher(api.upgrade) - defaults = __webpack_require__(1514); +module.exports.MockClient = MockClient +module.exports.MockPool = MockPool +module.exports.MockAgent = MockAgent +module.exports.mockErrors = mockErrors - builder = __webpack_require__(2476); +const { EventSource } = __nccwpck_require__(1238) - parser = __webpack_require__(1885); +module.exports.EventSource = EventSource - processors = __webpack_require__(5350); - exports.defaults = defaults.defaults; - - exports.processors = processors; +/***/ }), - exports.ValidationError = (function(superClass) { - extend(ValidationError, superClass); +/***/ 158: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - function ValidationError(message) { - this.message = message; - } +const { addAbortListener } = __nccwpck_require__(3440) +const { RequestAbortedError } = __nccwpck_require__(8707) - return ValidationError; +const kListener = Symbol('kListener') +const kSignal = Symbol('kSignal') - })(Error); +function abort (self) { + if (self.abort) { + self.abort(self[kSignal]?.reason) + } else { + self.reason = self[kSignal]?.reason ?? new RequestAbortedError() + } + removeSignal(self) +} - exports.Builder = builder.Builder; +function addSignal (self, signal) { + self.reason = null - exports.Parser = parser.Parser; + self[kSignal] = null + self[kListener] = null - exports.parseString = parser.parseString; + if (!signal) { + return + } -}).call(this); + if (signal.aborted) { + abort(self) + return + } + self[kSignal] = signal + self[kListener] = () => { + abort(self) + } -/***/ }), + addAbortListener(self[kSignal], self[kListener]) +} -/***/ 3998: -/***/ (function(module) { +function removeSignal (self) { + if (!self[kSignal]) { + return + } -module.exports = {"pagination":{"DescribeActionTargets":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"DescribeProducts":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"DescribeStandards":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"DescribeStandardsControls":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"GetEnabledStandards":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"GetFindings":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"GetInsights":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListEnabledProductsForImport":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListInvitations":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListMembers":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"}}}; + if ('removeEventListener' in self[kSignal]) { + self[kSignal].removeEventListener('abort', self[kListener]) + } else { + self[kSignal].removeListener('abort', self[kListener]) + } -/***/ }), + self[kSignal] = null + self[kListener] = null +} -/***/ 4008: -/***/ (function(module) { +module.exports = { + addSignal, + removeSignal +} -module.exports = {"version":"2.0","metadata":{"apiVersion":"2015-12-10","endpointPrefix":"servicecatalog","jsonVersion":"1.1","protocol":"json","serviceFullName":"AWS Service Catalog","serviceId":"Service Catalog","signatureVersion":"v4","targetPrefix":"AWS242ServiceCatalogService","uid":"servicecatalog-2015-12-10"},"operations":{"AcceptPortfolioShare":{"input":{"type":"structure","required":["PortfolioId"],"members":{"AcceptLanguage":{},"PortfolioId":{},"PortfolioShareType":{}}},"output":{"type":"structure","members":{}}},"AssociateBudgetWithResource":{"input":{"type":"structure","required":["BudgetName","ResourceId"],"members":{"BudgetName":{},"ResourceId":{}}},"output":{"type":"structure","members":{}}},"AssociatePrincipalWithPortfolio":{"input":{"type":"structure","required":["PortfolioId","PrincipalARN","PrincipalType"],"members":{"AcceptLanguage":{},"PortfolioId":{},"PrincipalARN":{},"PrincipalType":{}}},"output":{"type":"structure","members":{}}},"AssociateProductWithPortfolio":{"input":{"type":"structure","required":["ProductId","PortfolioId"],"members":{"AcceptLanguage":{},"ProductId":{},"PortfolioId":{},"SourcePortfolioId":{}}},"output":{"type":"structure","members":{}}},"AssociateServiceActionWithProvisioningArtifact":{"input":{"type":"structure","required":["ProductId","ProvisioningArtifactId","ServiceActionId"],"members":{"ProductId":{},"ProvisioningArtifactId":{},"ServiceActionId":{},"AcceptLanguage":{}}},"output":{"type":"structure","members":{}}},"AssociateTagOptionWithResource":{"input":{"type":"structure","required":["ResourceId","TagOptionId"],"members":{"ResourceId":{},"TagOptionId":{}}},"output":{"type":"structure","members":{}}},"BatchAssociateServiceActionWithProvisioningArtifact":{"input":{"type":"structure","required":["ServiceActionAssociations"],"members":{"ServiceActionAssociations":{"shape":"Sm"},"AcceptLanguage":{}}},"output":{"type":"structure","members":{"FailedServiceActionAssociations":{"shape":"Sp"}}}},"BatchDisassociateServiceActionFromProvisioningArtifact":{"input":{"type":"structure","required":["ServiceActionAssociations"],"members":{"ServiceActionAssociations":{"shape":"Sm"},"AcceptLanguage":{}}},"output":{"type":"structure","members":{"FailedServiceActionAssociations":{"shape":"Sp"}}}},"CopyProduct":{"input":{"type":"structure","required":["SourceProductArn","IdempotencyToken"],"members":{"AcceptLanguage":{},"SourceProductArn":{},"TargetProductId":{},"TargetProductName":{},"SourceProvisioningArtifactIdentifiers":{"type":"list","member":{"type":"map","key":{},"value":{}}},"CopyOptions":{"type":"list","member":{}},"IdempotencyToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"CopyProductToken":{}}}},"CreateConstraint":{"input":{"type":"structure","required":["PortfolioId","ProductId","Parameters","Type","IdempotencyToken"],"members":{"AcceptLanguage":{},"PortfolioId":{},"ProductId":{},"Parameters":{},"Type":{},"Description":{},"IdempotencyToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"ConstraintDetail":{"shape":"S1b"},"ConstraintParameters":{},"Status":{}}}},"CreatePortfolio":{"input":{"type":"structure","required":["DisplayName","ProviderName","IdempotencyToken"],"members":{"AcceptLanguage":{},"DisplayName":{},"Description":{},"ProviderName":{},"Tags":{"shape":"S1i"},"IdempotencyToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"PortfolioDetail":{"shape":"S1n"},"Tags":{"shape":"S1q"}}}},"CreatePortfolioShare":{"input":{"type":"structure","required":["PortfolioId"],"members":{"AcceptLanguage":{},"PortfolioId":{},"AccountId":{},"OrganizationNode":{"shape":"S1s"}}},"output":{"type":"structure","members":{"PortfolioShareToken":{}}}},"CreateProduct":{"input":{"type":"structure","required":["Name","Owner","ProductType","ProvisioningArtifactParameters","IdempotencyToken"],"members":{"AcceptLanguage":{},"Name":{},"Owner":{},"Description":{},"Distributor":{},"SupportDescription":{},"SupportEmail":{},"SupportUrl":{},"ProductType":{},"Tags":{"shape":"S1i"},"ProvisioningArtifactParameters":{"shape":"S23"},"IdempotencyToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"ProductViewDetail":{"shape":"S2c"},"ProvisioningArtifactDetail":{"shape":"S2h"},"Tags":{"shape":"S1q"}}}},"CreateProvisionedProductPlan":{"input":{"type":"structure","required":["PlanName","PlanType","ProductId","ProvisionedProductName","ProvisioningArtifactId","IdempotencyToken"],"members":{"AcceptLanguage":{},"PlanName":{},"PlanType":{},"NotificationArns":{"shape":"S2n"},"PathId":{},"ProductId":{},"ProvisionedProductName":{},"ProvisioningArtifactId":{},"ProvisioningParameters":{"shape":"S2q"},"IdempotencyToken":{"idempotencyToken":true},"Tags":{"shape":"S1q"}}},"output":{"type":"structure","members":{"PlanName":{},"PlanId":{},"ProvisionProductId":{},"ProvisionedProductName":{},"ProvisioningArtifactId":{}}}},"CreateProvisioningArtifact":{"input":{"type":"structure","required":["ProductId","Parameters","IdempotencyToken"],"members":{"AcceptLanguage":{},"ProductId":{},"Parameters":{"shape":"S23"},"IdempotencyToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"ProvisioningArtifactDetail":{"shape":"S2h"},"Info":{"shape":"S26"},"Status":{}}}},"CreateServiceAction":{"input":{"type":"structure","required":["Name","DefinitionType","Definition","IdempotencyToken"],"members":{"Name":{},"DefinitionType":{},"Definition":{"shape":"S31"},"Description":{},"AcceptLanguage":{},"IdempotencyToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"ServiceActionDetail":{"shape":"S36"}}}},"CreateTagOption":{"input":{"type":"structure","required":["Key","Value"],"members":{"Key":{},"Value":{}}},"output":{"type":"structure","members":{"TagOptionDetail":{"shape":"S3c"}}}},"DeleteConstraint":{"input":{"type":"structure","required":["Id"],"members":{"AcceptLanguage":{},"Id":{}}},"output":{"type":"structure","members":{}}},"DeletePortfolio":{"input":{"type":"structure","required":["Id"],"members":{"AcceptLanguage":{},"Id":{}}},"output":{"type":"structure","members":{}}},"DeletePortfolioShare":{"input":{"type":"structure","required":["PortfolioId"],"members":{"AcceptLanguage":{},"PortfolioId":{},"AccountId":{},"OrganizationNode":{"shape":"S1s"}}},"output":{"type":"structure","members":{"PortfolioShareToken":{}}}},"DeleteProduct":{"input":{"type":"structure","required":["Id"],"members":{"AcceptLanguage":{},"Id":{}}},"output":{"type":"structure","members":{}}},"DeleteProvisionedProductPlan":{"input":{"type":"structure","required":["PlanId"],"members":{"AcceptLanguage":{},"PlanId":{},"IgnoreErrors":{"type":"boolean"}}},"output":{"type":"structure","members":{}}},"DeleteProvisioningArtifact":{"input":{"type":"structure","required":["ProductId","ProvisioningArtifactId"],"members":{"AcceptLanguage":{},"ProductId":{},"ProvisioningArtifactId":{}}},"output":{"type":"structure","members":{}}},"DeleteServiceAction":{"input":{"type":"structure","required":["Id"],"members":{"Id":{},"AcceptLanguage":{}}},"output":{"type":"structure","members":{}}},"DeleteTagOption":{"input":{"type":"structure","required":["Id"],"members":{"Id":{}}},"output":{"type":"structure","members":{}}},"DescribeConstraint":{"input":{"type":"structure","required":["Id"],"members":{"AcceptLanguage":{},"Id":{}}},"output":{"type":"structure","members":{"ConstraintDetail":{"shape":"S1b"},"ConstraintParameters":{},"Status":{}}}},"DescribeCopyProductStatus":{"input":{"type":"structure","required":["CopyProductToken"],"members":{"AcceptLanguage":{},"CopyProductToken":{}}},"output":{"type":"structure","members":{"CopyProductStatus":{},"TargetProductId":{},"StatusDetail":{}}}},"DescribePortfolio":{"input":{"type":"structure","required":["Id"],"members":{"AcceptLanguage":{},"Id":{}}},"output":{"type":"structure","members":{"PortfolioDetail":{"shape":"S1n"},"Tags":{"shape":"S1q"},"TagOptions":{"shape":"S43"},"Budgets":{"shape":"S44"}}}},"DescribePortfolioShareStatus":{"input":{"type":"structure","required":["PortfolioShareToken"],"members":{"PortfolioShareToken":{}}},"output":{"type":"structure","members":{"PortfolioShareToken":{},"PortfolioId":{},"OrganizationNodeValue":{},"Status":{},"ShareDetails":{"type":"structure","members":{"SuccessfulShares":{"type":"list","member":{}},"ShareErrors":{"type":"list","member":{"type":"structure","members":{"Accounts":{"type":"list","member":{}},"Message":{},"Error":{}}}}}}}}},"DescribeProduct":{"input":{"type":"structure","members":{"AcceptLanguage":{},"Id":{},"Name":{}}},"output":{"type":"structure","members":{"ProductViewSummary":{"shape":"S2d"},"ProvisioningArtifacts":{"shape":"S4i"},"Budgets":{"shape":"S44"},"LaunchPaths":{"type":"list","member":{"type":"structure","members":{"Id":{},"Name":{}}}}}}},"DescribeProductAsAdmin":{"input":{"type":"structure","members":{"AcceptLanguage":{},"Id":{},"Name":{}}},"output":{"type":"structure","members":{"ProductViewDetail":{"shape":"S2c"},"ProvisioningArtifactSummaries":{"type":"list","member":{"type":"structure","members":{"Id":{},"Name":{},"Description":{},"CreatedTime":{"type":"timestamp"},"ProvisioningArtifactMetadata":{"shape":"S26"}}}},"Tags":{"shape":"S1q"},"TagOptions":{"shape":"S43"},"Budgets":{"shape":"S44"}}}},"DescribeProductView":{"input":{"type":"structure","required":["Id"],"members":{"AcceptLanguage":{},"Id":{}}},"output":{"type":"structure","members":{"ProductViewSummary":{"shape":"S2d"},"ProvisioningArtifacts":{"shape":"S4i"}}}},"DescribeProvisionedProduct":{"input":{"type":"structure","required":["Id"],"members":{"AcceptLanguage":{},"Id":{}}},"output":{"type":"structure","members":{"ProvisionedProductDetail":{"shape":"S4w"},"CloudWatchDashboards":{"type":"list","member":{"type":"structure","members":{"Name":{}}}}}}},"DescribeProvisionedProductPlan":{"input":{"type":"structure","required":["PlanId"],"members":{"AcceptLanguage":{},"PlanId":{},"PageSize":{"type":"integer"},"PageToken":{}}},"output":{"type":"structure","members":{"ProvisionedProductPlanDetails":{"type":"structure","members":{"CreatedTime":{"type":"timestamp"},"PathId":{},"ProductId":{},"PlanName":{},"PlanId":{},"ProvisionProductId":{},"ProvisionProductName":{},"PlanType":{},"ProvisioningArtifactId":{},"Status":{},"UpdatedTime":{"type":"timestamp"},"NotificationArns":{"shape":"S2n"},"ProvisioningParameters":{"shape":"S2q"},"Tags":{"shape":"S1q"},"StatusMessage":{}}},"ResourceChanges":{"type":"list","member":{"type":"structure","members":{"Action":{},"LogicalResourceId":{},"PhysicalResourceId":{},"ResourceType":{},"Replacement":{},"Scope":{"type":"list","member":{}},"Details":{"type":"list","member":{"type":"structure","members":{"Target":{"type":"structure","members":{"Attribute":{},"Name":{},"RequiresRecreation":{}}},"Evaluation":{},"CausingEntity":{}}}}}}},"NextPageToken":{}}}},"DescribeProvisioningArtifact":{"input":{"type":"structure","members":{"AcceptLanguage":{},"ProvisioningArtifactId":{},"ProductId":{},"ProvisioningArtifactName":{},"ProductName":{},"Verbose":{"type":"boolean"}}},"output":{"type":"structure","members":{"ProvisioningArtifactDetail":{"shape":"S2h"},"Info":{"shape":"S26"},"Status":{}}}},"DescribeProvisioningParameters":{"input":{"type":"structure","members":{"AcceptLanguage":{},"ProductId":{},"ProductName":{},"ProvisioningArtifactId":{},"ProvisioningArtifactName":{},"PathId":{},"PathName":{}}},"output":{"type":"structure","members":{"ProvisioningArtifactParameters":{"type":"list","member":{"type":"structure","members":{"ParameterKey":{},"DefaultValue":{},"ParameterType":{},"IsNoEcho":{"type":"boolean"},"Description":{},"ParameterConstraints":{"type":"structure","members":{"AllowedValues":{"type":"list","member":{}}}}}}},"ConstraintSummaries":{"shape":"S68"},"UsageInstructions":{"type":"list","member":{"type":"structure","members":{"Type":{},"Value":{}}}},"TagOptions":{"type":"list","member":{"type":"structure","members":{"Key":{},"Values":{"type":"list","member":{}}}}},"ProvisioningArtifactPreferences":{"type":"structure","members":{"StackSetAccounts":{"shape":"S6i"},"StackSetRegions":{"shape":"S6j"}}},"ProvisioningArtifactOutputs":{"type":"list","member":{"type":"structure","members":{"Key":{},"Description":{}}}}}}},"DescribeRecord":{"input":{"type":"structure","required":["Id"],"members":{"AcceptLanguage":{},"Id":{},"PageToken":{},"PageSize":{"type":"integer"}}},"output":{"type":"structure","members":{"RecordDetail":{"shape":"S6r"},"RecordOutputs":{"type":"list","member":{"type":"structure","members":{"OutputKey":{},"OutputValue":{},"Description":{}}}},"NextPageToken":{}}}},"DescribeServiceAction":{"input":{"type":"structure","required":["Id"],"members":{"Id":{},"AcceptLanguage":{}}},"output":{"type":"structure","members":{"ServiceActionDetail":{"shape":"S36"}}}},"DescribeServiceActionExecutionParameters":{"input":{"type":"structure","required":["ProvisionedProductId","ServiceActionId"],"members":{"ProvisionedProductId":{},"ServiceActionId":{},"AcceptLanguage":{}}},"output":{"type":"structure","members":{"ServiceActionParameters":{"type":"list","member":{"type":"structure","members":{"Name":{},"Type":{},"DefaultValues":{"shape":"S7e"}}}}}}},"DescribeTagOption":{"input":{"type":"structure","required":["Id"],"members":{"Id":{}}},"output":{"type":"structure","members":{"TagOptionDetail":{"shape":"S3c"}}}},"DisableAWSOrganizationsAccess":{"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{}}},"DisassociateBudgetFromResource":{"input":{"type":"structure","required":["BudgetName","ResourceId"],"members":{"BudgetName":{},"ResourceId":{}}},"output":{"type":"structure","members":{}}},"DisassociatePrincipalFromPortfolio":{"input":{"type":"structure","required":["PortfolioId","PrincipalARN"],"members":{"AcceptLanguage":{},"PortfolioId":{},"PrincipalARN":{}}},"output":{"type":"structure","members":{}}},"DisassociateProductFromPortfolio":{"input":{"type":"structure","required":["ProductId","PortfolioId"],"members":{"AcceptLanguage":{},"ProductId":{},"PortfolioId":{}}},"output":{"type":"structure","members":{}}},"DisassociateServiceActionFromProvisioningArtifact":{"input":{"type":"structure","required":["ProductId","ProvisioningArtifactId","ServiceActionId"],"members":{"ProductId":{},"ProvisioningArtifactId":{},"ServiceActionId":{},"AcceptLanguage":{}}},"output":{"type":"structure","members":{}}},"DisassociateTagOptionFromResource":{"input":{"type":"structure","required":["ResourceId","TagOptionId"],"members":{"ResourceId":{},"TagOptionId":{}}},"output":{"type":"structure","members":{}}},"EnableAWSOrganizationsAccess":{"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{}}},"ExecuteProvisionedProductPlan":{"input":{"type":"structure","required":["PlanId","IdempotencyToken"],"members":{"AcceptLanguage":{},"PlanId":{},"IdempotencyToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"RecordDetail":{"shape":"S6r"}}}},"ExecuteProvisionedProductServiceAction":{"input":{"type":"structure","required":["ProvisionedProductId","ServiceActionId","ExecuteToken"],"members":{"ProvisionedProductId":{},"ServiceActionId":{},"ExecuteToken":{"idempotencyToken":true},"AcceptLanguage":{},"Parameters":{"type":"map","key":{},"value":{"shape":"S7e"}}}},"output":{"type":"structure","members":{"RecordDetail":{"shape":"S6r"}}}},"GetAWSOrganizationsAccessStatus":{"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"AccessStatus":{}}}},"ListAcceptedPortfolioShares":{"input":{"type":"structure","members":{"AcceptLanguage":{},"PageToken":{},"PageSize":{"type":"integer"},"PortfolioShareType":{}}},"output":{"type":"structure","members":{"PortfolioDetails":{"shape":"S86"},"NextPageToken":{}}}},"ListBudgetsForResource":{"input":{"type":"structure","required":["ResourceId"],"members":{"AcceptLanguage":{},"ResourceId":{},"PageSize":{"type":"integer"},"PageToken":{}}},"output":{"type":"structure","members":{"Budgets":{"shape":"S44"},"NextPageToken":{}}}},"ListConstraintsForPortfolio":{"input":{"type":"structure","required":["PortfolioId"],"members":{"AcceptLanguage":{},"PortfolioId":{},"ProductId":{},"PageSize":{"type":"integer"},"PageToken":{}}},"output":{"type":"structure","members":{"ConstraintDetails":{"type":"list","member":{"shape":"S1b"}},"NextPageToken":{}}}},"ListLaunchPaths":{"input":{"type":"structure","required":["ProductId"],"members":{"AcceptLanguage":{},"ProductId":{},"PageSize":{"type":"integer"},"PageToken":{}}},"output":{"type":"structure","members":{"LaunchPathSummaries":{"type":"list","member":{"type":"structure","members":{"Id":{},"ConstraintSummaries":{"shape":"S68"},"Tags":{"shape":"S1q"},"Name":{}}}},"NextPageToken":{}}}},"ListOrganizationPortfolioAccess":{"input":{"type":"structure","required":["PortfolioId","OrganizationNodeType"],"members":{"AcceptLanguage":{},"PortfolioId":{},"OrganizationNodeType":{},"PageToken":{},"PageSize":{"type":"integer"}}},"output":{"type":"structure","members":{"OrganizationNodes":{"type":"list","member":{"shape":"S1s"}},"NextPageToken":{}}}},"ListPortfolioAccess":{"input":{"type":"structure","required":["PortfolioId"],"members":{"AcceptLanguage":{},"PortfolioId":{},"OrganizationParentId":{},"PageToken":{},"PageSize":{"type":"integer"}}},"output":{"type":"structure","members":{"AccountIds":{"type":"list","member":{}},"NextPageToken":{}}}},"ListPortfolios":{"input":{"type":"structure","members":{"AcceptLanguage":{},"PageToken":{},"PageSize":{"type":"integer"}}},"output":{"type":"structure","members":{"PortfolioDetails":{"shape":"S86"},"NextPageToken":{}}}},"ListPortfoliosForProduct":{"input":{"type":"structure","required":["ProductId"],"members":{"AcceptLanguage":{},"ProductId":{},"PageToken":{},"PageSize":{"type":"integer"}}},"output":{"type":"structure","members":{"PortfolioDetails":{"shape":"S86"},"NextPageToken":{}}}},"ListPrincipalsForPortfolio":{"input":{"type":"structure","required":["PortfolioId"],"members":{"AcceptLanguage":{},"PortfolioId":{},"PageSize":{"type":"integer"},"PageToken":{}}},"output":{"type":"structure","members":{"Principals":{"type":"list","member":{"type":"structure","members":{"PrincipalARN":{},"PrincipalType":{}}}},"NextPageToken":{}}}},"ListProvisionedProductPlans":{"input":{"type":"structure","members":{"AcceptLanguage":{},"ProvisionProductId":{},"PageSize":{"type":"integer"},"PageToken":{},"AccessLevelFilter":{"shape":"S8v"}}},"output":{"type":"structure","members":{"ProvisionedProductPlans":{"type":"list","member":{"type":"structure","members":{"PlanName":{},"PlanId":{},"ProvisionProductId":{},"ProvisionProductName":{},"PlanType":{},"ProvisioningArtifactId":{}}}},"NextPageToken":{}}}},"ListProvisioningArtifacts":{"input":{"type":"structure","required":["ProductId"],"members":{"AcceptLanguage":{},"ProductId":{}}},"output":{"type":"structure","members":{"ProvisioningArtifactDetails":{"type":"list","member":{"shape":"S2h"}},"NextPageToken":{}}}},"ListProvisioningArtifactsForServiceAction":{"input":{"type":"structure","required":["ServiceActionId"],"members":{"ServiceActionId":{},"PageSize":{"type":"integer"},"PageToken":{},"AcceptLanguage":{}}},"output":{"type":"structure","members":{"ProvisioningArtifactViews":{"type":"list","member":{"type":"structure","members":{"ProductViewSummary":{"shape":"S2d"},"ProvisioningArtifact":{"shape":"S4j"}}}},"NextPageToken":{}}}},"ListRecordHistory":{"input":{"type":"structure","members":{"AcceptLanguage":{},"AccessLevelFilter":{"shape":"S8v"},"SearchFilter":{"type":"structure","members":{"Key":{},"Value":{}}},"PageSize":{"type":"integer"},"PageToken":{}}},"output":{"type":"structure","members":{"RecordDetails":{"type":"list","member":{"shape":"S6r"}},"NextPageToken":{}}}},"ListResourcesForTagOption":{"input":{"type":"structure","required":["TagOptionId"],"members":{"TagOptionId":{},"ResourceType":{},"PageSize":{"type":"integer"},"PageToken":{}}},"output":{"type":"structure","members":{"ResourceDetails":{"type":"list","member":{"type":"structure","members":{"Id":{},"ARN":{},"Name":{},"Description":{},"CreatedTime":{"type":"timestamp"}}}},"PageToken":{}}}},"ListServiceActions":{"input":{"type":"structure","members":{"AcceptLanguage":{},"PageSize":{"type":"integer"},"PageToken":{}}},"output":{"type":"structure","members":{"ServiceActionSummaries":{"shape":"S9q"},"NextPageToken":{}}}},"ListServiceActionsForProvisioningArtifact":{"input":{"type":"structure","required":["ProductId","ProvisioningArtifactId"],"members":{"ProductId":{},"ProvisioningArtifactId":{},"PageSize":{"type":"integer"},"PageToken":{},"AcceptLanguage":{}}},"output":{"type":"structure","members":{"ServiceActionSummaries":{"shape":"S9q"},"NextPageToken":{}}}},"ListStackInstancesForProvisionedProduct":{"input":{"type":"structure","required":["ProvisionedProductId"],"members":{"AcceptLanguage":{},"ProvisionedProductId":{},"PageToken":{},"PageSize":{"type":"integer"}}},"output":{"type":"structure","members":{"StackInstances":{"type":"list","member":{"type":"structure","members":{"Account":{},"Region":{},"StackInstanceStatus":{}}}},"NextPageToken":{}}}},"ListTagOptions":{"input":{"type":"structure","members":{"Filters":{"type":"structure","members":{"Key":{},"Value":{},"Active":{"type":"boolean"}}},"PageSize":{"type":"integer"},"PageToken":{}}},"output":{"type":"structure","members":{"TagOptionDetails":{"shape":"S43"},"PageToken":{}}}},"ProvisionProduct":{"input":{"type":"structure","required":["ProvisionedProductName","ProvisionToken"],"members":{"AcceptLanguage":{},"ProductId":{},"ProductName":{},"ProvisioningArtifactId":{},"ProvisioningArtifactName":{},"PathId":{},"PathName":{},"ProvisionedProductName":{},"ProvisioningParameters":{"type":"list","member":{"type":"structure","members":{"Key":{},"Value":{}}}},"ProvisioningPreferences":{"type":"structure","members":{"StackSetAccounts":{"shape":"S6i"},"StackSetRegions":{"shape":"S6j"},"StackSetFailureToleranceCount":{"type":"integer"},"StackSetFailureTolerancePercentage":{"type":"integer"},"StackSetMaxConcurrencyCount":{"type":"integer"},"StackSetMaxConcurrencyPercentage":{"type":"integer"}}},"Tags":{"shape":"S1q"},"NotificationArns":{"shape":"S2n"},"ProvisionToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"RecordDetail":{"shape":"S6r"}}}},"RejectPortfolioShare":{"input":{"type":"structure","required":["PortfolioId"],"members":{"AcceptLanguage":{},"PortfolioId":{},"PortfolioShareType":{}}},"output":{"type":"structure","members":{}}},"ScanProvisionedProducts":{"input":{"type":"structure","members":{"AcceptLanguage":{},"AccessLevelFilter":{"shape":"S8v"},"PageSize":{"type":"integer"},"PageToken":{}}},"output":{"type":"structure","members":{"ProvisionedProducts":{"type":"list","member":{"shape":"S4w"}},"NextPageToken":{}}}},"SearchProducts":{"input":{"type":"structure","members":{"AcceptLanguage":{},"Filters":{"shape":"Sag"},"PageSize":{"type":"integer"},"SortBy":{},"SortOrder":{},"PageToken":{}}},"output":{"type":"structure","members":{"ProductViewSummaries":{"type":"list","member":{"shape":"S2d"}},"ProductViewAggregations":{"type":"map","key":{},"value":{"type":"list","member":{"type":"structure","members":{"Value":{},"ApproximateCount":{"type":"integer"}}}}},"NextPageToken":{}}}},"SearchProductsAsAdmin":{"input":{"type":"structure","members":{"AcceptLanguage":{},"PortfolioId":{},"Filters":{"shape":"Sag"},"SortBy":{},"SortOrder":{},"PageToken":{},"PageSize":{"type":"integer"},"ProductSource":{}}},"output":{"type":"structure","members":{"ProductViewDetails":{"type":"list","member":{"shape":"S2c"}},"NextPageToken":{}}}},"SearchProvisionedProducts":{"input":{"type":"structure","members":{"AcceptLanguage":{},"AccessLevelFilter":{"shape":"S8v"},"Filters":{"type":"map","key":{},"value":{"type":"list","member":{}}},"SortBy":{},"SortOrder":{},"PageSize":{"type":"integer"},"PageToken":{}}},"output":{"type":"structure","members":{"ProvisionedProducts":{"type":"list","member":{"type":"structure","members":{"Name":{},"Arn":{},"Type":{},"Id":{},"Status":{},"StatusMessage":{},"CreatedTime":{"type":"timestamp"},"IdempotencyToken":{},"LastRecordId":{},"Tags":{"shape":"S1q"},"PhysicalId":{},"ProductId":{},"ProvisioningArtifactId":{},"UserArn":{},"UserArnSession":{}}}},"TotalResultsCount":{"type":"integer"},"NextPageToken":{}}}},"TerminateProvisionedProduct":{"input":{"type":"structure","required":["TerminateToken"],"members":{"ProvisionedProductName":{},"ProvisionedProductId":{},"TerminateToken":{"idempotencyToken":true},"IgnoreErrors":{"type":"boolean"},"AcceptLanguage":{}}},"output":{"type":"structure","members":{"RecordDetail":{"shape":"S6r"}}}},"UpdateConstraint":{"input":{"type":"structure","required":["Id"],"members":{"AcceptLanguage":{},"Id":{},"Description":{},"Parameters":{}}},"output":{"type":"structure","members":{"ConstraintDetail":{"shape":"S1b"},"ConstraintParameters":{},"Status":{}}}},"UpdatePortfolio":{"input":{"type":"structure","required":["Id"],"members":{"AcceptLanguage":{},"Id":{},"DisplayName":{},"Description":{},"ProviderName":{},"AddTags":{"shape":"S1i"},"RemoveTags":{"shape":"Sbh"}}},"output":{"type":"structure","members":{"PortfolioDetail":{"shape":"S1n"},"Tags":{"shape":"S1q"}}}},"UpdateProduct":{"input":{"type":"structure","required":["Id"],"members":{"AcceptLanguage":{},"Id":{},"Name":{},"Owner":{},"Description":{},"Distributor":{},"SupportDescription":{},"SupportEmail":{},"SupportUrl":{},"AddTags":{"shape":"S1i"},"RemoveTags":{"shape":"Sbh"}}},"output":{"type":"structure","members":{"ProductViewDetail":{"shape":"S2c"},"Tags":{"shape":"S1q"}}}},"UpdateProvisionedProduct":{"input":{"type":"structure","required":["UpdateToken"],"members":{"AcceptLanguage":{},"ProvisionedProductName":{},"ProvisionedProductId":{},"ProductId":{},"ProductName":{},"ProvisioningArtifactId":{},"ProvisioningArtifactName":{},"PathId":{},"PathName":{},"ProvisioningParameters":{"shape":"S2q"},"ProvisioningPreferences":{"type":"structure","members":{"StackSetAccounts":{"shape":"S6i"},"StackSetRegions":{"shape":"S6j"},"StackSetFailureToleranceCount":{"type":"integer"},"StackSetFailureTolerancePercentage":{"type":"integer"},"StackSetMaxConcurrencyCount":{"type":"integer"},"StackSetMaxConcurrencyPercentage":{"type":"integer"},"StackSetOperationType":{}}},"Tags":{"shape":"S1q"},"UpdateToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"RecordDetail":{"shape":"S6r"}}}},"UpdateProvisionedProductProperties":{"input":{"type":"structure","required":["ProvisionedProductId","ProvisionedProductProperties","IdempotencyToken"],"members":{"AcceptLanguage":{},"ProvisionedProductId":{},"ProvisionedProductProperties":{"shape":"Sbq"},"IdempotencyToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"ProvisionedProductId":{},"ProvisionedProductProperties":{"shape":"Sbq"},"RecordId":{},"Status":{}}}},"UpdateProvisioningArtifact":{"input":{"type":"structure","required":["ProductId","ProvisioningArtifactId"],"members":{"AcceptLanguage":{},"ProductId":{},"ProvisioningArtifactId":{},"Name":{},"Description":{},"Active":{"type":"boolean"},"Guidance":{}}},"output":{"type":"structure","members":{"ProvisioningArtifactDetail":{"shape":"S2h"},"Info":{"shape":"S26"},"Status":{}}}},"UpdateServiceAction":{"input":{"type":"structure","required":["Id"],"members":{"Id":{},"Name":{},"Definition":{"shape":"S31"},"Description":{},"AcceptLanguage":{}}},"output":{"type":"structure","members":{"ServiceActionDetail":{"shape":"S36"}}}},"UpdateTagOption":{"input":{"type":"structure","required":["Id"],"members":{"Id":{},"Value":{},"Active":{"type":"boolean"}}},"output":{"type":"structure","members":{"TagOptionDetail":{"shape":"S3c"}}}}},"shapes":{"Sm":{"type":"list","member":{"type":"structure","required":["ServiceActionId","ProductId","ProvisioningArtifactId"],"members":{"ServiceActionId":{},"ProductId":{},"ProvisioningArtifactId":{}}}},"Sp":{"type":"list","member":{"type":"structure","members":{"ServiceActionId":{},"ProductId":{},"ProvisioningArtifactId":{},"ErrorCode":{},"ErrorMessage":{}}}},"S1b":{"type":"structure","members":{"ConstraintId":{},"Type":{},"Description":{},"Owner":{},"ProductId":{},"PortfolioId":{}}},"S1i":{"type":"list","member":{"shape":"S1j"}},"S1j":{"type":"structure","required":["Key","Value"],"members":{"Key":{},"Value":{}}},"S1n":{"type":"structure","members":{"Id":{},"ARN":{},"DisplayName":{},"Description":{},"CreatedTime":{"type":"timestamp"},"ProviderName":{}}},"S1q":{"type":"list","member":{"shape":"S1j"}},"S1s":{"type":"structure","members":{"Type":{},"Value":{}}},"S23":{"type":"structure","required":["Info"],"members":{"Name":{},"Description":{},"Info":{"shape":"S26"},"Type":{},"DisableTemplateValidation":{"type":"boolean"}}},"S26":{"type":"map","key":{},"value":{}},"S2c":{"type":"structure","members":{"ProductViewSummary":{"shape":"S2d"},"Status":{},"ProductARN":{},"CreatedTime":{"type":"timestamp"}}},"S2d":{"type":"structure","members":{"Id":{},"ProductId":{},"Name":{},"Owner":{},"ShortDescription":{},"Type":{},"Distributor":{},"HasDefaultPath":{"type":"boolean"},"SupportEmail":{},"SupportDescription":{},"SupportUrl":{}}},"S2h":{"type":"structure","members":{"Id":{},"Name":{},"Description":{},"Type":{},"CreatedTime":{"type":"timestamp"},"Active":{"type":"boolean"},"Guidance":{}}},"S2n":{"type":"list","member":{}},"S2q":{"type":"list","member":{"type":"structure","members":{"Key":{},"Value":{},"UsePreviousValue":{"type":"boolean"}}}},"S31":{"type":"map","key":{},"value":{}},"S36":{"type":"structure","members":{"ServiceActionSummary":{"shape":"S37"},"Definition":{"shape":"S31"}}},"S37":{"type":"structure","members":{"Id":{},"Name":{},"Description":{},"DefinitionType":{}}},"S3c":{"type":"structure","members":{"Key":{},"Value":{},"Active":{"type":"boolean"},"Id":{}}},"S43":{"type":"list","member":{"shape":"S3c"}},"S44":{"type":"list","member":{"type":"structure","members":{"BudgetName":{}}}},"S4i":{"type":"list","member":{"shape":"S4j"}},"S4j":{"type":"structure","members":{"Id":{},"Name":{},"Description":{},"CreatedTime":{"type":"timestamp"},"Guidance":{}}},"S4w":{"type":"structure","members":{"Name":{},"Arn":{},"Type":{},"Id":{},"Status":{},"StatusMessage":{},"CreatedTime":{"type":"timestamp"},"IdempotencyToken":{},"LastRecordId":{},"ProductId":{},"ProvisioningArtifactId":{}}},"S68":{"type":"list","member":{"type":"structure","members":{"Type":{},"Description":{}}}},"S6i":{"type":"list","member":{}},"S6j":{"type":"list","member":{}},"S6r":{"type":"structure","members":{"RecordId":{},"ProvisionedProductName":{},"Status":{},"CreatedTime":{"type":"timestamp"},"UpdatedTime":{"type":"timestamp"},"ProvisionedProductType":{},"RecordType":{},"ProvisionedProductId":{},"ProductId":{},"ProvisioningArtifactId":{},"PathId":{},"RecordErrors":{"type":"list","member":{"type":"structure","members":{"Code":{},"Description":{}}}},"RecordTags":{"type":"list","member":{"type":"structure","members":{"Key":{},"Value":{}}}}}},"S7e":{"type":"list","member":{}},"S86":{"type":"list","member":{"shape":"S1n"}},"S8v":{"type":"structure","members":{"Key":{},"Value":{}}},"S9q":{"type":"list","member":{"shape":"S37"}},"Sag":{"type":"map","key":{},"value":{"type":"list","member":{}}},"Sbh":{"type":"list","member":{}},"Sbq":{"type":"map","key":{},"value":{}}}}; /***/ }), -/***/ 4009: -/***/ (function(module, __unusedexports, __webpack_require__) { +/***/ 2279: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; +const assert = __nccwpck_require__(4589) +const { AsyncResource } = __nccwpck_require__(6698) +const { InvalidArgumentError, SocketError } = __nccwpck_require__(8707) +const util = __nccwpck_require__(3440) +const { addSignal, removeSignal } = __nccwpck_require__(158) -var loader = __webpack_require__(2457); -var dumper = __webpack_require__(2685); +class ConnectHandler extends AsyncResource { + constructor (opts, callback) { + if (!opts || typeof opts !== 'object') { + throw new InvalidArgumentError('invalid opts') + } + if (typeof callback !== 'function') { + throw new InvalidArgumentError('invalid callback') + } -function deprecated(name) { - return function () { - throw new Error('Function ' + name + ' is deprecated and cannot be used.'); - }; -} + const { signal, opaque, responseHeaders } = opts + if (signal && typeof signal.on !== 'function' && typeof signal.addEventListener !== 'function') { + throw new InvalidArgumentError('signal must be an EventEmitter or EventTarget') + } -module.exports.Type = __webpack_require__(4945); -module.exports.Schema = __webpack_require__(8043); -module.exports.FAILSAFE_SCHEMA = __webpack_require__(3581); -module.exports.JSON_SCHEMA = __webpack_require__(8023); -module.exports.CORE_SCHEMA = __webpack_require__(3611); -module.exports.DEFAULT_SAFE_SCHEMA = __webpack_require__(6830); -module.exports.DEFAULT_FULL_SCHEMA = __webpack_require__(5910); -module.exports.load = loader.load; -module.exports.loadAll = loader.loadAll; -module.exports.safeLoad = loader.safeLoad; -module.exports.safeLoadAll = loader.safeLoadAll; -module.exports.dump = dumper.dump; -module.exports.safeDump = dumper.safeDump; -module.exports.YAMLException = __webpack_require__(556); + super('UNDICI_CONNECT') -// Deprecated schema names from JS-YAML 2.0.x -module.exports.MINIMAL_SCHEMA = __webpack_require__(3581); -module.exports.SAFE_SCHEMA = __webpack_require__(6830); -module.exports.DEFAULT_SCHEMA = __webpack_require__(5910); + this.opaque = opaque || null + this.responseHeaders = responseHeaders || null + this.callback = callback + this.abort = null -// Deprecated functions from JS-YAML 1.x.x -module.exports.scan = deprecated('scan'); -module.exports.parse = deprecated('parse'); -module.exports.compose = deprecated('compose'); -module.exports.addConstructor = deprecated('addConstructor'); + addSignal(this, signal) + } + onConnect (abort, context) { + if (this.reason) { + abort(this.reason) + return + } -/***/ }), + assert(this.callback) -/***/ 4035: -/***/ (function(module, __unusedexports, __webpack_require__) { + this.abort = abort + this.context = context + } -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; + onHeaders () { + throw new SocketError('bad connect', null) + } -apiLoader.services['codeartifact'] = {}; -AWS.CodeArtifact = Service.defineService('codeartifact', ['2018-09-22']); -Object.defineProperty(apiLoader.services['codeartifact'], '2018-09-22', { - get: function get() { - var model = __webpack_require__(9069); - model.paginators = __webpack_require__(848).pagination; - return model; - }, - enumerable: true, - configurable: true -}); + onUpgrade (statusCode, rawHeaders, socket) { + const { callback, opaque, context } = this -module.exports = AWS.CodeArtifact; + removeSignal(this) + this.callback = null -/***/ }), + let headers = rawHeaders + // Indicates is an HTTP2Session + if (headers != null) { + headers = this.responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders) + } -/***/ 4068: -/***/ (function(module, __unusedexports, __webpack_require__) { + this.runInAsyncScope(callback, null, null, { + statusCode, + headers, + socket, + opaque, + context + }) + } -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; + onError (err) { + const { callback, opaque } = this -apiLoader.services['forecastqueryservice'] = {}; -AWS.ForecastQueryService = Service.defineService('forecastqueryservice', ['2018-06-26']); -Object.defineProperty(apiLoader.services['forecastqueryservice'], '2018-06-26', { - get: function get() { - var model = __webpack_require__(890); - model.paginators = __webpack_require__(520).pagination; - return model; - }, - enumerable: true, - configurable: true -}); + removeSignal(this) -module.exports = AWS.ForecastQueryService; + if (callback) { + this.callback = null + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }) + }) + } + } +} +function connect (opts, callback) { + if (callback === undefined) { + return new Promise((resolve, reject) => { + connect.call(this, opts, (err, data) => { + return err ? reject(err) : resolve(data) + }) + }) + } -/***/ }), + try { + const connectHandler = new ConnectHandler(opts, callback) + this.dispatch({ ...opts, method: 'CONNECT' }, connectHandler) + } catch (err) { + if (typeof callback !== 'function') { + throw err + } + const opaque = opts?.opaque + queueMicrotask(() => callback(err, { opaque })) + } +} -/***/ 4074: -/***/ (function(module) { +module.exports = connect -module.exports = {"metadata":{"apiVersion":"2017-11-27","endpointPrefix":"mq","signingName":"mq","serviceFullName":"AmazonMQ","serviceId":"mq","protocol":"rest-json","jsonVersion":"1.1","uid":"mq-2017-11-27","signatureVersion":"v4"},"operations":{"CreateBroker":{"http":{"requestUri":"/v1/brokers","responseCode":200},"input":{"type":"structure","members":{"AuthenticationStrategy":{"locationName":"authenticationStrategy"},"AutoMinorVersionUpgrade":{"locationName":"autoMinorVersionUpgrade","type":"boolean"},"BrokerName":{"locationName":"brokerName"},"Configuration":{"shape":"S5","locationName":"configuration"},"CreatorRequestId":{"locationName":"creatorRequestId","idempotencyToken":true},"DeploymentMode":{"locationName":"deploymentMode"},"EncryptionOptions":{"shape":"S8","locationName":"encryptionOptions"},"EngineType":{"locationName":"engineType"},"EngineVersion":{"locationName":"engineVersion"},"HostInstanceType":{"locationName":"hostInstanceType"},"LdapServerMetadata":{"shape":"Sa","locationName":"ldapServerMetadata"},"Logs":{"shape":"Sc","locationName":"logs"},"MaintenanceWindowStartTime":{"shape":"Sd","locationName":"maintenanceWindowStartTime"},"PubliclyAccessible":{"locationName":"publiclyAccessible","type":"boolean"},"SecurityGroups":{"shape":"Sb","locationName":"securityGroups"},"StorageType":{"locationName":"storageType"},"SubnetIds":{"shape":"Sb","locationName":"subnetIds"},"Tags":{"shape":"Sg","locationName":"tags"},"Users":{"locationName":"users","type":"list","member":{"type":"structure","members":{"ConsoleAccess":{"locationName":"consoleAccess","type":"boolean"},"Groups":{"shape":"Sb","locationName":"groups"},"Password":{"locationName":"password"},"Username":{"locationName":"username"}}}}}},"output":{"type":"structure","members":{"BrokerArn":{"locationName":"brokerArn"},"BrokerId":{"locationName":"brokerId"}}}},"CreateConfiguration":{"http":{"requestUri":"/v1/configurations","responseCode":200},"input":{"type":"structure","members":{"AuthenticationStrategy":{"locationName":"authenticationStrategy"},"EngineType":{"locationName":"engineType"},"EngineVersion":{"locationName":"engineVersion"},"Name":{"locationName":"name"},"Tags":{"shape":"Sg","locationName":"tags"}}},"output":{"type":"structure","members":{"Arn":{"locationName":"arn"},"AuthenticationStrategy":{"locationName":"authenticationStrategy"},"Created":{"shape":"Sm","locationName":"created"},"Id":{"locationName":"id"},"LatestRevision":{"shape":"Sn","locationName":"latestRevision"},"Name":{"locationName":"name"}}}},"CreateTags":{"http":{"requestUri":"/v1/tags/{resource-arn}","responseCode":204},"input":{"type":"structure","members":{"ResourceArn":{"location":"uri","locationName":"resource-arn"},"Tags":{"shape":"Sg","locationName":"tags"}},"required":["ResourceArn"]}},"CreateUser":{"http":{"requestUri":"/v1/brokers/{broker-id}/users/{username}","responseCode":200},"input":{"type":"structure","members":{"BrokerId":{"location":"uri","locationName":"broker-id"},"ConsoleAccess":{"locationName":"consoleAccess","type":"boolean"},"Groups":{"shape":"Sb","locationName":"groups"},"Password":{"locationName":"password"},"Username":{"location":"uri","locationName":"username"}},"required":["Username","BrokerId"]},"output":{"type":"structure","members":{}}},"DeleteBroker":{"http":{"method":"DELETE","requestUri":"/v1/brokers/{broker-id}","responseCode":200},"input":{"type":"structure","members":{"BrokerId":{"location":"uri","locationName":"broker-id"}},"required":["BrokerId"]},"output":{"type":"structure","members":{"BrokerId":{"locationName":"brokerId"}}}},"DeleteTags":{"http":{"method":"DELETE","requestUri":"/v1/tags/{resource-arn}","responseCode":204},"input":{"type":"structure","members":{"ResourceArn":{"location":"uri","locationName":"resource-arn"},"TagKeys":{"shape":"Sb","location":"querystring","locationName":"tagKeys"}},"required":["TagKeys","ResourceArn"]}},"DeleteUser":{"http":{"method":"DELETE","requestUri":"/v1/brokers/{broker-id}/users/{username}","responseCode":200},"input":{"type":"structure","members":{"BrokerId":{"location":"uri","locationName":"broker-id"},"Username":{"location":"uri","locationName":"username"}},"required":["Username","BrokerId"]},"output":{"type":"structure","members":{}}},"DescribeBroker":{"http":{"method":"GET","requestUri":"/v1/brokers/{broker-id}","responseCode":200},"input":{"type":"structure","members":{"BrokerId":{"location":"uri","locationName":"broker-id"}},"required":["BrokerId"]},"output":{"type":"structure","members":{"AuthenticationStrategy":{"locationName":"authenticationStrategy"},"AutoMinorVersionUpgrade":{"locationName":"autoMinorVersionUpgrade","type":"boolean"},"BrokerArn":{"locationName":"brokerArn"},"BrokerId":{"locationName":"brokerId"},"BrokerInstances":{"locationName":"brokerInstances","type":"list","member":{"type":"structure","members":{"ConsoleURL":{"locationName":"consoleURL"},"Endpoints":{"shape":"Sb","locationName":"endpoints"},"IpAddress":{"locationName":"ipAddress"}}}},"BrokerName":{"locationName":"brokerName"},"BrokerState":{"locationName":"brokerState"},"Configurations":{"locationName":"configurations","type":"structure","members":{"Current":{"shape":"S5","locationName":"current"},"History":{"locationName":"history","type":"list","member":{"shape":"S5"}},"Pending":{"shape":"S5","locationName":"pending"}}},"Created":{"shape":"Sm","locationName":"created"},"DeploymentMode":{"locationName":"deploymentMode"},"EncryptionOptions":{"shape":"S8","locationName":"encryptionOptions"},"EngineType":{"locationName":"engineType"},"EngineVersion":{"locationName":"engineVersion"},"HostInstanceType":{"locationName":"hostInstanceType"},"LdapServerMetadata":{"shape":"S13","locationName":"ldapServerMetadata"},"Logs":{"locationName":"logs","type":"structure","members":{"Audit":{"locationName":"audit","type":"boolean"},"AuditLogGroup":{"locationName":"auditLogGroup"},"General":{"locationName":"general","type":"boolean"},"GeneralLogGroup":{"locationName":"generalLogGroup"},"Pending":{"locationName":"pending","type":"structure","members":{"Audit":{"locationName":"audit","type":"boolean"},"General":{"locationName":"general","type":"boolean"}}}}},"MaintenanceWindowStartTime":{"shape":"Sd","locationName":"maintenanceWindowStartTime"},"PendingAuthenticationStrategy":{"locationName":"pendingAuthenticationStrategy"},"PendingEngineVersion":{"locationName":"pendingEngineVersion"},"PendingHostInstanceType":{"locationName":"pendingHostInstanceType"},"PendingLdapServerMetadata":{"shape":"S13","locationName":"pendingLdapServerMetadata"},"PendingSecurityGroups":{"shape":"Sb","locationName":"pendingSecurityGroups"},"PubliclyAccessible":{"locationName":"publiclyAccessible","type":"boolean"},"SecurityGroups":{"shape":"Sb","locationName":"securityGroups"},"StorageType":{"locationName":"storageType"},"SubnetIds":{"shape":"Sb","locationName":"subnetIds"},"Tags":{"shape":"Sg","locationName":"tags"},"Users":{"shape":"S16","locationName":"users"}}}},"DescribeBrokerEngineTypes":{"http":{"method":"GET","requestUri":"/v1/broker-engine-types","responseCode":200},"input":{"type":"structure","members":{"EngineType":{"location":"querystring","locationName":"engineType"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"BrokerEngineTypes":{"locationName":"brokerEngineTypes","type":"list","member":{"type":"structure","members":{"EngineType":{"locationName":"engineType"},"EngineVersions":{"locationName":"engineVersions","type":"list","member":{"type":"structure","members":{"Name":{"locationName":"name"}}}}}}},"MaxResults":{"locationName":"maxResults","type":"integer"},"NextToken":{"locationName":"nextToken"}}}},"DescribeBrokerInstanceOptions":{"http":{"method":"GET","requestUri":"/v1/broker-instance-options","responseCode":200},"input":{"type":"structure","members":{"EngineType":{"location":"querystring","locationName":"engineType"},"HostInstanceType":{"location":"querystring","locationName":"hostInstanceType"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"},"StorageType":{"location":"querystring","locationName":"storageType"}}},"output":{"type":"structure","members":{"BrokerInstanceOptions":{"locationName":"brokerInstanceOptions","type":"list","member":{"type":"structure","members":{"AvailabilityZones":{"locationName":"availabilityZones","type":"list","member":{"type":"structure","members":{"Name":{"locationName":"name"}}}},"EngineType":{"locationName":"engineType"},"HostInstanceType":{"locationName":"hostInstanceType"},"StorageType":{"locationName":"storageType"},"SupportedDeploymentModes":{"locationName":"supportedDeploymentModes","type":"list","member":{}},"SupportedEngineVersions":{"shape":"Sb","locationName":"supportedEngineVersions"}}}},"MaxResults":{"locationName":"maxResults","type":"integer"},"NextToken":{"locationName":"nextToken"}}}},"DescribeConfiguration":{"http":{"method":"GET","requestUri":"/v1/configurations/{configuration-id}","responseCode":200},"input":{"type":"structure","members":{"ConfigurationId":{"location":"uri","locationName":"configuration-id"}},"required":["ConfigurationId"]},"output":{"type":"structure","members":{"Arn":{"locationName":"arn"},"AuthenticationStrategy":{"locationName":"authenticationStrategy"},"Created":{"shape":"Sm","locationName":"created"},"Description":{"locationName":"description"},"EngineType":{"locationName":"engineType"},"EngineVersion":{"locationName":"engineVersion"},"Id":{"locationName":"id"},"LatestRevision":{"shape":"Sn","locationName":"latestRevision"},"Name":{"locationName":"name"},"Tags":{"shape":"Sg","locationName":"tags"}}}},"DescribeConfigurationRevision":{"http":{"method":"GET","requestUri":"/v1/configurations/{configuration-id}/revisions/{configuration-revision}","responseCode":200},"input":{"type":"structure","members":{"ConfigurationId":{"location":"uri","locationName":"configuration-id"},"ConfigurationRevision":{"location":"uri","locationName":"configuration-revision"}},"required":["ConfigurationRevision","ConfigurationId"]},"output":{"type":"structure","members":{"ConfigurationId":{"locationName":"configurationId"},"Created":{"shape":"Sm","locationName":"created"},"Data":{"locationName":"data"},"Description":{"locationName":"description"}}}},"DescribeUser":{"http":{"method":"GET","requestUri":"/v1/brokers/{broker-id}/users/{username}","responseCode":200},"input":{"type":"structure","members":{"BrokerId":{"location":"uri","locationName":"broker-id"},"Username":{"location":"uri","locationName":"username"}},"required":["Username","BrokerId"]},"output":{"type":"structure","members":{"BrokerId":{"locationName":"brokerId"},"ConsoleAccess":{"locationName":"consoleAccess","type":"boolean"},"Groups":{"shape":"Sb","locationName":"groups"},"Pending":{"locationName":"pending","type":"structure","members":{"ConsoleAccess":{"locationName":"consoleAccess","type":"boolean"},"Groups":{"shape":"Sb","locationName":"groups"},"PendingChange":{"locationName":"pendingChange"}}},"Username":{"locationName":"username"}}}},"ListBrokers":{"http":{"method":"GET","requestUri":"/v1/brokers","responseCode":200},"input":{"type":"structure","members":{"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"BrokerSummaries":{"locationName":"brokerSummaries","type":"list","member":{"type":"structure","members":{"BrokerArn":{"locationName":"brokerArn"},"BrokerId":{"locationName":"brokerId"},"BrokerName":{"locationName":"brokerName"},"BrokerState":{"locationName":"brokerState"},"Created":{"shape":"Sm","locationName":"created"},"DeploymentMode":{"locationName":"deploymentMode"},"HostInstanceType":{"locationName":"hostInstanceType"}}}},"NextToken":{"locationName":"nextToken"}}}},"ListConfigurationRevisions":{"http":{"method":"GET","requestUri":"/v1/configurations/{configuration-id}/revisions","responseCode":200},"input":{"type":"structure","members":{"ConfigurationId":{"location":"uri","locationName":"configuration-id"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}},"required":["ConfigurationId"]},"output":{"type":"structure","members":{"ConfigurationId":{"locationName":"configurationId"},"MaxResults":{"locationName":"maxResults","type":"integer"},"NextToken":{"locationName":"nextToken"},"Revisions":{"locationName":"revisions","type":"list","member":{"shape":"Sn"}}}}},"ListConfigurations":{"http":{"method":"GET","requestUri":"/v1/configurations","responseCode":200},"input":{"type":"structure","members":{"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"Configurations":{"locationName":"configurations","type":"list","member":{"type":"structure","members":{"Arn":{"locationName":"arn"},"AuthenticationStrategy":{"locationName":"authenticationStrategy"},"Created":{"shape":"Sm","locationName":"created"},"Description":{"locationName":"description"},"EngineType":{"locationName":"engineType"},"EngineVersion":{"locationName":"engineVersion"},"Id":{"locationName":"id"},"LatestRevision":{"shape":"Sn","locationName":"latestRevision"},"Name":{"locationName":"name"},"Tags":{"shape":"Sg","locationName":"tags"}}}},"MaxResults":{"locationName":"maxResults","type":"integer"},"NextToken":{"locationName":"nextToken"}}}},"ListTags":{"http":{"method":"GET","requestUri":"/v1/tags/{resource-arn}","responseCode":200},"input":{"type":"structure","members":{"ResourceArn":{"location":"uri","locationName":"resource-arn"}},"required":["ResourceArn"]},"output":{"type":"structure","members":{"Tags":{"shape":"Sg","locationName":"tags"}}}},"ListUsers":{"http":{"method":"GET","requestUri":"/v1/brokers/{broker-id}/users","responseCode":200},"input":{"type":"structure","members":{"BrokerId":{"location":"uri","locationName":"broker-id"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}},"required":["BrokerId"]},"output":{"type":"structure","members":{"BrokerId":{"locationName":"brokerId"},"MaxResults":{"locationName":"maxResults","type":"integer"},"NextToken":{"locationName":"nextToken"},"Users":{"shape":"S16","locationName":"users"}}}},"RebootBroker":{"http":{"requestUri":"/v1/brokers/{broker-id}/reboot","responseCode":200},"input":{"type":"structure","members":{"BrokerId":{"location":"uri","locationName":"broker-id"}},"required":["BrokerId"]},"output":{"type":"structure","members":{}}},"UpdateBroker":{"http":{"method":"PUT","requestUri":"/v1/brokers/{broker-id}","responseCode":200},"input":{"type":"structure","members":{"AuthenticationStrategy":{"locationName":"authenticationStrategy"},"AutoMinorVersionUpgrade":{"locationName":"autoMinorVersionUpgrade","type":"boolean"},"BrokerId":{"location":"uri","locationName":"broker-id"},"Configuration":{"shape":"S5","locationName":"configuration"},"EngineVersion":{"locationName":"engineVersion"},"HostInstanceType":{"locationName":"hostInstanceType"},"LdapServerMetadata":{"shape":"Sa","locationName":"ldapServerMetadata"},"Logs":{"shape":"Sc","locationName":"logs"},"SecurityGroups":{"shape":"Sb","locationName":"securityGroups"}},"required":["BrokerId"]},"output":{"type":"structure","members":{"AuthenticationStrategy":{"locationName":"authenticationStrategy"},"AutoMinorVersionUpgrade":{"locationName":"autoMinorVersionUpgrade","type":"boolean"},"BrokerId":{"locationName":"brokerId"},"Configuration":{"shape":"S5","locationName":"configuration"},"EngineVersion":{"locationName":"engineVersion"},"HostInstanceType":{"locationName":"hostInstanceType"},"LdapServerMetadata":{"shape":"S13","locationName":"ldapServerMetadata"},"Logs":{"shape":"Sc","locationName":"logs"},"SecurityGroups":{"shape":"Sb","locationName":"securityGroups"}}}},"UpdateConfiguration":{"http":{"method":"PUT","requestUri":"/v1/configurations/{configuration-id}","responseCode":200},"input":{"type":"structure","members":{"ConfigurationId":{"location":"uri","locationName":"configuration-id"},"Data":{"locationName":"data"},"Description":{"locationName":"description"}},"required":["ConfigurationId"]},"output":{"type":"structure","members":{"Arn":{"locationName":"arn"},"Created":{"shape":"Sm","locationName":"created"},"Id":{"locationName":"id"},"LatestRevision":{"shape":"Sn","locationName":"latestRevision"},"Name":{"locationName":"name"},"Warnings":{"locationName":"warnings","type":"list","member":{"type":"structure","members":{"AttributeName":{"locationName":"attributeName"},"ElementName":{"locationName":"elementName"},"Reason":{"locationName":"reason"}}}}}}},"UpdateUser":{"http":{"method":"PUT","requestUri":"/v1/brokers/{broker-id}/users/{username}","responseCode":200},"input":{"type":"structure","members":{"BrokerId":{"location":"uri","locationName":"broker-id"},"ConsoleAccess":{"locationName":"consoleAccess","type":"boolean"},"Groups":{"shape":"Sb","locationName":"groups"},"Password":{"locationName":"password"},"Username":{"location":"uri","locationName":"username"}},"required":["Username","BrokerId"]},"output":{"type":"structure","members":{}}}},"shapes":{"S5":{"type":"structure","members":{"Id":{"locationName":"id"},"Revision":{"locationName":"revision","type":"integer"}}},"S8":{"type":"structure","members":{"KmsKeyId":{"locationName":"kmsKeyId"},"UseAwsOwnedKey":{"locationName":"useAwsOwnedKey","type":"boolean"}},"required":["UseAwsOwnedKey"]},"Sa":{"type":"structure","members":{"Hosts":{"shape":"Sb","locationName":"hosts"},"RoleBase":{"locationName":"roleBase"},"RoleName":{"locationName":"roleName"},"RoleSearchMatching":{"locationName":"roleSearchMatching"},"RoleSearchSubtree":{"locationName":"roleSearchSubtree","type":"boolean"},"ServiceAccountPassword":{"locationName":"serviceAccountPassword"},"ServiceAccountUsername":{"locationName":"serviceAccountUsername"},"UserBase":{"locationName":"userBase"},"UserRoleName":{"locationName":"userRoleName"},"UserSearchMatching":{"locationName":"userSearchMatching"},"UserSearchSubtree":{"locationName":"userSearchSubtree","type":"boolean"}}},"Sb":{"type":"list","member":{}},"Sc":{"type":"structure","members":{"Audit":{"locationName":"audit","type":"boolean"},"General":{"locationName":"general","type":"boolean"}}},"Sd":{"type":"structure","members":{"DayOfWeek":{"locationName":"dayOfWeek"},"TimeOfDay":{"locationName":"timeOfDay"},"TimeZone":{"locationName":"timeZone"}}},"Sg":{"type":"map","key":{},"value":{}},"Sm":{"type":"timestamp","timestampFormat":"iso8601"},"Sn":{"type":"structure","members":{"Created":{"shape":"Sm","locationName":"created"},"Description":{"locationName":"description"},"Revision":{"locationName":"revision","type":"integer"}}},"S13":{"type":"structure","members":{"Hosts":{"shape":"Sb","locationName":"hosts"},"RoleBase":{"locationName":"roleBase"},"RoleName":{"locationName":"roleName"},"RoleSearchMatching":{"locationName":"roleSearchMatching"},"RoleSearchSubtree":{"locationName":"roleSearchSubtree","type":"boolean"},"ServiceAccountUsername":{"locationName":"serviceAccountUsername"},"UserBase":{"locationName":"userBase"},"UserRoleName":{"locationName":"userRoleName"},"UserSearchMatching":{"locationName":"userSearchMatching"},"UserSearchSubtree":{"locationName":"userSearchSubtree","type":"boolean"}}},"S16":{"type":"list","member":{"type":"structure","members":{"PendingChange":{"locationName":"pendingChange"},"Username":{"locationName":"username"}}}}},"authorizers":{"authorization_strategy":{"name":"authorization_strategy","type":"provided","placement":{"location":"header","name":"Authorization"}}}}; /***/ }), -/***/ 4080: -/***/ (function(module) { +/***/ 6862: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = {"version":"2.0","metadata":{"apiVersion":"2017-04-19","endpointPrefix":"dax","jsonVersion":"1.1","protocol":"json","serviceAbbreviation":"Amazon DAX","serviceFullName":"Amazon DynamoDB Accelerator (DAX)","serviceId":"DAX","signatureVersion":"v4","targetPrefix":"AmazonDAXV3","uid":"dax-2017-04-19"},"operations":{"CreateCluster":{"input":{"type":"structure","required":["ClusterName","NodeType","ReplicationFactor","IamRoleArn"],"members":{"ClusterName":{},"NodeType":{},"Description":{},"ReplicationFactor":{"type":"integer"},"AvailabilityZones":{"shape":"S4"},"SubnetGroupName":{},"SecurityGroupIds":{"shape":"S5"},"PreferredMaintenanceWindow":{},"NotificationTopicArn":{},"IamRoleArn":{},"ParameterGroupName":{},"Tags":{"shape":"S6"},"SSESpecification":{"type":"structure","required":["Enabled"],"members":{"Enabled":{"type":"boolean"}}}}},"output":{"type":"structure","members":{"Cluster":{"shape":"Sb"}}}},"CreateParameterGroup":{"input":{"type":"structure","required":["ParameterGroupName"],"members":{"ParameterGroupName":{},"Description":{}}},"output":{"type":"structure","members":{"ParameterGroup":{"shape":"Sq"}}}},"CreateSubnetGroup":{"input":{"type":"structure","required":["SubnetGroupName","SubnetIds"],"members":{"SubnetGroupName":{},"Description":{},"SubnetIds":{"shape":"Ss"}}},"output":{"type":"structure","members":{"SubnetGroup":{"shape":"Su"}}}},"DecreaseReplicationFactor":{"input":{"type":"structure","required":["ClusterName","NewReplicationFactor"],"members":{"ClusterName":{},"NewReplicationFactor":{"type":"integer"},"AvailabilityZones":{"shape":"S4"},"NodeIdsToRemove":{"shape":"Se"}}},"output":{"type":"structure","members":{"Cluster":{"shape":"Sb"}}}},"DeleteCluster":{"input":{"type":"structure","required":["ClusterName"],"members":{"ClusterName":{}}},"output":{"type":"structure","members":{"Cluster":{"shape":"Sb"}}}},"DeleteParameterGroup":{"input":{"type":"structure","required":["ParameterGroupName"],"members":{"ParameterGroupName":{}}},"output":{"type":"structure","members":{"DeletionMessage":{}}}},"DeleteSubnetGroup":{"input":{"type":"structure","required":["SubnetGroupName"],"members":{"SubnetGroupName":{}}},"output":{"type":"structure","members":{"DeletionMessage":{}}}},"DescribeClusters":{"input":{"type":"structure","members":{"ClusterNames":{"type":"list","member":{}},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"NextToken":{},"Clusters":{"type":"list","member":{"shape":"Sb"}}}}},"DescribeDefaultParameters":{"input":{"type":"structure","members":{"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"NextToken":{},"Parameters":{"shape":"S1b"}}}},"DescribeEvents":{"input":{"type":"structure","members":{"SourceName":{},"SourceType":{},"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"Duration":{"type":"integer"},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"NextToken":{},"Events":{"type":"list","member":{"type":"structure","members":{"SourceName":{},"SourceType":{},"Message":{},"Date":{"type":"timestamp"}}}}}}},"DescribeParameterGroups":{"input":{"type":"structure","members":{"ParameterGroupNames":{"type":"list","member":{}},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"NextToken":{},"ParameterGroups":{"type":"list","member":{"shape":"Sq"}}}}},"DescribeParameters":{"input":{"type":"structure","required":["ParameterGroupName"],"members":{"ParameterGroupName":{},"Source":{},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"NextToken":{},"Parameters":{"shape":"S1b"}}}},"DescribeSubnetGroups":{"input":{"type":"structure","members":{"SubnetGroupNames":{"type":"list","member":{}},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"NextToken":{},"SubnetGroups":{"type":"list","member":{"shape":"Su"}}}}},"IncreaseReplicationFactor":{"input":{"type":"structure","required":["ClusterName","NewReplicationFactor"],"members":{"ClusterName":{},"NewReplicationFactor":{"type":"integer"},"AvailabilityZones":{"shape":"S4"}}},"output":{"type":"structure","members":{"Cluster":{"shape":"Sb"}}}},"ListTags":{"input":{"type":"structure","required":["ResourceName"],"members":{"ResourceName":{},"NextToken":{}}},"output":{"type":"structure","members":{"Tags":{"shape":"S6"},"NextToken":{}}}},"RebootNode":{"input":{"type":"structure","required":["ClusterName","NodeId"],"members":{"ClusterName":{},"NodeId":{}}},"output":{"type":"structure","members":{"Cluster":{"shape":"Sb"}}}},"TagResource":{"input":{"type":"structure","required":["ResourceName","Tags"],"members":{"ResourceName":{},"Tags":{"shape":"S6"}}},"output":{"type":"structure","members":{"Tags":{"shape":"S6"}}}},"UntagResource":{"input":{"type":"structure","required":["ResourceName","TagKeys"],"members":{"ResourceName":{},"TagKeys":{"type":"list","member":{}}}},"output":{"type":"structure","members":{"Tags":{"shape":"S6"}}}},"UpdateCluster":{"input":{"type":"structure","required":["ClusterName"],"members":{"ClusterName":{},"Description":{},"PreferredMaintenanceWindow":{},"NotificationTopicArn":{},"NotificationTopicStatus":{},"ParameterGroupName":{},"SecurityGroupIds":{"shape":"S5"}}},"output":{"type":"structure","members":{"Cluster":{"shape":"Sb"}}}},"UpdateParameterGroup":{"input":{"type":"structure","required":["ParameterGroupName","ParameterNameValues"],"members":{"ParameterGroupName":{},"ParameterNameValues":{"type":"list","member":{"type":"structure","members":{"ParameterName":{},"ParameterValue":{}}}}}},"output":{"type":"structure","members":{"ParameterGroup":{"shape":"Sq"}}}},"UpdateSubnetGroup":{"input":{"type":"structure","required":["SubnetGroupName"],"members":{"SubnetGroupName":{},"Description":{},"SubnetIds":{"shape":"Ss"}}},"output":{"type":"structure","members":{"SubnetGroup":{"shape":"Su"}}}}},"shapes":{"S4":{"type":"list","member":{}},"S5":{"type":"list","member":{}},"S6":{"type":"list","member":{"type":"structure","members":{"Key":{},"Value":{}}}},"Sb":{"type":"structure","members":{"ClusterName":{},"Description":{},"ClusterArn":{},"TotalNodes":{"type":"integer"},"ActiveNodes":{"type":"integer"},"NodeType":{},"Status":{},"ClusterDiscoveryEndpoint":{"shape":"Sd"},"NodeIdsToRemove":{"shape":"Se"},"Nodes":{"type":"list","member":{"type":"structure","members":{"NodeId":{},"Endpoint":{"shape":"Sd"},"NodeCreateTime":{"type":"timestamp"},"AvailabilityZone":{},"NodeStatus":{},"ParameterGroupStatus":{}}}},"PreferredMaintenanceWindow":{},"NotificationConfiguration":{"type":"structure","members":{"TopicArn":{},"TopicStatus":{}}},"SubnetGroup":{},"SecurityGroups":{"type":"list","member":{"type":"structure","members":{"SecurityGroupIdentifier":{},"Status":{}}}},"IamRoleArn":{},"ParameterGroup":{"type":"structure","members":{"ParameterGroupName":{},"ParameterApplyStatus":{},"NodeIdsToReboot":{"shape":"Se"}}},"SSEDescription":{"type":"structure","members":{"Status":{}}}}},"Sd":{"type":"structure","members":{"Address":{},"Port":{"type":"integer"}}},"Se":{"type":"list","member":{}},"Sq":{"type":"structure","members":{"ParameterGroupName":{},"Description":{}}},"Ss":{"type":"list","member":{}},"Su":{"type":"structure","members":{"SubnetGroupName":{},"Description":{},"VpcId":{},"Subnets":{"type":"list","member":{"type":"structure","members":{"SubnetIdentifier":{},"SubnetAvailabilityZone":{}}}}}},"S1b":{"type":"list","member":{"type":"structure","members":{"ParameterName":{},"ParameterType":{},"ParameterValue":{},"NodeTypeSpecificValues":{"type":"list","member":{"type":"structure","members":{"NodeType":{},"Value":{}}}},"Description":{},"Source":{},"DataType":{},"AllowedValues":{},"IsModifiable":{},"ChangeType":{}}}}}}; +"use strict"; -/***/ }), -/***/ 4086: -/***/ (function(module, __unusedexports, __webpack_require__) { +const { + Readable, + Duplex, + PassThrough +} = __nccwpck_require__(7075) +const { + InvalidArgumentError, + InvalidReturnValueError, + RequestAbortedError +} = __nccwpck_require__(8707) +const util = __nccwpck_require__(3440) +const { AsyncResource } = __nccwpck_require__(6698) +const { addSignal, removeSignal } = __nccwpck_require__(158) +const assert = __nccwpck_require__(4589) + +const kResume = Symbol('resume') + +class PipelineRequest extends Readable { + constructor () { + super({ autoDestroy: true }) + + this[kResume] = null + } -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; + _read () { + const { [kResume]: resume } = this -apiLoader.services['codecommit'] = {}; -AWS.CodeCommit = Service.defineService('codecommit', ['2015-04-13']); -Object.defineProperty(apiLoader.services['codecommit'], '2015-04-13', { - get: function get() { - var model = __webpack_require__(4208); - model.paginators = __webpack_require__(1327).pagination; - return model; - }, - enumerable: true, - configurable: true -}); + if (resume) { + this[kResume] = null + resume() + } + } -module.exports = AWS.CodeCommit; + _destroy (err, callback) { + this._read() + callback(err) + } +} -/***/ }), +class PipelineResponse extends Readable { + constructor (resume) { + super({ autoDestroy: true }) + this[kResume] = resume + } -/***/ 4100: -/***/ (function(module, __unusedexports, __webpack_require__) { + _read () { + this[kResume]() + } -"use strict"; + _destroy (err, callback) { + if (!err && !this._readableState.endEmitted) { + err = new RequestAbortedError() + } + callback(err) + } +} -var Type = __webpack_require__(4945); +class PipelineHandler extends AsyncResource { + constructor (opts, handler) { + if (!opts || typeof opts !== 'object') { + throw new InvalidArgumentError('invalid opts') + } -var _hasOwnProperty = Object.prototype.hasOwnProperty; + if (typeof handler !== 'function') { + throw new InvalidArgumentError('invalid handler') + } -function resolveYamlSet(data) { - if (data === null) return true; + const { signal, method, opaque, onInfo, responseHeaders } = opts - var key, object = data; + if (signal && typeof signal.on !== 'function' && typeof signal.addEventListener !== 'function') { + throw new InvalidArgumentError('signal must be an EventEmitter or EventTarget') + } - for (key in object) { - if (_hasOwnProperty.call(object, key)) { - if (object[key] !== null) return false; + if (method === 'CONNECT') { + throw new InvalidArgumentError('invalid method') } - } - return true; -} + if (onInfo && typeof onInfo !== 'function') { + throw new InvalidArgumentError('invalid onInfo callback') + } -function constructYamlSet(data) { - return data !== null ? data : {}; -} + super('UNDICI_PIPELINE') -module.exports = new Type('tag:yaml.org,2002:set', { - kind: 'mapping', - resolve: resolveYamlSet, - construct: constructYamlSet -}); + this.opaque = opaque || null + this.responseHeaders = responseHeaders || null + this.handler = handler + this.abort = null + this.context = null + this.onInfo = onInfo || null + this.req = new PipelineRequest().on('error', util.nop) -/***/ }), + this.ret = new Duplex({ + readableObjectMode: opts.objectMode, + autoDestroy: true, + read: () => { + const { body } = this -/***/ 4105: -/***/ (function(module, __unusedexports, __webpack_require__) { + if (body?.resume) { + body.resume() + } + }, + write: (chunk, encoding, callback) => { + const { req } = this -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; + if (req.push(chunk, encoding) || req._readableState.destroyed) { + callback() + } else { + req[kResume] = callback + } + }, + destroy: (err, callback) => { + const { body, req, res, ret, abort } = this -apiLoader.services['eventbridge'] = {}; -AWS.EventBridge = Service.defineService('eventbridge', ['2015-10-07']); -Object.defineProperty(apiLoader.services['eventbridge'], '2015-10-07', { - get: function get() { - var model = __webpack_require__(887); - model.paginators = __webpack_require__(6257).pagination; - return model; - }, - enumerable: true, - configurable: true -}); + if (!err && !ret._readableState.endEmitted) { + err = new RequestAbortedError() + } -module.exports = AWS.EventBridge; + if (abort && err) { + abort() + } + util.destroy(body, err) + util.destroy(req, err) + util.destroy(res, err) -/***/ }), + removeSignal(this) -/***/ 4112: -/***/ (function(module) { + callback(err) + } + }).on('prefinish', () => { + const { req } = this -module.exports = {"pagination":{"DescribeBackups":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Backups"},"DescribeEvents":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"ServerEvents"},"DescribeServers":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Servers"},"ListTagsForResource":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Tags"}}}; + // Node < 15 does not call _final in same tick. + req.push(null) + }) -/***/ }), + this.res = null -/***/ 4120: -/***/ (function(__unusedmodule, exports, __webpack_require__) { + addSignal(this, signal) + } -"use strict"; + onConnect (abort, context) { + const { ret, res } = this -Object.defineProperty(exports, "__esModule", { value: true }); -var LRU_1 = __webpack_require__(8629); -var CACHE_SIZE = 1000; -/** - * Inspired node-lru-cache[https://github.com/isaacs/node-lru-cache] - */ -var EndpointCache = /** @class */ (function () { - function EndpointCache(maxSize) { - if (maxSize === void 0) { maxSize = CACHE_SIZE; } - this.maxSize = maxSize; - this.cache = new LRU_1.LRUCache(maxSize); + if (this.reason) { + abort(this.reason) + return } - ; - Object.defineProperty(EndpointCache.prototype, "size", { - get: function () { - return this.cache.length; - }, - enumerable: true, - configurable: true - }); - EndpointCache.prototype.put = function (key, value) { - var keyString = typeof key !== 'string' ? EndpointCache.getKeyString(key) : key; - var endpointRecord = this.populateValue(value); - this.cache.put(keyString, endpointRecord); - }; - EndpointCache.prototype.get = function (key) { - var keyString = typeof key !== 'string' ? EndpointCache.getKeyString(key) : key; - var now = Date.now(); - var records = this.cache.get(keyString); - if (records) { - for (var i = 0; i < records.length; i++) { - var record = records[i]; - if (record.Expire < now) { - this.cache.remove(keyString); - return undefined; - } - } - } - return records; - }; - EndpointCache.getKeyString = function (key) { - var identifiers = []; - var identifierNames = Object.keys(key).sort(); - for (var i = 0; i < identifierNames.length; i++) { - var identifierName = identifierNames[i]; - if (key[identifierName] === undefined) - continue; - identifiers.push(key[identifierName]); - } - return identifiers.join(' '); - }; - EndpointCache.prototype.populateValue = function (endpoints) { - var now = Date.now(); - return endpoints.map(function (endpoint) { return ({ - Address: endpoint.Address || '', - Expire: now + (endpoint.CachePeriodInMinutes || 1) * 60 * 1000 - }); }); - }; - EndpointCache.prototype.empty = function () { - this.cache.empty(); - }; - EndpointCache.prototype.remove = function (key) { - var keyString = typeof key !== 'string' ? EndpointCache.getKeyString(key) : key; - this.cache.remove(keyString); - }; - return EndpointCache; -}()); -exports.EndpointCache = EndpointCache; -/***/ }), + assert(!res, 'pipeline cannot be retried') + assert(!ret.destroyed) -/***/ 4122: -/***/ (function(module, __unusedexports, __webpack_require__) { + this.abort = abort + this.context = context + } -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; + onHeaders (statusCode, rawHeaders, resume) { + const { opaque, handler, context } = this -apiLoader.services['connectparticipant'] = {}; -AWS.ConnectParticipant = Service.defineService('connectparticipant', ['2018-09-07']); -Object.defineProperty(apiLoader.services['connectparticipant'], '2018-09-07', { - get: function get() { - var model = __webpack_require__(8301); - model.paginators = __webpack_require__(4371).pagination; - return model; - }, - enumerable: true, - configurable: true -}); + if (statusCode < 200) { + if (this.onInfo) { + const headers = this.responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders) + this.onInfo({ statusCode, headers }) + } + return + } -module.exports = AWS.ConnectParticipant; + this.res = new PipelineResponse(resume) + let body + try { + this.handler = null + const headers = this.responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders) + body = this.runInAsyncScope(handler, null, { + statusCode, + headers, + opaque, + body: this.res, + context + }) + } catch (err) { + this.res.on('error', util.nop) + throw err + } -/***/ }), + if (!body || typeof body.on !== 'function') { + throw new InvalidReturnValueError('expected Readable') + } -/***/ 4126: -/***/ (function(module) { + body + .on('data', (chunk) => { + const { ret, body } = this -module.exports = {"pagination":{"ListJobs":{"input_token":"Marker","output_token":"Jobs[-1].JobId","more_results":"IsTruncated","limit_key":"MaxJobs","result_key":"Jobs"}}}; + if (!ret.push(chunk) && body.pause) { + body.pause() + } + }) + .on('error', (err) => { + const { ret } = this -/***/ }), + util.destroy(ret, err) + }) + .on('end', () => { + const { ret } = this -/***/ 4128: -/***/ (function(module, __unusedexports, __webpack_require__) { + ret.push(null) + }) + .on('close', () => { + const { ret } = this -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; + if (!ret._readableState.ended) { + util.destroy(ret, new RequestAbortedError()) + } + }) -apiLoader.services['networkmanager'] = {}; -AWS.NetworkManager = Service.defineService('networkmanager', ['2019-07-05']); -Object.defineProperty(apiLoader.services['networkmanager'], '2019-07-05', { - get: function get() { - var model = __webpack_require__(8424); - model.paginators = __webpack_require__(8934).pagination; - return model; - }, - enumerable: true, - configurable: true -}); + this.body = body + } -module.exports = AWS.NetworkManager; + onData (chunk) { + const { res } = this + return res.push(chunk) + } + onComplete (trailers) { + const { res } = this + res.push(null) + } -/***/ }), + onError (err) { + const { ret } = this + this.handler = null + util.destroy(ret, err) + } +} + +function pipeline (opts, handler) { + try { + const pipelineHandler = new PipelineHandler(opts, handler) + this.dispatch({ ...opts, body: pipelineHandler.req }, pipelineHandler) + return pipelineHandler.ret + } catch (err) { + return new PassThrough().destroy(err) + } +} -/***/ 4136: -/***/ (function(module) { +module.exports = pipeline -module.exports = {"pagination":{"DescribeInstanceHealth":{"result_key":"InstanceStates"},"DescribeLoadBalancerPolicies":{"result_key":"PolicyDescriptions"},"DescribeLoadBalancerPolicyTypes":{"result_key":"PolicyTypeDescriptions"},"DescribeLoadBalancers":{"input_token":"Marker","output_token":"NextMarker","result_key":"LoadBalancerDescriptions"}}}; /***/ }), -/***/ 4155: -/***/ (function(module) { +/***/ 4043: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = {"version":"2.0","metadata":{"apiVersion":"2014-05-30","endpointPrefix":"cloudhsm","jsonVersion":"1.1","protocol":"json","serviceAbbreviation":"CloudHSM","serviceFullName":"Amazon CloudHSM","serviceId":"CloudHSM","signatureVersion":"v4","targetPrefix":"CloudHsmFrontendService","uid":"cloudhsm-2014-05-30"},"operations":{"AddTagsToResource":{"input":{"type":"structure","required":["ResourceArn","TagList"],"members":{"ResourceArn":{},"TagList":{"shape":"S3"}}},"output":{"type":"structure","required":["Status"],"members":{"Status":{}}}},"CreateHapg":{"input":{"type":"structure","required":["Label"],"members":{"Label":{}}},"output":{"type":"structure","members":{"HapgArn":{}}}},"CreateHsm":{"input":{"type":"structure","required":["SubnetId","SshKey","IamRoleArn","SubscriptionType"],"members":{"SubnetId":{"locationName":"SubnetId"},"SshKey":{"locationName":"SshKey"},"EniIp":{"locationName":"EniIp"},"IamRoleArn":{"locationName":"IamRoleArn"},"ExternalId":{"locationName":"ExternalId"},"SubscriptionType":{"locationName":"SubscriptionType"},"ClientToken":{"locationName":"ClientToken"},"SyslogIp":{"locationName":"SyslogIp"}},"locationName":"CreateHsmRequest"},"output":{"type":"structure","members":{"HsmArn":{}}}},"CreateLunaClient":{"input":{"type":"structure","required":["Certificate"],"members":{"Label":{},"Certificate":{}}},"output":{"type":"structure","members":{"ClientArn":{}}}},"DeleteHapg":{"input":{"type":"structure","required":["HapgArn"],"members":{"HapgArn":{}}},"output":{"type":"structure","required":["Status"],"members":{"Status":{}}}},"DeleteHsm":{"input":{"type":"structure","required":["HsmArn"],"members":{"HsmArn":{"locationName":"HsmArn"}},"locationName":"DeleteHsmRequest"},"output":{"type":"structure","required":["Status"],"members":{"Status":{}}}},"DeleteLunaClient":{"input":{"type":"structure","required":["ClientArn"],"members":{"ClientArn":{}}},"output":{"type":"structure","required":["Status"],"members":{"Status":{}}}},"DescribeHapg":{"input":{"type":"structure","required":["HapgArn"],"members":{"HapgArn":{}}},"output":{"type":"structure","members":{"HapgArn":{},"HapgSerial":{},"HsmsLastActionFailed":{"shape":"Sz"},"HsmsPendingDeletion":{"shape":"Sz"},"HsmsPendingRegistration":{"shape":"Sz"},"Label":{},"LastModifiedTimestamp":{},"PartitionSerialList":{"shape":"S11"},"State":{}}}},"DescribeHsm":{"input":{"type":"structure","members":{"HsmArn":{},"HsmSerialNumber":{}}},"output":{"type":"structure","members":{"HsmArn":{},"Status":{},"StatusDetails":{},"AvailabilityZone":{},"EniId":{},"EniIp":{},"SubscriptionType":{},"SubscriptionStartDate":{},"SubscriptionEndDate":{},"VpcId":{},"SubnetId":{},"IamRoleArn":{},"SerialNumber":{},"VendorName":{},"HsmType":{},"SoftwareVersion":{},"SshPublicKey":{},"SshKeyLastUpdated":{},"ServerCertUri":{},"ServerCertLastUpdated":{},"Partitions":{"type":"list","member":{}}}}},"DescribeLunaClient":{"input":{"type":"structure","members":{"ClientArn":{},"CertificateFingerprint":{}}},"output":{"type":"structure","members":{"ClientArn":{},"Certificate":{},"CertificateFingerprint":{},"LastModifiedTimestamp":{},"Label":{}}}},"GetConfig":{"input":{"type":"structure","required":["ClientArn","ClientVersion","HapgList"],"members":{"ClientArn":{},"ClientVersion":{},"HapgList":{"shape":"S1i"}}},"output":{"type":"structure","members":{"ConfigType":{},"ConfigFile":{},"ConfigCred":{}}}},"ListAvailableZones":{"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"AZList":{"type":"list","member":{}}}}},"ListHapgs":{"input":{"type":"structure","members":{"NextToken":{}}},"output":{"type":"structure","required":["HapgList"],"members":{"HapgList":{"shape":"S1i"},"NextToken":{}}}},"ListHsms":{"input":{"type":"structure","members":{"NextToken":{}}},"output":{"type":"structure","members":{"HsmList":{"shape":"Sz"},"NextToken":{}}}},"ListLunaClients":{"input":{"type":"structure","members":{"NextToken":{}}},"output":{"type":"structure","required":["ClientList"],"members":{"ClientList":{"type":"list","member":{}},"NextToken":{}}}},"ListTagsForResource":{"input":{"type":"structure","required":["ResourceArn"],"members":{"ResourceArn":{}}},"output":{"type":"structure","required":["TagList"],"members":{"TagList":{"shape":"S3"}}}},"ModifyHapg":{"input":{"type":"structure","required":["HapgArn"],"members":{"HapgArn":{},"Label":{},"PartitionSerialList":{"shape":"S11"}}},"output":{"type":"structure","members":{"HapgArn":{}}}},"ModifyHsm":{"input":{"type":"structure","required":["HsmArn"],"members":{"HsmArn":{"locationName":"HsmArn"},"SubnetId":{"locationName":"SubnetId"},"EniIp":{"locationName":"EniIp"},"IamRoleArn":{"locationName":"IamRoleArn"},"ExternalId":{"locationName":"ExternalId"},"SyslogIp":{"locationName":"SyslogIp"}},"locationName":"ModifyHsmRequest"},"output":{"type":"structure","members":{"HsmArn":{}}}},"ModifyLunaClient":{"input":{"type":"structure","required":["ClientArn","Certificate"],"members":{"ClientArn":{},"Certificate":{}}},"output":{"type":"structure","members":{"ClientArn":{}}}},"RemoveTagsFromResource":{"input":{"type":"structure","required":["ResourceArn","TagKeyList"],"members":{"ResourceArn":{},"TagKeyList":{"type":"list","member":{}}}},"output":{"type":"structure","required":["Status"],"members":{"Status":{}}}}},"shapes":{"S3":{"type":"list","member":{"type":"structure","required":["Key","Value"],"members":{"Key":{},"Value":{}}}},"Sz":{"type":"list","member":{}},"S11":{"type":"list","member":{}},"S1i":{"type":"list","member":{}}}}; +"use strict"; -/***/ }), -/***/ 4208: -/***/ (function(module) { +const assert = __nccwpck_require__(4589) +const { Readable } = __nccwpck_require__(9927) +const { InvalidArgumentError, RequestAbortedError } = __nccwpck_require__(8707) +const util = __nccwpck_require__(3440) +const { getResolveErrorBodyCallback } = __nccwpck_require__(7655) +const { AsyncResource } = __nccwpck_require__(6698) -module.exports = {"version":"2.0","metadata":{"apiVersion":"2015-04-13","endpointPrefix":"codecommit","jsonVersion":"1.1","protocol":"json","serviceAbbreviation":"CodeCommit","serviceFullName":"AWS CodeCommit","serviceId":"CodeCommit","signatureVersion":"v4","targetPrefix":"CodeCommit_20150413","uid":"codecommit-2015-04-13"},"operations":{"AssociateApprovalRuleTemplateWithRepository":{"input":{"type":"structure","required":["approvalRuleTemplateName","repositoryName"],"members":{"approvalRuleTemplateName":{},"repositoryName":{}}}},"BatchAssociateApprovalRuleTemplateWithRepositories":{"input":{"type":"structure","required":["approvalRuleTemplateName","repositoryNames"],"members":{"approvalRuleTemplateName":{},"repositoryNames":{"shape":"S5"}}},"output":{"type":"structure","required":["associatedRepositoryNames","errors"],"members":{"associatedRepositoryNames":{"shape":"S5"},"errors":{"type":"list","member":{"type":"structure","members":{"repositoryName":{},"errorCode":{},"errorMessage":{}}}}}}},"BatchDescribeMergeConflicts":{"input":{"type":"structure","required":["repositoryName","destinationCommitSpecifier","sourceCommitSpecifier","mergeOption"],"members":{"repositoryName":{},"destinationCommitSpecifier":{},"sourceCommitSpecifier":{},"mergeOption":{},"maxMergeHunks":{"type":"integer"},"maxConflictFiles":{"type":"integer"},"filePaths":{"type":"list","member":{}},"conflictDetailLevel":{},"conflictResolutionStrategy":{},"nextToken":{}}},"output":{"type":"structure","required":["conflicts","destinationCommitId","sourceCommitId"],"members":{"conflicts":{"type":"list","member":{"type":"structure","members":{"conflictMetadata":{"shape":"Sn"},"mergeHunks":{"shape":"S12"}}}},"nextToken":{},"errors":{"type":"list","member":{"type":"structure","required":["filePath","exceptionName","message"],"members":{"filePath":{},"exceptionName":{},"message":{}}}},"destinationCommitId":{},"sourceCommitId":{},"baseCommitId":{}}}},"BatchDisassociateApprovalRuleTemplateFromRepositories":{"input":{"type":"structure","required":["approvalRuleTemplateName","repositoryNames"],"members":{"approvalRuleTemplateName":{},"repositoryNames":{"shape":"S5"}}},"output":{"type":"structure","required":["disassociatedRepositoryNames","errors"],"members":{"disassociatedRepositoryNames":{"shape":"S5"},"errors":{"type":"list","member":{"type":"structure","members":{"repositoryName":{},"errorCode":{},"errorMessage":{}}}}}}},"BatchGetCommits":{"input":{"type":"structure","required":["commitIds","repositoryName"],"members":{"commitIds":{"type":"list","member":{}},"repositoryName":{}}},"output":{"type":"structure","members":{"commits":{"type":"list","member":{"shape":"S1l"}},"errors":{"type":"list","member":{"type":"structure","members":{"commitId":{},"errorCode":{},"errorMessage":{}}}}}}},"BatchGetRepositories":{"input":{"type":"structure","required":["repositoryNames"],"members":{"repositoryNames":{"shape":"S5"}}},"output":{"type":"structure","members":{"repositories":{"type":"list","member":{"shape":"S1x"}},"repositoriesNotFound":{"type":"list","member":{}}}}},"CreateApprovalRuleTemplate":{"input":{"type":"structure","required":["approvalRuleTemplateName","approvalRuleTemplateContent"],"members":{"approvalRuleTemplateName":{},"approvalRuleTemplateContent":{},"approvalRuleTemplateDescription":{}}},"output":{"type":"structure","required":["approvalRuleTemplate"],"members":{"approvalRuleTemplate":{"shape":"S2c"}}}},"CreateBranch":{"input":{"type":"structure","required":["repositoryName","branchName","commitId"],"members":{"repositoryName":{},"branchName":{},"commitId":{}}}},"CreateCommit":{"input":{"type":"structure","required":["repositoryName","branchName"],"members":{"repositoryName":{},"branchName":{},"parentCommitId":{},"authorName":{},"email":{},"commitMessage":{},"keepEmptyFolders":{"type":"boolean"},"putFiles":{"type":"list","member":{"type":"structure","required":["filePath"],"members":{"filePath":{},"fileMode":{},"fileContent":{"type":"blob"},"sourceFile":{"type":"structure","required":["filePath"],"members":{"filePath":{},"isMove":{"type":"boolean"}}}}}},"deleteFiles":{"shape":"S2o"},"setFileModes":{"shape":"S2q"}}},"output":{"type":"structure","members":{"commitId":{},"treeId":{},"filesAdded":{"shape":"S2t"},"filesUpdated":{"shape":"S2t"},"filesDeleted":{"shape":"S2t"}}}},"CreatePullRequest":{"input":{"type":"structure","required":["title","targets"],"members":{"title":{},"description":{},"targets":{"type":"list","member":{"type":"structure","required":["repositoryName","sourceReference"],"members":{"repositoryName":{},"sourceReference":{},"destinationReference":{}}}},"clientRequestToken":{"idempotencyToken":true}}},"output":{"type":"structure","required":["pullRequest"],"members":{"pullRequest":{"shape":"S33"}}}},"CreatePullRequestApprovalRule":{"input":{"type":"structure","required":["pullRequestId","approvalRuleName","approvalRuleContent"],"members":{"pullRequestId":{},"approvalRuleName":{},"approvalRuleContent":{}}},"output":{"type":"structure","required":["approvalRule"],"members":{"approvalRule":{"shape":"S3c"}}}},"CreateRepository":{"input":{"type":"structure","required":["repositoryName"],"members":{"repositoryName":{},"repositoryDescription":{},"tags":{"shape":"S3k"}}},"output":{"type":"structure","members":{"repositoryMetadata":{"shape":"S1x"}}}},"CreateUnreferencedMergeCommit":{"input":{"type":"structure","required":["repositoryName","sourceCommitSpecifier","destinationCommitSpecifier","mergeOption"],"members":{"repositoryName":{},"sourceCommitSpecifier":{},"destinationCommitSpecifier":{},"mergeOption":{},"conflictDetailLevel":{},"conflictResolutionStrategy":{},"authorName":{},"email":{},"commitMessage":{},"keepEmptyFolders":{"type":"boolean"},"conflictResolution":{"shape":"S3p"}}},"output":{"type":"structure","members":{"commitId":{},"treeId":{}}}},"DeleteApprovalRuleTemplate":{"input":{"type":"structure","required":["approvalRuleTemplateName"],"members":{"approvalRuleTemplateName":{}}},"output":{"type":"structure","required":["approvalRuleTemplateId"],"members":{"approvalRuleTemplateId":{}}}},"DeleteBranch":{"input":{"type":"structure","required":["repositoryName","branchName"],"members":{"repositoryName":{},"branchName":{}}},"output":{"type":"structure","members":{"deletedBranch":{"shape":"S3y"}}}},"DeleteCommentContent":{"input":{"type":"structure","required":["commentId"],"members":{"commentId":{}}},"output":{"type":"structure","members":{"comment":{"shape":"S42"}}}},"DeleteFile":{"input":{"type":"structure","required":["repositoryName","branchName","filePath","parentCommitId"],"members":{"repositoryName":{},"branchName":{},"filePath":{},"parentCommitId":{},"keepEmptyFolders":{"type":"boolean"},"commitMessage":{},"name":{},"email":{}}},"output":{"type":"structure","required":["commitId","blobId","treeId","filePath"],"members":{"commitId":{},"blobId":{},"treeId":{},"filePath":{}}}},"DeletePullRequestApprovalRule":{"input":{"type":"structure","required":["pullRequestId","approvalRuleName"],"members":{"pullRequestId":{},"approvalRuleName":{}}},"output":{"type":"structure","required":["approvalRuleId"],"members":{"approvalRuleId":{}}}},"DeleteRepository":{"input":{"type":"structure","required":["repositoryName"],"members":{"repositoryName":{}}},"output":{"type":"structure","members":{"repositoryId":{}}}},"DescribeMergeConflicts":{"input":{"type":"structure","required":["repositoryName","destinationCommitSpecifier","sourceCommitSpecifier","mergeOption","filePath"],"members":{"repositoryName":{},"destinationCommitSpecifier":{},"sourceCommitSpecifier":{},"mergeOption":{},"maxMergeHunks":{"type":"integer"},"filePath":{},"conflictDetailLevel":{},"conflictResolutionStrategy":{},"nextToken":{}}},"output":{"type":"structure","required":["conflictMetadata","mergeHunks","destinationCommitId","sourceCommitId"],"members":{"conflictMetadata":{"shape":"Sn"},"mergeHunks":{"shape":"S12"},"nextToken":{},"destinationCommitId":{},"sourceCommitId":{},"baseCommitId":{}}}},"DescribePullRequestEvents":{"input":{"type":"structure","required":["pullRequestId"],"members":{"pullRequestId":{},"pullRequestEventType":{},"actorArn":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","required":["pullRequestEvents"],"members":{"pullRequestEvents":{"type":"list","member":{"type":"structure","members":{"pullRequestId":{},"eventDate":{"type":"timestamp"},"pullRequestEventType":{},"actorArn":{},"pullRequestCreatedEventMetadata":{"type":"structure","members":{"repositoryName":{},"sourceCommitId":{},"destinationCommitId":{},"mergeBase":{}}},"pullRequestStatusChangedEventMetadata":{"type":"structure","members":{"pullRequestStatus":{}}},"pullRequestSourceReferenceUpdatedEventMetadata":{"type":"structure","members":{"repositoryName":{},"beforeCommitId":{},"afterCommitId":{},"mergeBase":{}}},"pullRequestMergedStateChangedEventMetadata":{"type":"structure","members":{"repositoryName":{},"destinationReference":{},"mergeMetadata":{"shape":"S38"}}},"approvalRuleEventMetadata":{"type":"structure","members":{"approvalRuleName":{},"approvalRuleId":{},"approvalRuleContent":{}}},"approvalStateChangedEventMetadata":{"type":"structure","members":{"revisionId":{},"approvalStatus":{}}},"approvalRuleOverriddenEventMetadata":{"type":"structure","members":{"revisionId":{},"overrideStatus":{}}}}}},"nextToken":{}}}},"DisassociateApprovalRuleTemplateFromRepository":{"input":{"type":"structure","required":["approvalRuleTemplateName","repositoryName"],"members":{"approvalRuleTemplateName":{},"repositoryName":{}}}},"EvaluatePullRequestApprovalRules":{"input":{"type":"structure","required":["pullRequestId","revisionId"],"members":{"pullRequestId":{},"revisionId":{}}},"output":{"type":"structure","required":["evaluation"],"members":{"evaluation":{"type":"structure","members":{"approved":{"type":"boolean"},"overridden":{"type":"boolean"},"approvalRulesSatisfied":{"type":"list","member":{}},"approvalRulesNotSatisfied":{"type":"list","member":{}}}}}}},"GetApprovalRuleTemplate":{"input":{"type":"structure","required":["approvalRuleTemplateName"],"members":{"approvalRuleTemplateName":{}}},"output":{"type":"structure","required":["approvalRuleTemplate"],"members":{"approvalRuleTemplate":{"shape":"S2c"}}}},"GetBlob":{"input":{"type":"structure","required":["repositoryName","blobId"],"members":{"repositoryName":{},"blobId":{}}},"output":{"type":"structure","required":["content"],"members":{"content":{"type":"blob"}}}},"GetBranch":{"input":{"type":"structure","members":{"repositoryName":{},"branchName":{}}},"output":{"type":"structure","members":{"branch":{"shape":"S3y"}}}},"GetComment":{"input":{"type":"structure","required":["commentId"],"members":{"commentId":{}}},"output":{"type":"structure","members":{"comment":{"shape":"S42"}}}},"GetCommentReactions":{"input":{"type":"structure","required":["commentId"],"members":{"commentId":{},"reactionUserArn":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","required":["reactionsForComment"],"members":{"reactionsForComment":{"type":"list","member":{"type":"structure","members":{"reaction":{"type":"structure","members":{"emoji":{},"shortCode":{},"unicode":{}}},"reactionUsers":{"type":"list","member":{}},"reactionsFromDeletedUsersCount":{"type":"integer"}}}},"nextToken":{}}}},"GetCommentsForComparedCommit":{"input":{"type":"structure","required":["repositoryName","afterCommitId"],"members":{"repositoryName":{},"beforeCommitId":{},"afterCommitId":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"commentsForComparedCommitData":{"type":"list","member":{"type":"structure","members":{"repositoryName":{},"beforeCommitId":{},"afterCommitId":{},"beforeBlobId":{},"afterBlobId":{},"location":{"shape":"S5q"},"comments":{"shape":"S5t"}}}},"nextToken":{}}}},"GetCommentsForPullRequest":{"input":{"type":"structure","required":["pullRequestId"],"members":{"pullRequestId":{},"repositoryName":{},"beforeCommitId":{},"afterCommitId":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"commentsForPullRequestData":{"type":"list","member":{"type":"structure","members":{"pullRequestId":{},"repositoryName":{},"beforeCommitId":{},"afterCommitId":{},"beforeBlobId":{},"afterBlobId":{},"location":{"shape":"S5q"},"comments":{"shape":"S5t"}}}},"nextToken":{}}}},"GetCommit":{"input":{"type":"structure","required":["repositoryName","commitId"],"members":{"repositoryName":{},"commitId":{}}},"output":{"type":"structure","required":["commit"],"members":{"commit":{"shape":"S1l"}}}},"GetDifferences":{"input":{"type":"structure","required":["repositoryName","afterCommitSpecifier"],"members":{"repositoryName":{},"beforeCommitSpecifier":{},"afterCommitSpecifier":{},"beforePath":{},"afterPath":{},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"differences":{"type":"list","member":{"type":"structure","members":{"beforeBlob":{"shape":"S65"},"afterBlob":{"shape":"S65"},"changeType":{}}}},"NextToken":{}}}},"GetFile":{"input":{"type":"structure","required":["repositoryName","filePath"],"members":{"repositoryName":{},"commitSpecifier":{},"filePath":{}}},"output":{"type":"structure","required":["commitId","blobId","filePath","fileMode","fileSize","fileContent"],"members":{"commitId":{},"blobId":{},"filePath":{},"fileMode":{},"fileSize":{"type":"long"},"fileContent":{"type":"blob"}}}},"GetFolder":{"input":{"type":"structure","required":["repositoryName","folderPath"],"members":{"repositoryName":{},"commitSpecifier":{},"folderPath":{}}},"output":{"type":"structure","required":["commitId","folderPath"],"members":{"commitId":{},"folderPath":{},"treeId":{},"subFolders":{"type":"list","member":{"type":"structure","members":{"treeId":{},"absolutePath":{},"relativePath":{}}}},"files":{"type":"list","member":{"type":"structure","members":{"blobId":{},"absolutePath":{},"relativePath":{},"fileMode":{}}}},"symbolicLinks":{"type":"list","member":{"type":"structure","members":{"blobId":{},"absolutePath":{},"relativePath":{},"fileMode":{}}}},"subModules":{"type":"list","member":{"type":"structure","members":{"commitId":{},"absolutePath":{},"relativePath":{}}}}}}},"GetMergeCommit":{"input":{"type":"structure","required":["repositoryName","sourceCommitSpecifier","destinationCommitSpecifier"],"members":{"repositoryName":{},"sourceCommitSpecifier":{},"destinationCommitSpecifier":{},"conflictDetailLevel":{},"conflictResolutionStrategy":{}}},"output":{"type":"structure","members":{"sourceCommitId":{},"destinationCommitId":{},"baseCommitId":{},"mergedCommitId":{}}}},"GetMergeConflicts":{"input":{"type":"structure","required":["repositoryName","destinationCommitSpecifier","sourceCommitSpecifier","mergeOption"],"members":{"repositoryName":{},"destinationCommitSpecifier":{},"sourceCommitSpecifier":{},"mergeOption":{},"conflictDetailLevel":{},"maxConflictFiles":{"type":"integer"},"conflictResolutionStrategy":{},"nextToken":{}}},"output":{"type":"structure","required":["mergeable","destinationCommitId","sourceCommitId","conflictMetadataList"],"members":{"mergeable":{"type":"boolean"},"destinationCommitId":{},"sourceCommitId":{},"baseCommitId":{},"conflictMetadataList":{"type":"list","member":{"shape":"Sn"}},"nextToken":{}}}},"GetMergeOptions":{"input":{"type":"structure","required":["repositoryName","sourceCommitSpecifier","destinationCommitSpecifier"],"members":{"repositoryName":{},"sourceCommitSpecifier":{},"destinationCommitSpecifier":{},"conflictDetailLevel":{},"conflictResolutionStrategy":{}}},"output":{"type":"structure","required":["mergeOptions","sourceCommitId","destinationCommitId","baseCommitId"],"members":{"mergeOptions":{"type":"list","member":{}},"sourceCommitId":{},"destinationCommitId":{},"baseCommitId":{}}}},"GetPullRequest":{"input":{"type":"structure","required":["pullRequestId"],"members":{"pullRequestId":{}}},"output":{"type":"structure","required":["pullRequest"],"members":{"pullRequest":{"shape":"S33"}}}},"GetPullRequestApprovalStates":{"input":{"type":"structure","required":["pullRequestId","revisionId"],"members":{"pullRequestId":{},"revisionId":{}}},"output":{"type":"structure","members":{"approvals":{"type":"list","member":{"type":"structure","members":{"userArn":{},"approvalState":{}}}}}}},"GetPullRequestOverrideState":{"input":{"type":"structure","required":["pullRequestId","revisionId"],"members":{"pullRequestId":{},"revisionId":{}}},"output":{"type":"structure","members":{"overridden":{"type":"boolean"},"overrider":{}}}},"GetRepository":{"input":{"type":"structure","required":["repositoryName"],"members":{"repositoryName":{}}},"output":{"type":"structure","members":{"repositoryMetadata":{"shape":"S1x"}}}},"GetRepositoryTriggers":{"input":{"type":"structure","required":["repositoryName"],"members":{"repositoryName":{}}},"output":{"type":"structure","members":{"configurationId":{},"triggers":{"shape":"S76"}}}},"ListApprovalRuleTemplates":{"input":{"type":"structure","members":{"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"approvalRuleTemplateNames":{"shape":"S7f"},"nextToken":{}}}},"ListAssociatedApprovalRuleTemplatesForRepository":{"input":{"type":"structure","required":["repositoryName"],"members":{"repositoryName":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"approvalRuleTemplateNames":{"shape":"S7f"},"nextToken":{}}}},"ListBranches":{"input":{"type":"structure","required":["repositoryName"],"members":{"repositoryName":{},"nextToken":{}}},"output":{"type":"structure","members":{"branches":{"shape":"S7a"},"nextToken":{}}}},"ListPullRequests":{"input":{"type":"structure","required":["repositoryName"],"members":{"repositoryName":{},"authorArn":{},"pullRequestStatus":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","required":["pullRequestIds"],"members":{"pullRequestIds":{"type":"list","member":{}},"nextToken":{}}}},"ListRepositories":{"input":{"type":"structure","members":{"nextToken":{},"sortBy":{},"order":{}}},"output":{"type":"structure","members":{"repositories":{"type":"list","member":{"type":"structure","members":{"repositoryName":{},"repositoryId":{}}}},"nextToken":{}}}},"ListRepositoriesForApprovalRuleTemplate":{"input":{"type":"structure","required":["approvalRuleTemplateName"],"members":{"approvalRuleTemplateName":{},"nextToken":{},"maxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"repositoryNames":{"shape":"S5"},"nextToken":{}}}},"ListTagsForResource":{"input":{"type":"structure","required":["resourceArn"],"members":{"resourceArn":{},"nextToken":{}}},"output":{"type":"structure","members":{"tags":{"shape":"S3k"},"nextToken":{}}}},"MergeBranchesByFastForward":{"input":{"type":"structure","required":["repositoryName","sourceCommitSpecifier","destinationCommitSpecifier"],"members":{"repositoryName":{},"sourceCommitSpecifier":{},"destinationCommitSpecifier":{},"targetBranch":{}}},"output":{"type":"structure","members":{"commitId":{},"treeId":{}}}},"MergeBranchesBySquash":{"input":{"type":"structure","required":["repositoryName","sourceCommitSpecifier","destinationCommitSpecifier"],"members":{"repositoryName":{},"sourceCommitSpecifier":{},"destinationCommitSpecifier":{},"targetBranch":{},"conflictDetailLevel":{},"conflictResolutionStrategy":{},"authorName":{},"email":{},"commitMessage":{},"keepEmptyFolders":{"type":"boolean"},"conflictResolution":{"shape":"S3p"}}},"output":{"type":"structure","members":{"commitId":{},"treeId":{}}}},"MergeBranchesByThreeWay":{"input":{"type":"structure","required":["repositoryName","sourceCommitSpecifier","destinationCommitSpecifier"],"members":{"repositoryName":{},"sourceCommitSpecifier":{},"destinationCommitSpecifier":{},"targetBranch":{},"conflictDetailLevel":{},"conflictResolutionStrategy":{},"authorName":{},"email":{},"commitMessage":{},"keepEmptyFolders":{"type":"boolean"},"conflictResolution":{"shape":"S3p"}}},"output":{"type":"structure","members":{"commitId":{},"treeId":{}}}},"MergePullRequestByFastForward":{"input":{"type":"structure","required":["pullRequestId","repositoryName"],"members":{"pullRequestId":{},"repositoryName":{},"sourceCommitId":{}}},"output":{"type":"structure","members":{"pullRequest":{"shape":"S33"}}}},"MergePullRequestBySquash":{"input":{"type":"structure","required":["pullRequestId","repositoryName"],"members":{"pullRequestId":{},"repositoryName":{},"sourceCommitId":{},"conflictDetailLevel":{},"conflictResolutionStrategy":{},"commitMessage":{},"authorName":{},"email":{},"keepEmptyFolders":{"type":"boolean"},"conflictResolution":{"shape":"S3p"}}},"output":{"type":"structure","members":{"pullRequest":{"shape":"S33"}}}},"MergePullRequestByThreeWay":{"input":{"type":"structure","required":["pullRequestId","repositoryName"],"members":{"pullRequestId":{},"repositoryName":{},"sourceCommitId":{},"conflictDetailLevel":{},"conflictResolutionStrategy":{},"commitMessage":{},"authorName":{},"email":{},"keepEmptyFolders":{"type":"boolean"},"conflictResolution":{"shape":"S3p"}}},"output":{"type":"structure","members":{"pullRequest":{"shape":"S33"}}}},"OverridePullRequestApprovalRules":{"input":{"type":"structure","required":["pullRequestId","revisionId","overrideStatus"],"members":{"pullRequestId":{},"revisionId":{},"overrideStatus":{}}}},"PostCommentForComparedCommit":{"input":{"type":"structure","required":["repositoryName","afterCommitId","content"],"members":{"repositoryName":{},"beforeCommitId":{},"afterCommitId":{},"location":{"shape":"S5q"},"content":{},"clientRequestToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"repositoryName":{},"beforeCommitId":{},"afterCommitId":{},"beforeBlobId":{},"afterBlobId":{},"location":{"shape":"S5q"},"comment":{"shape":"S42"}}},"idempotent":true},"PostCommentForPullRequest":{"input":{"type":"structure","required":["pullRequestId","repositoryName","beforeCommitId","afterCommitId","content"],"members":{"pullRequestId":{},"repositoryName":{},"beforeCommitId":{},"afterCommitId":{},"location":{"shape":"S5q"},"content":{},"clientRequestToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"repositoryName":{},"pullRequestId":{},"beforeCommitId":{},"afterCommitId":{},"beforeBlobId":{},"afterBlobId":{},"location":{"shape":"S5q"},"comment":{"shape":"S42"}}},"idempotent":true},"PostCommentReply":{"input":{"type":"structure","required":["inReplyTo","content"],"members":{"inReplyTo":{},"clientRequestToken":{"idempotencyToken":true},"content":{}}},"output":{"type":"structure","members":{"comment":{"shape":"S42"}}},"idempotent":true},"PutCommentReaction":{"input":{"type":"structure","required":["commentId","reactionValue"],"members":{"commentId":{},"reactionValue":{}}}},"PutFile":{"input":{"type":"structure","required":["repositoryName","branchName","fileContent","filePath"],"members":{"repositoryName":{},"branchName":{},"fileContent":{"type":"blob"},"filePath":{},"fileMode":{},"parentCommitId":{},"commitMessage":{},"name":{},"email":{}}},"output":{"type":"structure","required":["commitId","blobId","treeId"],"members":{"commitId":{},"blobId":{},"treeId":{}}}},"PutRepositoryTriggers":{"input":{"type":"structure","required":["repositoryName","triggers"],"members":{"repositoryName":{},"triggers":{"shape":"S76"}}},"output":{"type":"structure","members":{"configurationId":{}}}},"TagResource":{"input":{"type":"structure","required":["resourceArn","tags"],"members":{"resourceArn":{},"tags":{"shape":"S3k"}}}},"TestRepositoryTriggers":{"input":{"type":"structure","required":["repositoryName","triggers"],"members":{"repositoryName":{},"triggers":{"shape":"S76"}}},"output":{"type":"structure","members":{"successfulExecutions":{"type":"list","member":{}},"failedExecutions":{"type":"list","member":{"type":"structure","members":{"trigger":{},"failureMessage":{}}}}}}},"UntagResource":{"input":{"type":"structure","required":["resourceArn","tagKeys"],"members":{"resourceArn":{},"tagKeys":{"type":"list","member":{}}}}},"UpdateApprovalRuleTemplateContent":{"input":{"type":"structure","required":["approvalRuleTemplateName","newRuleContent"],"members":{"approvalRuleTemplateName":{},"newRuleContent":{},"existingRuleContentSha256":{}}},"output":{"type":"structure","required":["approvalRuleTemplate"],"members":{"approvalRuleTemplate":{"shape":"S2c"}}}},"UpdateApprovalRuleTemplateDescription":{"input":{"type":"structure","required":["approvalRuleTemplateName","approvalRuleTemplateDescription"],"members":{"approvalRuleTemplateName":{},"approvalRuleTemplateDescription":{}}},"output":{"type":"structure","required":["approvalRuleTemplate"],"members":{"approvalRuleTemplate":{"shape":"S2c"}}}},"UpdateApprovalRuleTemplateName":{"input":{"type":"structure","required":["oldApprovalRuleTemplateName","newApprovalRuleTemplateName"],"members":{"oldApprovalRuleTemplateName":{},"newApprovalRuleTemplateName":{}}},"output":{"type":"structure","required":["approvalRuleTemplate"],"members":{"approvalRuleTemplate":{"shape":"S2c"}}}},"UpdateComment":{"input":{"type":"structure","required":["commentId","content"],"members":{"commentId":{},"content":{}}},"output":{"type":"structure","members":{"comment":{"shape":"S42"}}}},"UpdateDefaultBranch":{"input":{"type":"structure","required":["repositoryName","defaultBranchName"],"members":{"repositoryName":{},"defaultBranchName":{}}}},"UpdatePullRequestApprovalRuleContent":{"input":{"type":"structure","required":["pullRequestId","approvalRuleName","newRuleContent"],"members":{"pullRequestId":{},"approvalRuleName":{},"existingRuleContentSha256":{},"newRuleContent":{}}},"output":{"type":"structure","required":["approvalRule"],"members":{"approvalRule":{"shape":"S3c"}}}},"UpdatePullRequestApprovalState":{"input":{"type":"structure","required":["pullRequestId","revisionId","approvalState"],"members":{"pullRequestId":{},"revisionId":{},"approvalState":{}}}},"UpdatePullRequestDescription":{"input":{"type":"structure","required":["pullRequestId","description"],"members":{"pullRequestId":{},"description":{}}},"output":{"type":"structure","required":["pullRequest"],"members":{"pullRequest":{"shape":"S33"}}}},"UpdatePullRequestStatus":{"input":{"type":"structure","required":["pullRequestId","pullRequestStatus"],"members":{"pullRequestId":{},"pullRequestStatus":{}}},"output":{"type":"structure","required":["pullRequest"],"members":{"pullRequest":{"shape":"S33"}}}},"UpdatePullRequestTitle":{"input":{"type":"structure","required":["pullRequestId","title"],"members":{"pullRequestId":{},"title":{}}},"output":{"type":"structure","required":["pullRequest"],"members":{"pullRequest":{"shape":"S33"}}}},"UpdateRepositoryDescription":{"input":{"type":"structure","required":["repositoryName"],"members":{"repositoryName":{},"repositoryDescription":{}}}},"UpdateRepositoryName":{"input":{"type":"structure","required":["oldName","newName"],"members":{"oldName":{},"newName":{}}}}},"shapes":{"S5":{"type":"list","member":{}},"Sn":{"type":"structure","members":{"filePath":{},"fileSizes":{"type":"structure","members":{"source":{"type":"long"},"destination":{"type":"long"},"base":{"type":"long"}}},"fileModes":{"type":"structure","members":{"source":{},"destination":{},"base":{}}},"objectTypes":{"type":"structure","members":{"source":{},"destination":{},"base":{}}},"numberOfConflicts":{"type":"integer"},"isBinaryFile":{"type":"structure","members":{"source":{"type":"boolean"},"destination":{"type":"boolean"},"base":{"type":"boolean"}}},"contentConflict":{"type":"boolean"},"fileModeConflict":{"type":"boolean"},"objectTypeConflict":{"type":"boolean"},"mergeOperations":{"type":"structure","members":{"source":{},"destination":{}}}}},"S12":{"type":"list","member":{"type":"structure","members":{"isConflict":{"type":"boolean"},"source":{"shape":"S15"},"destination":{"shape":"S15"},"base":{"shape":"S15"}}}},"S15":{"type":"structure","members":{"startLine":{"type":"integer"},"endLine":{"type":"integer"},"hunkContent":{}}},"S1l":{"type":"structure","members":{"commitId":{},"treeId":{},"parents":{"type":"list","member":{}},"message":{},"author":{"shape":"S1n"},"committer":{"shape":"S1n"},"additionalData":{}}},"S1n":{"type":"structure","members":{"name":{},"email":{},"date":{}}},"S1x":{"type":"structure","members":{"accountId":{},"repositoryId":{},"repositoryName":{},"repositoryDescription":{},"defaultBranch":{},"lastModifiedDate":{"type":"timestamp"},"creationDate":{"type":"timestamp"},"cloneUrlHttp":{},"cloneUrlSsh":{},"Arn":{}}},"S2c":{"type":"structure","members":{"approvalRuleTemplateId":{},"approvalRuleTemplateName":{},"approvalRuleTemplateDescription":{},"approvalRuleTemplateContent":{},"ruleContentSha256":{},"lastModifiedDate":{"type":"timestamp"},"creationDate":{"type":"timestamp"},"lastModifiedUser":{}}},"S2o":{"type":"list","member":{"type":"structure","required":["filePath"],"members":{"filePath":{}}}},"S2q":{"type":"list","member":{"type":"structure","required":["filePath","fileMode"],"members":{"filePath":{},"fileMode":{}}}},"S2t":{"type":"list","member":{"type":"structure","members":{"absolutePath":{},"blobId":{},"fileMode":{}}}},"S33":{"type":"structure","members":{"pullRequestId":{},"title":{},"description":{},"lastActivityDate":{"type":"timestamp"},"creationDate":{"type":"timestamp"},"pullRequestStatus":{},"authorArn":{},"pullRequestTargets":{"type":"list","member":{"type":"structure","members":{"repositoryName":{},"sourceReference":{},"destinationReference":{},"destinationCommit":{},"sourceCommit":{},"mergeBase":{},"mergeMetadata":{"shape":"S38"}}}},"clientRequestToken":{},"revisionId":{},"approvalRules":{"type":"list","member":{"shape":"S3c"}}}},"S38":{"type":"structure","members":{"isMerged":{"type":"boolean"},"mergedBy":{},"mergeCommitId":{},"mergeOption":{}}},"S3c":{"type":"structure","members":{"approvalRuleId":{},"approvalRuleName":{},"approvalRuleContent":{},"ruleContentSha256":{},"lastModifiedDate":{"type":"timestamp"},"creationDate":{"type":"timestamp"},"lastModifiedUser":{},"originApprovalRuleTemplate":{"type":"structure","members":{"approvalRuleTemplateId":{},"approvalRuleTemplateName":{}}}}},"S3k":{"type":"map","key":{},"value":{}},"S3p":{"type":"structure","members":{"replaceContents":{"type":"list","member":{"type":"structure","required":["filePath","replacementType"],"members":{"filePath":{},"replacementType":{},"content":{"type":"blob"},"fileMode":{}}}},"deleteFiles":{"shape":"S2o"},"setFileModes":{"shape":"S2q"}}},"S3y":{"type":"structure","members":{"branchName":{},"commitId":{}}},"S42":{"type":"structure","members":{"commentId":{},"content":{},"inReplyTo":{},"creationDate":{"type":"timestamp"},"lastModifiedDate":{"type":"timestamp"},"authorArn":{},"deleted":{"type":"boolean"},"clientRequestToken":{},"callerReactions":{"type":"list","member":{}},"reactionCounts":{"type":"map","key":{},"value":{"type":"integer"}}}},"S5q":{"type":"structure","members":{"filePath":{},"filePosition":{"type":"long"},"relativeFileVersion":{}}},"S5t":{"type":"list","member":{"shape":"S42"}},"S65":{"type":"structure","members":{"blobId":{},"path":{},"mode":{}}},"S76":{"type":"list","member":{"type":"structure","required":["name","destinationArn","events"],"members":{"name":{},"destinationArn":{},"customData":{},"branches":{"shape":"S7a"},"events":{"type":"list","member":{}}}}},"S7a":{"type":"list","member":{}},"S7f":{"type":"list","member":{}}}}; +class RequestHandler extends AsyncResource { + constructor (opts, callback) { + if (!opts || typeof opts !== 'object') { + throw new InvalidArgumentError('invalid opts') + } -/***/ }), + const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError, highWaterMark } = opts -/***/ 4211: -/***/ (function(module, __unusedexports, __webpack_require__) { + try { + if (typeof callback !== 'function') { + throw new InvalidArgumentError('invalid callback') + } -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; + if (highWaterMark && (typeof highWaterMark !== 'number' || highWaterMark < 0)) { + throw new InvalidArgumentError('invalid highWaterMark') + } -apiLoader.services['polly'] = {}; -AWS.Polly = Service.defineService('polly', ['2016-06-10']); -__webpack_require__(1531); -Object.defineProperty(apiLoader.services['polly'], '2016-06-10', { - get: function get() { - var model = __webpack_require__(3132); - model.paginators = __webpack_require__(5902).pagination; - return model; - }, - enumerable: true, - configurable: true -}); + if (signal && typeof signal.on !== 'function' && typeof signal.addEventListener !== 'function') { + throw new InvalidArgumentError('signal must be an EventEmitter or EventTarget') + } -module.exports = AWS.Polly; + if (method === 'CONNECT') { + throw new InvalidArgumentError('invalid method') + } + if (onInfo && typeof onInfo !== 'function') { + throw new InvalidArgumentError('invalid onInfo callback') + } -/***/ }), + super('UNDICI_REQUEST') + } catch (err) { + if (util.isStream(body)) { + util.destroy(body.on('error', util.nop), err) + } + throw err + } + + this.method = method + this.responseHeaders = responseHeaders || null + this.opaque = opaque || null + this.callback = callback + this.res = null + this.abort = null + this.body = body + this.trailers = {} + this.context = null + this.onInfo = onInfo || null + this.throwOnError = throwOnError + this.highWaterMark = highWaterMark + this.signal = signal + this.reason = null + this.removeAbortListener = null + + if (util.isStream(body)) { + body.on('error', (err) => { + this.onError(err) + }) + } -/***/ 4220: -/***/ (function(module) { + if (this.signal) { + if (this.signal.aborted) { + this.reason = this.signal.reason ?? new RequestAbortedError() + } else { + this.removeAbortListener = util.addAbortListener(this.signal, () => { + this.reason = this.signal.reason ?? new RequestAbortedError() + if (this.res) { + util.destroy(this.res.on('error', util.nop), this.reason) + } else if (this.abort) { + this.abort(this.reason) + } -module.exports = {"version":"2.0","metadata":{"apiVersion":"2017-10-01","endpointPrefix":"workmail","jsonVersion":"1.1","protocol":"json","serviceFullName":"Amazon WorkMail","serviceId":"WorkMail","signatureVersion":"v4","targetPrefix":"WorkMailService","uid":"workmail-2017-10-01"},"operations":{"AssociateDelegateToResource":{"input":{"type":"structure","required":["OrganizationId","ResourceId","EntityId"],"members":{"OrganizationId":{},"ResourceId":{},"EntityId":{}}},"output":{"type":"structure","members":{}},"idempotent":true},"AssociateMemberToGroup":{"input":{"type":"structure","required":["OrganizationId","GroupId","MemberId"],"members":{"OrganizationId":{},"GroupId":{},"MemberId":{}}},"output":{"type":"structure","members":{}},"idempotent":true},"CreateAlias":{"input":{"type":"structure","required":["OrganizationId","EntityId","Alias"],"members":{"OrganizationId":{},"EntityId":{},"Alias":{}}},"output":{"type":"structure","members":{}},"idempotent":true},"CreateGroup":{"input":{"type":"structure","required":["OrganizationId","Name"],"members":{"OrganizationId":{},"Name":{}}},"output":{"type":"structure","members":{"GroupId":{}}},"idempotent":true},"CreateResource":{"input":{"type":"structure","required":["OrganizationId","Name","Type"],"members":{"OrganizationId":{},"Name":{},"Type":{}}},"output":{"type":"structure","members":{"ResourceId":{}}},"idempotent":true},"CreateUser":{"input":{"type":"structure","required":["OrganizationId","Name","DisplayName","Password"],"members":{"OrganizationId":{},"Name":{},"DisplayName":{},"Password":{"shape":"Sl"}}},"output":{"type":"structure","members":{"UserId":{}}},"idempotent":true},"DeleteAccessControlRule":{"input":{"type":"structure","required":["OrganizationId","Name"],"members":{"OrganizationId":{},"Name":{}}},"output":{"type":"structure","members":{}}},"DeleteAlias":{"input":{"type":"structure","required":["OrganizationId","EntityId","Alias"],"members":{"OrganizationId":{},"EntityId":{},"Alias":{}}},"output":{"type":"structure","members":{}},"idempotent":true},"DeleteGroup":{"input":{"type":"structure","required":["OrganizationId","GroupId"],"members":{"OrganizationId":{},"GroupId":{}}},"output":{"type":"structure","members":{}},"idempotent":true},"DeleteMailboxPermissions":{"input":{"type":"structure","required":["OrganizationId","EntityId","GranteeId"],"members":{"OrganizationId":{},"EntityId":{},"GranteeId":{}}},"output":{"type":"structure","members":{}},"idempotent":true},"DeleteResource":{"input":{"type":"structure","required":["OrganizationId","ResourceId"],"members":{"OrganizationId":{},"ResourceId":{}}},"output":{"type":"structure","members":{}},"idempotent":true},"DeleteRetentionPolicy":{"input":{"type":"structure","required":["OrganizationId","Id"],"members":{"OrganizationId":{},"Id":{}}},"output":{"type":"structure","members":{}},"idempotent":true},"DeleteUser":{"input":{"type":"structure","required":["OrganizationId","UserId"],"members":{"OrganizationId":{},"UserId":{}}},"output":{"type":"structure","members":{}},"idempotent":true},"DeregisterFromWorkMail":{"input":{"type":"structure","required":["OrganizationId","EntityId"],"members":{"OrganizationId":{},"EntityId":{}}},"output":{"type":"structure","members":{}},"idempotent":true},"DescribeGroup":{"input":{"type":"structure","required":["OrganizationId","GroupId"],"members":{"OrganizationId":{},"GroupId":{}}},"output":{"type":"structure","members":{"GroupId":{},"Name":{},"Email":{},"State":{},"EnabledDate":{"type":"timestamp"},"DisabledDate":{"type":"timestamp"}}},"idempotent":true},"DescribeOrganization":{"input":{"type":"structure","required":["OrganizationId"],"members":{"OrganizationId":{}}},"output":{"type":"structure","members":{"OrganizationId":{},"Alias":{},"State":{},"DirectoryId":{},"DirectoryType":{},"DefaultMailDomain":{},"CompletedDate":{"type":"timestamp"},"ErrorMessage":{},"ARN":{}}},"idempotent":true},"DescribeResource":{"input":{"type":"structure","required":["OrganizationId","ResourceId"],"members":{"OrganizationId":{},"ResourceId":{}}},"output":{"type":"structure","members":{"ResourceId":{},"Email":{},"Name":{},"Type":{},"BookingOptions":{"shape":"S1f"},"State":{},"EnabledDate":{"type":"timestamp"},"DisabledDate":{"type":"timestamp"}}},"idempotent":true},"DescribeUser":{"input":{"type":"structure","required":["OrganizationId","UserId"],"members":{"OrganizationId":{},"UserId":{}}},"output":{"type":"structure","members":{"UserId":{},"Name":{},"Email":{},"DisplayName":{},"State":{},"UserRole":{},"EnabledDate":{"type":"timestamp"},"DisabledDate":{"type":"timestamp"}}},"idempotent":true},"DisassociateDelegateFromResource":{"input":{"type":"structure","required":["OrganizationId","ResourceId","EntityId"],"members":{"OrganizationId":{},"ResourceId":{},"EntityId":{}}},"output":{"type":"structure","members":{}},"idempotent":true},"DisassociateMemberFromGroup":{"input":{"type":"structure","required":["OrganizationId","GroupId","MemberId"],"members":{"OrganizationId":{},"GroupId":{},"MemberId":{}}},"output":{"type":"structure","members":{}},"idempotent":true},"GetAccessControlEffect":{"input":{"type":"structure","required":["OrganizationId","IpAddress","Action","UserId"],"members":{"OrganizationId":{},"IpAddress":{},"Action":{},"UserId":{}}},"output":{"type":"structure","members":{"Effect":{},"MatchedRules":{"type":"list","member":{}}}}},"GetDefaultRetentionPolicy":{"input":{"type":"structure","required":["OrganizationId"],"members":{"OrganizationId":{}}},"output":{"type":"structure","members":{"Id":{},"Name":{},"Description":{},"FolderConfigurations":{"shape":"S1w"}}},"idempotent":true},"GetMailboxDetails":{"input":{"type":"structure","required":["OrganizationId","UserId"],"members":{"OrganizationId":{},"UserId":{}}},"output":{"type":"structure","members":{"MailboxQuota":{"type":"integer"},"MailboxSize":{"type":"double"}}},"idempotent":true},"ListAccessControlRules":{"input":{"type":"structure","required":["OrganizationId"],"members":{"OrganizationId":{}}},"output":{"type":"structure","members":{"Rules":{"type":"list","member":{"type":"structure","members":{"Name":{},"Effect":{},"Description":{},"IpRanges":{"shape":"S2a"},"NotIpRanges":{"shape":"S2a"},"Actions":{"shape":"S2c"},"NotActions":{"shape":"S2c"},"UserIds":{"shape":"S2d"},"NotUserIds":{"shape":"S2d"},"DateCreated":{"type":"timestamp"},"DateModified":{"type":"timestamp"}}}}}}},"ListAliases":{"input":{"type":"structure","required":["OrganizationId","EntityId"],"members":{"OrganizationId":{},"EntityId":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"Aliases":{"type":"list","member":{}},"NextToken":{}}},"idempotent":true},"ListGroupMembers":{"input":{"type":"structure","required":["OrganizationId","GroupId"],"members":{"OrganizationId":{},"GroupId":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"Members":{"type":"list","member":{"type":"structure","members":{"Id":{},"Name":{},"Type":{},"State":{},"EnabledDate":{"type":"timestamp"},"DisabledDate":{"type":"timestamp"}}}},"NextToken":{}}},"idempotent":true},"ListGroups":{"input":{"type":"structure","required":["OrganizationId"],"members":{"OrganizationId":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"Groups":{"type":"list","member":{"type":"structure","members":{"Id":{},"Email":{},"Name":{},"State":{},"EnabledDate":{"type":"timestamp"},"DisabledDate":{"type":"timestamp"}}}},"NextToken":{}}},"idempotent":true},"ListMailboxPermissions":{"input":{"type":"structure","required":["OrganizationId","EntityId"],"members":{"OrganizationId":{},"EntityId":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"Permissions":{"type":"list","member":{"type":"structure","required":["GranteeId","GranteeType","PermissionValues"],"members":{"GranteeId":{},"GranteeType":{},"PermissionValues":{"shape":"S2w"}}}},"NextToken":{}}},"idempotent":true},"ListOrganizations":{"input":{"type":"structure","members":{"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"OrganizationSummaries":{"type":"list","member":{"type":"structure","members":{"OrganizationId":{},"Alias":{},"ErrorMessage":{},"State":{}}}},"NextToken":{}}},"idempotent":true},"ListResourceDelegates":{"input":{"type":"structure","required":["OrganizationId","ResourceId"],"members":{"OrganizationId":{},"ResourceId":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"Delegates":{"type":"list","member":{"type":"structure","required":["Id","Type"],"members":{"Id":{},"Type":{}}}},"NextToken":{}}},"idempotent":true},"ListResources":{"input":{"type":"structure","required":["OrganizationId"],"members":{"OrganizationId":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"Resources":{"type":"list","member":{"type":"structure","members":{"Id":{},"Email":{},"Name":{},"Type":{},"State":{},"EnabledDate":{"type":"timestamp"},"DisabledDate":{"type":"timestamp"}}}},"NextToken":{}}},"idempotent":true},"ListTagsForResource":{"input":{"type":"structure","required":["ResourceARN"],"members":{"ResourceARN":{}}},"output":{"type":"structure","members":{"Tags":{"shape":"S3c"}}}},"ListUsers":{"input":{"type":"structure","required":["OrganizationId"],"members":{"OrganizationId":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"Users":{"type":"list","member":{"type":"structure","members":{"Id":{},"Email":{},"Name":{},"DisplayName":{},"State":{},"UserRole":{},"EnabledDate":{"type":"timestamp"},"DisabledDate":{"type":"timestamp"}}}},"NextToken":{}}},"idempotent":true},"PutAccessControlRule":{"input":{"type":"structure","required":["Name","Effect","Description","OrganizationId"],"members":{"Name":{},"Effect":{},"Description":{},"IpRanges":{"shape":"S2a"},"NotIpRanges":{"shape":"S2a"},"Actions":{"shape":"S2c"},"NotActions":{"shape":"S2c"},"UserIds":{"shape":"S2d"},"NotUserIds":{"shape":"S2d"},"OrganizationId":{}}},"output":{"type":"structure","members":{}}},"PutMailboxPermissions":{"input":{"type":"structure","required":["OrganizationId","EntityId","GranteeId","PermissionValues"],"members":{"OrganizationId":{},"EntityId":{},"GranteeId":{},"PermissionValues":{"shape":"S2w"}}},"output":{"type":"structure","members":{}},"idempotent":true},"PutRetentionPolicy":{"input":{"type":"structure","required":["OrganizationId","Name","FolderConfigurations"],"members":{"OrganizationId":{},"Id":{},"Name":{},"Description":{},"FolderConfigurations":{"shape":"S1w"}}},"output":{"type":"structure","members":{}},"idempotent":true},"RegisterToWorkMail":{"input":{"type":"structure","required":["OrganizationId","EntityId","Email"],"members":{"OrganizationId":{},"EntityId":{},"Email":{}}},"output":{"type":"structure","members":{}},"idempotent":true},"ResetPassword":{"input":{"type":"structure","required":["OrganizationId","UserId","Password"],"members":{"OrganizationId":{},"UserId":{},"Password":{"shape":"Sl"}}},"output":{"type":"structure","members":{}},"idempotent":true},"TagResource":{"input":{"type":"structure","required":["ResourceARN","Tags"],"members":{"ResourceARN":{},"Tags":{"shape":"S3c"}}},"output":{"type":"structure","members":{}}},"UntagResource":{"input":{"type":"structure","required":["ResourceARN","TagKeys"],"members":{"ResourceARN":{},"TagKeys":{"type":"list","member":{}}}},"output":{"type":"structure","members":{}}},"UpdateMailboxQuota":{"input":{"type":"structure","required":["OrganizationId","UserId","MailboxQuota"],"members":{"OrganizationId":{},"UserId":{},"MailboxQuota":{"type":"integer"}}},"output":{"type":"structure","members":{}},"idempotent":true},"UpdatePrimaryEmailAddress":{"input":{"type":"structure","required":["OrganizationId","EntityId","Email"],"members":{"OrganizationId":{},"EntityId":{},"Email":{}}},"output":{"type":"structure","members":{}},"idempotent":true},"UpdateResource":{"input":{"type":"structure","required":["OrganizationId","ResourceId"],"members":{"OrganizationId":{},"ResourceId":{},"Name":{},"BookingOptions":{"shape":"S1f"}}},"output":{"type":"structure","members":{}},"idempotent":true}},"shapes":{"Sl":{"type":"string","sensitive":true},"S1f":{"type":"structure","members":{"AutoAcceptRequests":{"type":"boolean"},"AutoDeclineRecurringRequests":{"type":"boolean"},"AutoDeclineConflictingRequests":{"type":"boolean"}}},"S1w":{"type":"list","member":{"type":"structure","required":["Name","Action"],"members":{"Name":{},"Action":{},"Period":{"type":"integer"}}}},"S2a":{"type":"list","member":{}},"S2c":{"type":"list","member":{}},"S2d":{"type":"list","member":{}},"S2w":{"type":"list","member":{}},"S3c":{"type":"list","member":{"type":"structure","required":["Key","Value"],"members":{"Key":{},"Value":{}}}}}}; + if (this.removeAbortListener) { + this.res?.off('close', this.removeAbortListener) + this.removeAbortListener() + this.removeAbortListener = null + } + }) + } + } + } -/***/ }), + onConnect (abort, context) { + if (this.reason) { + abort(this.reason) + return + } -/***/ 4221: -/***/ (function(module) { + assert(this.callback) -module.exports = {"pagination":{"DescribeRemediationExceptions":{"input_token":"NextToken","limit_key":"Limit","output_token":"NextToken"},"DescribeRemediationExecutionStatus":{"input_token":"NextToken","limit_key":"Limit","output_token":"NextToken","result_key":"RemediationExecutionStatuses"},"GetResourceConfigHistory":{"input_token":"nextToken","limit_key":"limit","output_token":"nextToken","result_key":"configurationItems"},"SelectAggregateResourceConfig":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken"}}}; + this.abort = abort + this.context = context + } -/***/ }), + onHeaders (statusCode, rawHeaders, resume, statusMessage) { + const { callback, opaque, abort, context, responseHeaders, highWaterMark } = this -/***/ 4227: -/***/ (function(module, __unusedexports, __webpack_require__) { + const headers = responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders) -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; + if (statusCode < 200) { + if (this.onInfo) { + this.onInfo({ statusCode, headers }) + } + return + } -apiLoader.services['cloudwatchlogs'] = {}; -AWS.CloudWatchLogs = Service.defineService('cloudwatchlogs', ['2014-03-28']); -Object.defineProperty(apiLoader.services['cloudwatchlogs'], '2014-03-28', { - get: function get() { - var model = __webpack_require__(7684); - model.paginators = __webpack_require__(6288).pagination; - return model; - }, - enumerable: true, - configurable: true -}); + const parsedHeaders = responseHeaders === 'raw' ? util.parseHeaders(rawHeaders) : headers + const contentType = parsedHeaders['content-type'] + const contentLength = parsedHeaders['content-length'] + const res = new Readable({ + resume, + abort, + contentType, + contentLength: this.method !== 'HEAD' && contentLength + ? Number(contentLength) + : null, + highWaterMark + }) -module.exports = AWS.CloudWatchLogs; + if (this.removeAbortListener) { + res.on('close', this.removeAbortListener) + } + this.callback = null + this.res = res + if (callback !== null) { + if (this.throwOnError && statusCode >= 400) { + this.runInAsyncScope(getResolveErrorBodyCallback, null, + { callback, body: res, contentType, statusCode, statusMessage, headers } + ) + } else { + this.runInAsyncScope(callback, null, null, { + statusCode, + headers, + trailers: this.trailers, + opaque, + body: res, + context + }) + } + } + } -/***/ }), + onData (chunk) { + return this.res.push(chunk) + } -/***/ 4237: -/***/ (function(module) { + onComplete (trailers) { + util.parseHeaders(trailers, this.trailers) + this.res.push(null) + } -module.exports = {"version":"2.0","metadata":{"apiVersion":"2013-02-12","endpointPrefix":"rds","protocol":"query","serviceAbbreviation":"Amazon RDS","serviceFullName":"Amazon Relational Database Service","serviceId":"RDS","signatureVersion":"v4","uid":"rds-2013-02-12","xmlNamespace":"http://rds.amazonaws.com/doc/2013-02-12/"},"operations":{"AddSourceIdentifierToSubscription":{"input":{"type":"structure","required":["SubscriptionName","SourceIdentifier"],"members":{"SubscriptionName":{},"SourceIdentifier":{}}},"output":{"resultWrapper":"AddSourceIdentifierToSubscriptionResult","type":"structure","members":{"EventSubscription":{"shape":"S4"}}}},"AddTagsToResource":{"input":{"type":"structure","required":["ResourceName","Tags"],"members":{"ResourceName":{},"Tags":{"shape":"S9"}}}},"AuthorizeDBSecurityGroupIngress":{"input":{"type":"structure","required":["DBSecurityGroupName"],"members":{"DBSecurityGroupName":{},"CIDRIP":{},"EC2SecurityGroupName":{},"EC2SecurityGroupId":{},"EC2SecurityGroupOwnerId":{}}},"output":{"resultWrapper":"AuthorizeDBSecurityGroupIngressResult","type":"structure","members":{"DBSecurityGroup":{"shape":"Sd"}}}},"CopyDBSnapshot":{"input":{"type":"structure","required":["SourceDBSnapshotIdentifier","TargetDBSnapshotIdentifier"],"members":{"SourceDBSnapshotIdentifier":{},"TargetDBSnapshotIdentifier":{}}},"output":{"resultWrapper":"CopyDBSnapshotResult","type":"structure","members":{"DBSnapshot":{"shape":"Sk"}}}},"CreateDBInstance":{"input":{"type":"structure","required":["DBInstanceIdentifier","AllocatedStorage","DBInstanceClass","Engine","MasterUsername","MasterUserPassword"],"members":{"DBName":{},"DBInstanceIdentifier":{},"AllocatedStorage":{"type":"integer"},"DBInstanceClass":{},"Engine":{},"MasterUsername":{},"MasterUserPassword":{},"DBSecurityGroups":{"shape":"Sp"},"VpcSecurityGroupIds":{"shape":"Sq"},"AvailabilityZone":{},"DBSubnetGroupName":{},"PreferredMaintenanceWindow":{},"DBParameterGroupName":{},"BackupRetentionPeriod":{"type":"integer"},"PreferredBackupWindow":{},"Port":{"type":"integer"},"MultiAZ":{"type":"boolean"},"EngineVersion":{},"AutoMinorVersionUpgrade":{"type":"boolean"},"LicenseModel":{},"Iops":{"type":"integer"},"OptionGroupName":{},"CharacterSetName":{},"PubliclyAccessible":{"type":"boolean"}}},"output":{"resultWrapper":"CreateDBInstanceResult","type":"structure","members":{"DBInstance":{"shape":"St"}}}},"CreateDBInstanceReadReplica":{"input":{"type":"structure","required":["DBInstanceIdentifier","SourceDBInstanceIdentifier"],"members":{"DBInstanceIdentifier":{},"SourceDBInstanceIdentifier":{},"DBInstanceClass":{},"AvailabilityZone":{},"Port":{"type":"integer"},"AutoMinorVersionUpgrade":{"type":"boolean"},"Iops":{"type":"integer"},"OptionGroupName":{},"PubliclyAccessible":{"type":"boolean"}}},"output":{"resultWrapper":"CreateDBInstanceReadReplicaResult","type":"structure","members":{"DBInstance":{"shape":"St"}}}},"CreateDBParameterGroup":{"input":{"type":"structure","required":["DBParameterGroupName","DBParameterGroupFamily","Description"],"members":{"DBParameterGroupName":{},"DBParameterGroupFamily":{},"Description":{}}},"output":{"resultWrapper":"CreateDBParameterGroupResult","type":"structure","members":{"DBParameterGroup":{"shape":"S1d"}}}},"CreateDBSecurityGroup":{"input":{"type":"structure","required":["DBSecurityGroupName","DBSecurityGroupDescription"],"members":{"DBSecurityGroupName":{},"DBSecurityGroupDescription":{}}},"output":{"resultWrapper":"CreateDBSecurityGroupResult","type":"structure","members":{"DBSecurityGroup":{"shape":"Sd"}}}},"CreateDBSnapshot":{"input":{"type":"structure","required":["DBSnapshotIdentifier","DBInstanceIdentifier"],"members":{"DBSnapshotIdentifier":{},"DBInstanceIdentifier":{}}},"output":{"resultWrapper":"CreateDBSnapshotResult","type":"structure","members":{"DBSnapshot":{"shape":"Sk"}}}},"CreateDBSubnetGroup":{"input":{"type":"structure","required":["DBSubnetGroupName","DBSubnetGroupDescription","SubnetIds"],"members":{"DBSubnetGroupName":{},"DBSubnetGroupDescription":{},"SubnetIds":{"shape":"S1j"}}},"output":{"resultWrapper":"CreateDBSubnetGroupResult","type":"structure","members":{"DBSubnetGroup":{"shape":"S11"}}}},"CreateEventSubscription":{"input":{"type":"structure","required":["SubscriptionName","SnsTopicArn"],"members":{"SubscriptionName":{},"SnsTopicArn":{},"SourceType":{},"EventCategories":{"shape":"S6"},"SourceIds":{"shape":"S5"},"Enabled":{"type":"boolean"}}},"output":{"resultWrapper":"CreateEventSubscriptionResult","type":"structure","members":{"EventSubscription":{"shape":"S4"}}}},"CreateOptionGroup":{"input":{"type":"structure","required":["OptionGroupName","EngineName","MajorEngineVersion","OptionGroupDescription"],"members":{"OptionGroupName":{},"EngineName":{},"MajorEngineVersion":{},"OptionGroupDescription":{}}},"output":{"resultWrapper":"CreateOptionGroupResult","type":"structure","members":{"OptionGroup":{"shape":"S1p"}}}},"DeleteDBInstance":{"input":{"type":"structure","required":["DBInstanceIdentifier"],"members":{"DBInstanceIdentifier":{},"SkipFinalSnapshot":{"type":"boolean"},"FinalDBSnapshotIdentifier":{}}},"output":{"resultWrapper":"DeleteDBInstanceResult","type":"structure","members":{"DBInstance":{"shape":"St"}}}},"DeleteDBParameterGroup":{"input":{"type":"structure","required":["DBParameterGroupName"],"members":{"DBParameterGroupName":{}}}},"DeleteDBSecurityGroup":{"input":{"type":"structure","required":["DBSecurityGroupName"],"members":{"DBSecurityGroupName":{}}}},"DeleteDBSnapshot":{"input":{"type":"structure","required":["DBSnapshotIdentifier"],"members":{"DBSnapshotIdentifier":{}}},"output":{"resultWrapper":"DeleteDBSnapshotResult","type":"structure","members":{"DBSnapshot":{"shape":"Sk"}}}},"DeleteDBSubnetGroup":{"input":{"type":"structure","required":["DBSubnetGroupName"],"members":{"DBSubnetGroupName":{}}}},"DeleteEventSubscription":{"input":{"type":"structure","required":["SubscriptionName"],"members":{"SubscriptionName":{}}},"output":{"resultWrapper":"DeleteEventSubscriptionResult","type":"structure","members":{"EventSubscription":{"shape":"S4"}}}},"DeleteOptionGroup":{"input":{"type":"structure","required":["OptionGroupName"],"members":{"OptionGroupName":{}}}},"DescribeDBEngineVersions":{"input":{"type":"structure","members":{"Engine":{},"EngineVersion":{},"DBParameterGroupFamily":{},"MaxRecords":{"type":"integer"},"Marker":{},"DefaultOnly":{"type":"boolean"},"ListSupportedCharacterSets":{"type":"boolean"}}},"output":{"resultWrapper":"DescribeDBEngineVersionsResult","type":"structure","members":{"Marker":{},"DBEngineVersions":{"type":"list","member":{"locationName":"DBEngineVersion","type":"structure","members":{"Engine":{},"EngineVersion":{},"DBParameterGroupFamily":{},"DBEngineDescription":{},"DBEngineVersionDescription":{},"DefaultCharacterSet":{"shape":"S28"},"SupportedCharacterSets":{"type":"list","member":{"shape":"S28","locationName":"CharacterSet"}}}}}}}},"DescribeDBInstances":{"input":{"type":"structure","members":{"DBInstanceIdentifier":{},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeDBInstancesResult","type":"structure","members":{"Marker":{},"DBInstances":{"type":"list","member":{"shape":"St","locationName":"DBInstance"}}}}},"DescribeDBLogFiles":{"input":{"type":"structure","required":["DBInstanceIdentifier"],"members":{"DBInstanceIdentifier":{},"FilenameContains":{},"FileLastWritten":{"type":"long"},"FileSize":{"type":"long"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeDBLogFilesResult","type":"structure","members":{"DescribeDBLogFiles":{"type":"list","member":{"locationName":"DescribeDBLogFilesDetails","type":"structure","members":{"LogFileName":{},"LastWritten":{"type":"long"},"Size":{"type":"long"}}}},"Marker":{}}}},"DescribeDBParameterGroups":{"input":{"type":"structure","members":{"DBParameterGroupName":{},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeDBParameterGroupsResult","type":"structure","members":{"Marker":{},"DBParameterGroups":{"type":"list","member":{"shape":"S1d","locationName":"DBParameterGroup"}}}}},"DescribeDBParameters":{"input":{"type":"structure","required":["DBParameterGroupName"],"members":{"DBParameterGroupName":{},"Source":{},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeDBParametersResult","type":"structure","members":{"Parameters":{"shape":"S2n"},"Marker":{}}}},"DescribeDBSecurityGroups":{"input":{"type":"structure","members":{"DBSecurityGroupName":{},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeDBSecurityGroupsResult","type":"structure","members":{"Marker":{},"DBSecurityGroups":{"type":"list","member":{"shape":"Sd","locationName":"DBSecurityGroup"}}}}},"DescribeDBSnapshots":{"input":{"type":"structure","members":{"DBInstanceIdentifier":{},"DBSnapshotIdentifier":{},"SnapshotType":{},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeDBSnapshotsResult","type":"structure","members":{"Marker":{},"DBSnapshots":{"type":"list","member":{"shape":"Sk","locationName":"DBSnapshot"}}}}},"DescribeDBSubnetGroups":{"input":{"type":"structure","members":{"DBSubnetGroupName":{},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeDBSubnetGroupsResult","type":"structure","members":{"Marker":{},"DBSubnetGroups":{"type":"list","member":{"shape":"S11","locationName":"DBSubnetGroup"}}}}},"DescribeEngineDefaultParameters":{"input":{"type":"structure","required":["DBParameterGroupFamily"],"members":{"DBParameterGroupFamily":{},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeEngineDefaultParametersResult","type":"structure","members":{"EngineDefaults":{"type":"structure","members":{"DBParameterGroupFamily":{},"Marker":{},"Parameters":{"shape":"S2n"}},"wrapper":true}}}},"DescribeEventCategories":{"input":{"type":"structure","members":{"SourceType":{}}},"output":{"resultWrapper":"DescribeEventCategoriesResult","type":"structure","members":{"EventCategoriesMapList":{"type":"list","member":{"locationName":"EventCategoriesMap","type":"structure","members":{"SourceType":{},"EventCategories":{"shape":"S6"}},"wrapper":true}}}}},"DescribeEventSubscriptions":{"input":{"type":"structure","members":{"SubscriptionName":{},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeEventSubscriptionsResult","type":"structure","members":{"Marker":{},"EventSubscriptionsList":{"type":"list","member":{"shape":"S4","locationName":"EventSubscription"}}}}},"DescribeEvents":{"input":{"type":"structure","members":{"SourceIdentifier":{},"SourceType":{},"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"Duration":{"type":"integer"},"EventCategories":{"shape":"S6"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeEventsResult","type":"structure","members":{"Marker":{},"Events":{"type":"list","member":{"locationName":"Event","type":"structure","members":{"SourceIdentifier":{},"SourceType":{},"Message":{},"EventCategories":{"shape":"S6"},"Date":{"type":"timestamp"}}}}}}},"DescribeOptionGroupOptions":{"input":{"type":"structure","required":["EngineName"],"members":{"EngineName":{},"MajorEngineVersion":{},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeOptionGroupOptionsResult","type":"structure","members":{"OptionGroupOptions":{"type":"list","member":{"locationName":"OptionGroupOption","type":"structure","members":{"Name":{},"Description":{},"EngineName":{},"MajorEngineVersion":{},"MinimumRequiredMinorEngineVersion":{},"PortRequired":{"type":"boolean"},"DefaultPort":{"type":"integer"},"OptionsDependedOn":{"type":"list","member":{"locationName":"OptionName"}},"Persistent":{"type":"boolean"},"OptionGroupOptionSettings":{"type":"list","member":{"locationName":"OptionGroupOptionSetting","type":"structure","members":{"SettingName":{},"SettingDescription":{},"DefaultValue":{},"ApplyType":{},"AllowedValues":{},"IsModifiable":{"type":"boolean"}}}}}}},"Marker":{}}}},"DescribeOptionGroups":{"input":{"type":"structure","members":{"OptionGroupName":{},"Marker":{},"MaxRecords":{"type":"integer"},"EngineName":{},"MajorEngineVersion":{}}},"output":{"resultWrapper":"DescribeOptionGroupsResult","type":"structure","members":{"OptionGroupsList":{"type":"list","member":{"shape":"S1p","locationName":"OptionGroup"}},"Marker":{}}}},"DescribeOrderableDBInstanceOptions":{"input":{"type":"structure","required":["Engine"],"members":{"Engine":{},"EngineVersion":{},"DBInstanceClass":{},"LicenseModel":{},"Vpc":{"type":"boolean"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeOrderableDBInstanceOptionsResult","type":"structure","members":{"OrderableDBInstanceOptions":{"type":"list","member":{"locationName":"OrderableDBInstanceOption","type":"structure","members":{"Engine":{},"EngineVersion":{},"DBInstanceClass":{},"LicenseModel":{},"AvailabilityZones":{"type":"list","member":{"shape":"S14","locationName":"AvailabilityZone"}},"MultiAZCapable":{"type":"boolean"},"ReadReplicaCapable":{"type":"boolean"},"Vpc":{"type":"boolean"}},"wrapper":true}},"Marker":{}}}},"DescribeReservedDBInstances":{"input":{"type":"structure","members":{"ReservedDBInstanceId":{},"ReservedDBInstancesOfferingId":{},"DBInstanceClass":{},"Duration":{},"ProductDescription":{},"OfferingType":{},"MultiAZ":{"type":"boolean"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeReservedDBInstancesResult","type":"structure","members":{"Marker":{},"ReservedDBInstances":{"type":"list","member":{"shape":"S3w","locationName":"ReservedDBInstance"}}}}},"DescribeReservedDBInstancesOfferings":{"input":{"type":"structure","members":{"ReservedDBInstancesOfferingId":{},"DBInstanceClass":{},"Duration":{},"ProductDescription":{},"OfferingType":{},"MultiAZ":{"type":"boolean"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeReservedDBInstancesOfferingsResult","type":"structure","members":{"Marker":{},"ReservedDBInstancesOfferings":{"type":"list","member":{"locationName":"ReservedDBInstancesOffering","type":"structure","members":{"ReservedDBInstancesOfferingId":{},"DBInstanceClass":{},"Duration":{"type":"integer"},"FixedPrice":{"type":"double"},"UsagePrice":{"type":"double"},"CurrencyCode":{},"ProductDescription":{},"OfferingType":{},"MultiAZ":{"type":"boolean"},"RecurringCharges":{"shape":"S3y"}},"wrapper":true}}}}},"DownloadDBLogFilePortion":{"input":{"type":"structure","required":["DBInstanceIdentifier","LogFileName"],"members":{"DBInstanceIdentifier":{},"LogFileName":{},"Marker":{},"NumberOfLines":{"type":"integer"}}},"output":{"resultWrapper":"DownloadDBLogFilePortionResult","type":"structure","members":{"LogFileData":{},"Marker":{},"AdditionalDataPending":{"type":"boolean"}}}},"ListTagsForResource":{"input":{"type":"structure","required":["ResourceName"],"members":{"ResourceName":{}}},"output":{"resultWrapper":"ListTagsForResourceResult","type":"structure","members":{"TagList":{"shape":"S9"}}}},"ModifyDBInstance":{"input":{"type":"structure","required":["DBInstanceIdentifier"],"members":{"DBInstanceIdentifier":{},"AllocatedStorage":{"type":"integer"},"DBInstanceClass":{},"DBSecurityGroups":{"shape":"Sp"},"VpcSecurityGroupIds":{"shape":"Sq"},"ApplyImmediately":{"type":"boolean"},"MasterUserPassword":{},"DBParameterGroupName":{},"BackupRetentionPeriod":{"type":"integer"},"PreferredBackupWindow":{},"PreferredMaintenanceWindow":{},"MultiAZ":{"type":"boolean"},"EngineVersion":{},"AllowMajorVersionUpgrade":{"type":"boolean"},"AutoMinorVersionUpgrade":{"type":"boolean"},"Iops":{"type":"integer"},"OptionGroupName":{},"NewDBInstanceIdentifier":{}}},"output":{"resultWrapper":"ModifyDBInstanceResult","type":"structure","members":{"DBInstance":{"shape":"St"}}}},"ModifyDBParameterGroup":{"input":{"type":"structure","required":["DBParameterGroupName","Parameters"],"members":{"DBParameterGroupName":{},"Parameters":{"shape":"S2n"}}},"output":{"shape":"S4b","resultWrapper":"ModifyDBParameterGroupResult"}},"ModifyDBSubnetGroup":{"input":{"type":"structure","required":["DBSubnetGroupName","SubnetIds"],"members":{"DBSubnetGroupName":{},"DBSubnetGroupDescription":{},"SubnetIds":{"shape":"S1j"}}},"output":{"resultWrapper":"ModifyDBSubnetGroupResult","type":"structure","members":{"DBSubnetGroup":{"shape":"S11"}}}},"ModifyEventSubscription":{"input":{"type":"structure","required":["SubscriptionName"],"members":{"SubscriptionName":{},"SnsTopicArn":{},"SourceType":{},"EventCategories":{"shape":"S6"},"Enabled":{"type":"boolean"}}},"output":{"resultWrapper":"ModifyEventSubscriptionResult","type":"structure","members":{"EventSubscription":{"shape":"S4"}}}},"ModifyOptionGroup":{"input":{"type":"structure","required":["OptionGroupName"],"members":{"OptionGroupName":{},"OptionsToInclude":{"type":"list","member":{"locationName":"OptionConfiguration","type":"structure","required":["OptionName"],"members":{"OptionName":{},"Port":{"type":"integer"},"DBSecurityGroupMemberships":{"shape":"Sp"},"VpcSecurityGroupMemberships":{"shape":"Sq"},"OptionSettings":{"type":"list","member":{"shape":"S1t","locationName":"OptionSetting"}}}}},"OptionsToRemove":{"type":"list","member":{}},"ApplyImmediately":{"type":"boolean"}}},"output":{"resultWrapper":"ModifyOptionGroupResult","type":"structure","members":{"OptionGroup":{"shape":"S1p"}}}},"PromoteReadReplica":{"input":{"type":"structure","required":["DBInstanceIdentifier"],"members":{"DBInstanceIdentifier":{},"BackupRetentionPeriod":{"type":"integer"},"PreferredBackupWindow":{}}},"output":{"resultWrapper":"PromoteReadReplicaResult","type":"structure","members":{"DBInstance":{"shape":"St"}}}},"PurchaseReservedDBInstancesOffering":{"input":{"type":"structure","required":["ReservedDBInstancesOfferingId"],"members":{"ReservedDBInstancesOfferingId":{},"ReservedDBInstanceId":{},"DBInstanceCount":{"type":"integer"}}},"output":{"resultWrapper":"PurchaseReservedDBInstancesOfferingResult","type":"structure","members":{"ReservedDBInstance":{"shape":"S3w"}}}},"RebootDBInstance":{"input":{"type":"structure","required":["DBInstanceIdentifier"],"members":{"DBInstanceIdentifier":{},"ForceFailover":{"type":"boolean"}}},"output":{"resultWrapper":"RebootDBInstanceResult","type":"structure","members":{"DBInstance":{"shape":"St"}}}},"RemoveSourceIdentifierFromSubscription":{"input":{"type":"structure","required":["SubscriptionName","SourceIdentifier"],"members":{"SubscriptionName":{},"SourceIdentifier":{}}},"output":{"resultWrapper":"RemoveSourceIdentifierFromSubscriptionResult","type":"structure","members":{"EventSubscription":{"shape":"S4"}}}},"RemoveTagsFromResource":{"input":{"type":"structure","required":["ResourceName","TagKeys"],"members":{"ResourceName":{},"TagKeys":{"type":"list","member":{}}}}},"ResetDBParameterGroup":{"input":{"type":"structure","required":["DBParameterGroupName"],"members":{"DBParameterGroupName":{},"ResetAllParameters":{"type":"boolean"},"Parameters":{"shape":"S2n"}}},"output":{"shape":"S4b","resultWrapper":"ResetDBParameterGroupResult"}},"RestoreDBInstanceFromDBSnapshot":{"input":{"type":"structure","required":["DBInstanceIdentifier","DBSnapshotIdentifier"],"members":{"DBInstanceIdentifier":{},"DBSnapshotIdentifier":{},"DBInstanceClass":{},"Port":{"type":"integer"},"AvailabilityZone":{},"DBSubnetGroupName":{},"MultiAZ":{"type":"boolean"},"PubliclyAccessible":{"type":"boolean"},"AutoMinorVersionUpgrade":{"type":"boolean"},"LicenseModel":{},"DBName":{},"Engine":{},"Iops":{"type":"integer"},"OptionGroupName":{}}},"output":{"resultWrapper":"RestoreDBInstanceFromDBSnapshotResult","type":"structure","members":{"DBInstance":{"shape":"St"}}}},"RestoreDBInstanceToPointInTime":{"input":{"type":"structure","required":["SourceDBInstanceIdentifier","TargetDBInstanceIdentifier"],"members":{"SourceDBInstanceIdentifier":{},"TargetDBInstanceIdentifier":{},"RestoreTime":{"type":"timestamp"},"UseLatestRestorableTime":{"type":"boolean"},"DBInstanceClass":{},"Port":{"type":"integer"},"AvailabilityZone":{},"DBSubnetGroupName":{},"MultiAZ":{"type":"boolean"},"PubliclyAccessible":{"type":"boolean"},"AutoMinorVersionUpgrade":{"type":"boolean"},"LicenseModel":{},"DBName":{},"Engine":{},"Iops":{"type":"integer"},"OptionGroupName":{}}},"output":{"resultWrapper":"RestoreDBInstanceToPointInTimeResult","type":"structure","members":{"DBInstance":{"shape":"St"}}}},"RevokeDBSecurityGroupIngress":{"input":{"type":"structure","required":["DBSecurityGroupName"],"members":{"DBSecurityGroupName":{},"CIDRIP":{},"EC2SecurityGroupName":{},"EC2SecurityGroupId":{},"EC2SecurityGroupOwnerId":{}}},"output":{"resultWrapper":"RevokeDBSecurityGroupIngressResult","type":"structure","members":{"DBSecurityGroup":{"shape":"Sd"}}}}},"shapes":{"S4":{"type":"structure","members":{"CustomerAwsId":{},"CustSubscriptionId":{},"SnsTopicArn":{},"Status":{},"SubscriptionCreationTime":{},"SourceType":{},"SourceIdsList":{"shape":"S5"},"EventCategoriesList":{"shape":"S6"},"Enabled":{"type":"boolean"}},"wrapper":true},"S5":{"type":"list","member":{"locationName":"SourceId"}},"S6":{"type":"list","member":{"locationName":"EventCategory"}},"S9":{"type":"list","member":{"locationName":"Tag","type":"structure","members":{"Key":{},"Value":{}}}},"Sd":{"type":"structure","members":{"OwnerId":{},"DBSecurityGroupName":{},"DBSecurityGroupDescription":{},"VpcId":{},"EC2SecurityGroups":{"type":"list","member":{"locationName":"EC2SecurityGroup","type":"structure","members":{"Status":{},"EC2SecurityGroupName":{},"EC2SecurityGroupId":{},"EC2SecurityGroupOwnerId":{}}}},"IPRanges":{"type":"list","member":{"locationName":"IPRange","type":"structure","members":{"Status":{},"CIDRIP":{}}}}},"wrapper":true},"Sk":{"type":"structure","members":{"DBSnapshotIdentifier":{},"DBInstanceIdentifier":{},"SnapshotCreateTime":{"type":"timestamp"},"Engine":{},"AllocatedStorage":{"type":"integer"},"Status":{},"Port":{"type":"integer"},"AvailabilityZone":{},"VpcId":{},"InstanceCreateTime":{"type":"timestamp"},"MasterUsername":{},"EngineVersion":{},"LicenseModel":{},"SnapshotType":{},"Iops":{"type":"integer"},"OptionGroupName":{}},"wrapper":true},"Sp":{"type":"list","member":{"locationName":"DBSecurityGroupName"}},"Sq":{"type":"list","member":{"locationName":"VpcSecurityGroupId"}},"St":{"type":"structure","members":{"DBInstanceIdentifier":{},"DBInstanceClass":{},"Engine":{},"DBInstanceStatus":{},"MasterUsername":{},"DBName":{},"Endpoint":{"type":"structure","members":{"Address":{},"Port":{"type":"integer"}}},"AllocatedStorage":{"type":"integer"},"InstanceCreateTime":{"type":"timestamp"},"PreferredBackupWindow":{},"BackupRetentionPeriod":{"type":"integer"},"DBSecurityGroups":{"shape":"Sv"},"VpcSecurityGroups":{"shape":"Sx"},"DBParameterGroups":{"type":"list","member":{"locationName":"DBParameterGroup","type":"structure","members":{"DBParameterGroupName":{},"ParameterApplyStatus":{}}}},"AvailabilityZone":{},"DBSubnetGroup":{"shape":"S11"},"PreferredMaintenanceWindow":{},"PendingModifiedValues":{"type":"structure","members":{"DBInstanceClass":{},"AllocatedStorage":{"type":"integer"},"MasterUserPassword":{},"Port":{"type":"integer"},"BackupRetentionPeriod":{"type":"integer"},"MultiAZ":{"type":"boolean"},"EngineVersion":{},"Iops":{"type":"integer"},"DBInstanceIdentifier":{}}},"LatestRestorableTime":{"type":"timestamp"},"MultiAZ":{"type":"boolean"},"EngineVersion":{},"AutoMinorVersionUpgrade":{"type":"boolean"},"ReadReplicaSourceDBInstanceIdentifier":{},"ReadReplicaDBInstanceIdentifiers":{"type":"list","member":{"locationName":"ReadReplicaDBInstanceIdentifier"}},"LicenseModel":{},"Iops":{"type":"integer"},"OptionGroupMemberships":{"type":"list","member":{"locationName":"OptionGroupMembership","type":"structure","members":{"OptionGroupName":{},"Status":{}}}},"CharacterSetName":{},"SecondaryAvailabilityZone":{},"PubliclyAccessible":{"type":"boolean"}},"wrapper":true},"Sv":{"type":"list","member":{"locationName":"DBSecurityGroup","type":"structure","members":{"DBSecurityGroupName":{},"Status":{}}}},"Sx":{"type":"list","member":{"locationName":"VpcSecurityGroupMembership","type":"structure","members":{"VpcSecurityGroupId":{},"Status":{}}}},"S11":{"type":"structure","members":{"DBSubnetGroupName":{},"DBSubnetGroupDescription":{},"VpcId":{},"SubnetGroupStatus":{},"Subnets":{"type":"list","member":{"locationName":"Subnet","type":"structure","members":{"SubnetIdentifier":{},"SubnetAvailabilityZone":{"shape":"S14"},"SubnetStatus":{}}}}},"wrapper":true},"S14":{"type":"structure","members":{"Name":{},"ProvisionedIopsCapable":{"type":"boolean"}},"wrapper":true},"S1d":{"type":"structure","members":{"DBParameterGroupName":{},"DBParameterGroupFamily":{},"Description":{}},"wrapper":true},"S1j":{"type":"list","member":{"locationName":"SubnetIdentifier"}},"S1p":{"type":"structure","members":{"OptionGroupName":{},"OptionGroupDescription":{},"EngineName":{},"MajorEngineVersion":{},"Options":{"type":"list","member":{"locationName":"Option","type":"structure","members":{"OptionName":{},"OptionDescription":{},"Persistent":{"type":"boolean"},"Port":{"type":"integer"},"OptionSettings":{"type":"list","member":{"shape":"S1t","locationName":"OptionSetting"}},"DBSecurityGroupMemberships":{"shape":"Sv"},"VpcSecurityGroupMemberships":{"shape":"Sx"}}}},"AllowsVpcAndNonVpcInstanceMemberships":{"type":"boolean"},"VpcId":{}},"wrapper":true},"S1t":{"type":"structure","members":{"Name":{},"Value":{},"DefaultValue":{},"Description":{},"ApplyType":{},"DataType":{},"AllowedValues":{},"IsModifiable":{"type":"boolean"},"IsCollection":{"type":"boolean"}}},"S28":{"type":"structure","members":{"CharacterSetName":{},"CharacterSetDescription":{}}},"S2n":{"type":"list","member":{"locationName":"Parameter","type":"structure","members":{"ParameterName":{},"ParameterValue":{},"Description":{},"Source":{},"ApplyType":{},"DataType":{},"AllowedValues":{},"IsModifiable":{"type":"boolean"},"MinimumEngineVersion":{},"ApplyMethod":{}}}},"S3w":{"type":"structure","members":{"ReservedDBInstanceId":{},"ReservedDBInstancesOfferingId":{},"DBInstanceClass":{},"StartTime":{"type":"timestamp"},"Duration":{"type":"integer"},"FixedPrice":{"type":"double"},"UsagePrice":{"type":"double"},"CurrencyCode":{},"DBInstanceCount":{"type":"integer"},"ProductDescription":{},"OfferingType":{},"MultiAZ":{"type":"boolean"},"State":{},"RecurringCharges":{"shape":"S3y"}},"wrapper":true},"S3y":{"type":"list","member":{"locationName":"RecurringCharge","type":"structure","members":{"RecurringChargeAmount":{"type":"double"},"RecurringChargeFrequency":{}},"wrapper":true}},"S4b":{"type":"structure","members":{"DBParameterGroupName":{}}}}}; + onError (err) { + const { res, callback, body, opaque } = this -/***/ }), + if (callback) { + // TODO: Does this need queueMicrotask? + this.callback = null + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }) + }) + } -/***/ 4238: -/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) { + if (res) { + this.res = null + // Ensure all queued handlers are invoked before destroying res. + queueMicrotask(() => { + util.destroy(res, err) + }) + } -var AWS = __webpack_require__(395); + if (body) { + this.body = null + util.destroy(body, err) + } -// pull in CloudFront signer -__webpack_require__(1647); + if (this.removeAbortListener) { + res?.off('close', this.removeAbortListener) + this.removeAbortListener() + this.removeAbortListener = null + } + } +} -AWS.util.update(AWS.CloudFront.prototype, { +function request (opts, callback) { + if (callback === undefined) { + return new Promise((resolve, reject) => { + request.call(this, opts, (err, data) => { + return err ? reject(err) : resolve(data) + }) + }) + } - setupRequestListeners: function setupRequestListeners(request) { - request.addListener('extractData', AWS.util.hoistPayloadMember); + try { + this.dispatch(opts, new RequestHandler(opts, callback)) + } catch (err) { + if (typeof callback !== 'function') { + throw err + } + const opaque = opts?.opaque + queueMicrotask(() => callback(err, { opaque })) } +} -}); +module.exports = request +module.exports.RequestHandler = RequestHandler /***/ }), -/***/ 4252: -/***/ (function(module) { +/***/ 3560: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = {"pagination":{}}; +"use strict"; -/***/ }), -/***/ 4253: -/***/ (function(__unusedmodule, exports, __webpack_require__) { +const assert = __nccwpck_require__(4589) +const { finished, PassThrough } = __nccwpck_require__(7075) +const { InvalidArgumentError, InvalidReturnValueError } = __nccwpck_require__(8707) +const util = __nccwpck_require__(3440) +const { getResolveErrorBodyCallback } = __nccwpck_require__(7655) +const { AsyncResource } = __nccwpck_require__(6698) +const { addSignal, removeSignal } = __nccwpck_require__(158) -"use strict"; +class StreamHandler extends AsyncResource { + constructor (opts, factory, callback) { + if (!opts || typeof opts !== 'object') { + throw new InvalidArgumentError('invalid opts') + } -var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { - if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); -}) : (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 (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); - __setModuleDefault(result, mod); - return result; -}; -var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { - function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } - return new (P || (P = Promise))(function (resolve, reject) { - function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } - function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } - function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } - step((generator = generator.apply(thisArg, _arguments || [])).next()); - }); -}; -Object.defineProperty(exports, "__esModule", { value: true }); -exports.getStackOutputs = exports.deployStack = exports.updateStack = exports.cleanupChangeSet = void 0; -const core = __importStar(__webpack_require__(6470)); -function cleanupChangeSet(cfn, stack, params, noEmptyChangeSet, noDeleteFailedChangeSet) { - return __awaiter(this, void 0, void 0, function* () { - const knownErrorMessages = [ - `No updates are to be performed`, - `The submitted information didn't contain changes` - ]; - const changeSetStatus = yield cfn - .describeChangeSet({ - ChangeSetName: params.ChangeSetName, - StackName: params.StackName - }) - .promise(); - if (changeSetStatus.Status === 'FAILED') { - core.debug('Deleting failed Change Set'); - if (!noDeleteFailedChangeSet) { - yield cfn - .deleteChangeSet({ - ChangeSetName: params.ChangeSetName, - StackName: params.StackName - }) - .promise(); - } - if (noEmptyChangeSet && - knownErrorMessages.some(err => { var _a; return (_a = changeSetStatus.StatusReason) === null || _a === void 0 ? void 0 : _a.includes(err); })) { - return stack.StackId; - } - throw new Error(`Failed to create Change Set: ${changeSetStatus.StatusReason}`); - } - }); -} -exports.cleanupChangeSet = cleanupChangeSet; -function updateStack(cfn, stack, params, noEmptyChangeSet, noExecuteChageSet, noDeleteFailedChangeSet) { - return __awaiter(this, void 0, void 0, function* () { - core.debug('Creating CloudFormation Change Set'); - yield cfn.createChangeSet(params).promise(); - try { - core.debug('Waiting for CloudFormation Change Set creation'); - yield cfn - .waitFor('changeSetCreateComplete', { - ChangeSetName: params.ChangeSetName, - StackName: params.StackName - }) - .promise(); - } - catch (_) { - return cleanupChangeSet(cfn, stack, params, noEmptyChangeSet, noDeleteFailedChangeSet); - } - if (noExecuteChageSet) { - core.debug('Not executing the change set'); - return stack.StackId; - } - core.debug('Executing CloudFormation change set'); - yield cfn - .executeChangeSet({ - ChangeSetName: params.ChangeSetName, - StackName: params.StackName - }) - .promise(); - core.debug('Updating CloudFormation stack'); - yield cfn - .waitFor('stackUpdateComplete', { StackName: stack.StackId }) - .promise(); - return stack.StackId; - }); -} -exports.updateStack = updateStack; -function getStack(cfn, stackNameOrId) { - var _a; - return __awaiter(this, void 0, void 0, function* () { - try { - const stacks = yield cfn - .describeStacks({ - StackName: stackNameOrId - }) - .promise(); - return (_a = stacks.Stacks) === null || _a === void 0 ? void 0 : _a[0]; - } - catch (e) { - if (e.code === 'ValidationError' && e.message.match(/does not exist/)) { - return undefined; - } - throw e; - } - }); -} -function deployStack(cfn, params, noEmptyChangeSet, noExecuteChageSet, noDeleteFailedChangeSet, changesetPostfix) { - return __awaiter(this, void 0, void 0, function* () { - const stack = yield getStack(cfn, params.StackName); - if (!stack) { - core.debug(`Creating CloudFormation Stack`); - const stack = yield cfn.createStack(params).promise(); - yield cfn - .waitFor('stackCreateComplete', { StackName: params.StackName }) - .promise(); - return stack.StackId; - } - core.debug(`Creating stack with postfix ${changesetPostfix}`); - return yield updateStack(cfn, stack, Object.assign({ ChangeSetName: `${params.StackName}${changesetPostfix || '-CS'}` }, { - StackName: params.StackName, - TemplateBody: params.TemplateBody, - TemplateURL: params.TemplateURL, - Parameters: params.Parameters, - Capabilities: params.Capabilities, - ResourceTypes: params.ResourceTypes, - RoleARN: params.RoleARN, - RollbackConfiguration: params.RollbackConfiguration, - NotificationARNs: params.NotificationARNs, - Tags: params.Tags - }), noEmptyChangeSet, noExecuteChageSet, noDeleteFailedChangeSet); - }); -} -exports.deployStack = deployStack; -function getStackOutputs(cfn, stackId) { - return __awaiter(this, void 0, void 0, function* () { - const outputs = new Map(); - const stack = yield getStack(cfn, stackId); - if (stack && stack.Outputs) { - for (const output of stack.Outputs) { - if (output.OutputKey && output.OutputValue) { - outputs.set(output.OutputKey, output.OutputValue); - } - } - } - return outputs; - }); -} -exports.getStackOutputs = getStackOutputs; + const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError } = opts + try { + if (typeof callback !== 'function') { + throw new InvalidArgumentError('invalid callback') + } -/***/ }), - -/***/ 4258: -/***/ (function(module, __unusedexports, __webpack_require__) { + if (typeof factory !== 'function') { + throw new InvalidArgumentError('invalid factory') + } -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; + if (signal && typeof signal.on !== 'function' && typeof signal.addEventListener !== 'function') { + throw new InvalidArgumentError('signal must be an EventEmitter or EventTarget') + } -apiLoader.services['waf'] = {}; -AWS.WAF = Service.defineService('waf', ['2015-08-24']); -Object.defineProperty(apiLoader.services['waf'], '2015-08-24', { - get: function get() { - var model = __webpack_require__(5340); - model.paginators = __webpack_require__(9732).pagination; - return model; - }, - enumerable: true, - configurable: true -}); + if (method === 'CONNECT') { + throw new InvalidArgumentError('invalid method') + } -module.exports = AWS.WAF; + if (onInfo && typeof onInfo !== 'function') { + throw new InvalidArgumentError('invalid onInfo callback') + } + super('UNDICI_STREAM') + } catch (err) { + if (util.isStream(body)) { + util.destroy(body.on('error', util.nop), err) + } + throw err + } + + this.responseHeaders = responseHeaders || null + this.opaque = opaque || null + this.factory = factory + this.callback = callback + this.res = null + this.abort = null + this.context = null + this.trailers = null + this.body = body + this.onInfo = onInfo || null + this.throwOnError = throwOnError || false + + if (util.isStream(body)) { + body.on('error', (err) => { + this.onError(err) + }) + } -/***/ }), + addSignal(this, signal) + } -/***/ 4281: -/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) { + onConnect (abort, context) { + if (this.reason) { + abort(this.reason) + return + } -var AWS = __webpack_require__(395); -var rest = AWS.Protocol.Rest; + assert(this.callback) -/** - * A presigner object can be used to generate presigned urls for the Polly service. - */ -AWS.Polly.Presigner = AWS.util.inherit({ - /** - * Creates a presigner object with a set of configuration options. - * - * @option options params [map] An optional map of parameters to bind to every - * request sent by this service object. - * @option options service [AWS.Polly] An optional pre-configured instance - * of the AWS.Polly service object to use for requests. The object may - * bound parameters used by the presigner. - * @see AWS.Polly.constructor - */ - constructor: function Signer(options) { - options = options || {}; - this.options = options; - this.service = options.service; - this.bindServiceObject(options); - this._operations = {}; - }, + this.abort = abort + this.context = context + } - /** - * @api private - */ - bindServiceObject: function bindServiceObject(options) { - options = options || {}; - if (!this.service) { - this.service = new AWS.Polly(options); - } else { - var config = AWS.util.copy(this.service.config); - this.service = new this.service.constructor.__super__(config); - this.service.config.params = AWS.util.merge(this.service.config.params || {}, options.params); - } - }, + onHeaders (statusCode, rawHeaders, resume, statusMessage) { + const { factory, opaque, context, callback, responseHeaders } = this - /** - * @api private - */ - modifyInputMembers: function modifyInputMembers(input) { - // make copies of the input so we don't overwrite the api - // need to be careful to copy anything we access/modify - var modifiedInput = AWS.util.copy(input); - modifiedInput.members = AWS.util.copy(input.members); - AWS.util.each(input.members, function(name, member) { - modifiedInput.members[name] = AWS.util.copy(member); - // update location and locationName - if (!member.location || member.location === 'body') { - modifiedInput.members[name].location = 'querystring'; - modifiedInput.members[name].locationName = name; - } - }); - return modifiedInput; - }, + const headers = responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders) - /** - * @api private - */ - convertPostToGet: function convertPostToGet(req) { - // convert method - req.httpRequest.method = 'GET'; + if (statusCode < 200) { + if (this.onInfo) { + this.onInfo({ statusCode, headers }) + } + return + } - var operation = req.service.api.operations[req.operation]; - // get cached operation input first - var input = this._operations[req.operation]; - if (!input) { - // modify the original input - this._operations[req.operation] = input = this.modifyInputMembers(operation.input); - } + this.factory = null - var uri = rest.generateURI(req.httpRequest.endpoint.path, operation.httpPath, input, req.params); + let res - req.httpRequest.path = uri; - req.httpRequest.body = ''; + if (this.throwOnError && statusCode >= 400) { + const parsedHeaders = responseHeaders === 'raw' ? util.parseHeaders(rawHeaders) : headers + const contentType = parsedHeaders['content-type'] + res = new PassThrough() - // don't need these headers on a GET request - delete req.httpRequest.headers['Content-Length']; - delete req.httpRequest.headers['Content-Type']; - }, + this.callback = null + this.runInAsyncScope(getResolveErrorBodyCallback, null, + { callback, body: res, contentType, statusCode, statusMessage, headers } + ) + } else { + if (factory === null) { + return + } - /** - * @overload getSynthesizeSpeechUrl(params = {}, [expires = 3600], [callback]) - * Generate a presigned url for {AWS.Polly.synthesizeSpeech}. - * @note You must ensure that you have static or previously resolved - * credentials if you call this method synchronously (with no callback), - * otherwise it may not properly sign the request. If you cannot guarantee - * this (you are using an asynchronous credential provider, i.e., EC2 - * IAM roles), you should always call this method with an asynchronous - * callback. - * @param params [map] parameters to pass to the operation. See the {AWS.Polly.synthesizeSpeech} - * operation for the expected operation parameters. - * @param expires [Integer] (3600) the number of seconds to expire the pre-signed URL operation in. - * Defaults to 1 hour. - * @return [string] if called synchronously (with no callback), returns the signed URL. - * @return [null] nothing is returned if a callback is provided. - * @callback callback function (err, url) - * If a callback is supplied, it is called when a signed URL has been generated. - * @param err [Error] the error object returned from the presigner. - * @param url [String] the signed URL. - * @see AWS.Polly.synthesizeSpeech - */ - getSynthesizeSpeechUrl: function getSynthesizeSpeechUrl(params, expires, callback) { - var self = this; - var request = this.service.makeRequest('synthesizeSpeech', params); - // remove existing build listeners - request.removeAllListeners('build'); - request.on('build', function(req) { - self.convertPostToGet(req); - }); - return request.presign(expires, callback); - } -}); + res = this.runInAsyncScope(factory, null, { + statusCode, + headers, + opaque, + context + }) + if ( + !res || + typeof res.write !== 'function' || + typeof res.end !== 'function' || + typeof res.on !== 'function' + ) { + throw new InvalidReturnValueError('expected Writable') + } -/***/ }), + // TODO: Avoid finished. It registers an unnecessary amount of listeners. + finished(res, { readable: false }, (err) => { + const { callback, res, opaque, trailers, abort } = this -/***/ 4289: -/***/ (function(module) { + this.res = null + if (err || !res.readable) { + util.destroy(res, err) + } -module.exports = {"version":"2.0","metadata":{"apiVersion":"2019-06-30","endpointPrefix":"migrationhub-config","jsonVersion":"1.1","protocol":"json","serviceFullName":"AWS Migration Hub Config","serviceId":"MigrationHub Config","signatureVersion":"v4","signingName":"mgh","targetPrefix":"AWSMigrationHubMultiAccountService","uid":"migrationhub-config-2019-06-30"},"operations":{"CreateHomeRegionControl":{"input":{"type":"structure","required":["HomeRegion","Target"],"members":{"HomeRegion":{},"Target":{"shape":"S3"},"DryRun":{"type":"boolean"}}},"output":{"type":"structure","members":{"HomeRegionControl":{"shape":"S8"}}}},"DescribeHomeRegionControls":{"input":{"type":"structure","members":{"ControlId":{},"HomeRegion":{},"Target":{"shape":"S3"},"MaxResults":{"type":"integer"},"NextToken":{}}},"output":{"type":"structure","members":{"HomeRegionControls":{"type":"list","member":{"shape":"S8"}},"NextToken":{}}}},"GetHomeRegion":{"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"HomeRegion":{}}}}},"shapes":{"S3":{"type":"structure","required":["Type"],"members":{"Type":{},"Id":{}}},"S8":{"type":"structure","members":{"ControlId":{},"HomeRegion":{},"Target":{"shape":"S3"},"RequestedTime":{"type":"timestamp"}}}}}; + this.callback = null + this.runInAsyncScope(callback, null, err || null, { opaque, trailers }) -/***/ }), + if (err) { + abort() + } + }) + } -/***/ 4290: -/***/ (function(module, __unusedexports, __webpack_require__) { + res.on('drain', resume) -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; + this.res = res -apiLoader.services['greengrass'] = {}; -AWS.Greengrass = Service.defineService('greengrass', ['2017-06-07']); -Object.defineProperty(apiLoader.services['greengrass'], '2017-06-07', { - get: function get() { - var model = __webpack_require__(2053); - return model; - }, - enumerable: true, - configurable: true -}); + const needDrain = res.writableNeedDrain !== undefined + ? res.writableNeedDrain + : res._writableState?.needDrain -module.exports = AWS.Greengrass; + return needDrain !== true + } + onData (chunk) { + const { res } = this -/***/ }), + return res ? res.write(chunk) : true + } -/***/ 4291: -/***/ (function(module, __unusedexports, __webpack_require__) { + onComplete (trailers) { + const { res } = this -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; + removeSignal(this) -apiLoader.services['ivs'] = {}; -AWS.IVS = Service.defineService('ivs', ['2020-07-14']); -Object.defineProperty(apiLoader.services['ivs'], '2020-07-14', { - get: function get() { - var model = __webpack_require__(5907); - model.paginators = __webpack_require__(9342).pagination; - return model; - }, - enumerable: true, - configurable: true -}); + if (!res) { + return + } -module.exports = AWS.IVS; + this.trailers = util.parseHeaders(trailers) + res.end() + } -/***/ }), + onError (err) { + const { res, callback, opaque, body } = this -/***/ 4293: -/***/ (function(module) { + removeSignal(this) -module.exports = require("buffer"); + this.factory = null -/***/ }), + if (res) { + this.res = null + util.destroy(res, err) + } else if (callback) { + this.callback = null + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }) + }) + } -/***/ 4303: -/***/ (function(module) { + if (body) { + this.body = null + util.destroy(body, err) + } + } +} -module.exports = {"version":2,"waiters":{"LoadBalancerExists":{"delay":15,"operation":"DescribeLoadBalancers","maxAttempts":40,"acceptors":[{"matcher":"status","expected":200,"state":"success"},{"matcher":"error","expected":"LoadBalancerNotFound","state":"retry"}]},"LoadBalancerAvailable":{"delay":15,"operation":"DescribeLoadBalancers","maxAttempts":40,"acceptors":[{"state":"success","matcher":"pathAll","argument":"LoadBalancers[].State.Code","expected":"active"},{"state":"retry","matcher":"pathAny","argument":"LoadBalancers[].State.Code","expected":"provisioning"},{"state":"retry","matcher":"error","expected":"LoadBalancerNotFound"}]},"LoadBalancersDeleted":{"delay":15,"operation":"DescribeLoadBalancers","maxAttempts":40,"acceptors":[{"state":"retry","matcher":"pathAll","argument":"LoadBalancers[].State.Code","expected":"active"},{"matcher":"error","expected":"LoadBalancerNotFound","state":"success"}]},"TargetInService":{"delay":15,"maxAttempts":40,"operation":"DescribeTargetHealth","acceptors":[{"argument":"TargetHealthDescriptions[].TargetHealth.State","expected":"healthy","matcher":"pathAll","state":"success"},{"matcher":"error","expected":"InvalidInstance","state":"retry"}]},"TargetDeregistered":{"delay":15,"maxAttempts":40,"operation":"DescribeTargetHealth","acceptors":[{"matcher":"error","expected":"InvalidTarget","state":"success"},{"argument":"TargetHealthDescriptions[].TargetHealth.State","expected":"unused","matcher":"pathAll","state":"success"}]}}}; +function stream (opts, factory, callback) { + if (callback === undefined) { + return new Promise((resolve, reject) => { + stream.call(this, opts, factory, (err, data) => { + return err ? reject(err) : resolve(data) + }) + }) + } -/***/ }), + try { + this.dispatch(opts, new StreamHandler(opts, factory, callback)) + } catch (err) { + if (typeof callback !== 'function') { + throw err + } + const opaque = opts?.opaque + queueMicrotask(() => callback(err, { opaque })) + } +} -/***/ 4304: -/***/ (function(module) { +module.exports = stream -module.exports = require("string_decoder"); /***/ }), -/***/ 4341: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +/***/ 1882: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -apiLoader.services['discovery'] = {}; -AWS.Discovery = Service.defineService('discovery', ['2015-11-01']); -Object.defineProperty(apiLoader.services['discovery'], '2015-11-01', { - get: function get() { - var model = __webpack_require__(9389); - model.paginators = __webpack_require__(5266).pagination; - return model; - }, - enumerable: true, - configurable: true -}); +"use strict"; -module.exports = AWS.Discovery; +const { InvalidArgumentError, SocketError } = __nccwpck_require__(8707) +const { AsyncResource } = __nccwpck_require__(6698) +const util = __nccwpck_require__(3440) +const { addSignal, removeSignal } = __nccwpck_require__(158) +const assert = __nccwpck_require__(4589) -/***/ }), +class UpgradeHandler extends AsyncResource { + constructor (opts, callback) { + if (!opts || typeof opts !== 'object') { + throw new InvalidArgumentError('invalid opts') + } -/***/ 4343: -/***/ (function(module, __unusedexports, __webpack_require__) { + if (typeof callback !== 'function') { + throw new InvalidArgumentError('invalid callback') + } -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; + const { signal, opaque, responseHeaders } = opts -apiLoader.services['inspector'] = {}; -AWS.Inspector = Service.defineService('inspector', ['2015-08-18*', '2016-02-16']); -Object.defineProperty(apiLoader.services['inspector'], '2016-02-16', { - get: function get() { - var model = __webpack_require__(612); - model.paginators = __webpack_require__(1283).pagination; - return model; - }, - enumerable: true, - configurable: true -}); + if (signal && typeof signal.on !== 'function' && typeof signal.addEventListener !== 'function') { + throw new InvalidArgumentError('signal must be an EventEmitter or EventTarget') + } -module.exports = AWS.Inspector; + super('UNDICI_UPGRADE') + this.responseHeaders = responseHeaders || null + this.opaque = opaque || null + this.callback = callback + this.abort = null + this.context = null -/***/ }), + addSignal(this, signal) + } -/***/ 4344: -/***/ (function(module) { + onConnect (abort, context) { + if (this.reason) { + abort(this.reason) + return + } -module.exports = {"pagination":{}}; + assert(this.callback) -/***/ }), + this.abort = abort + this.context = null + } -/***/ 4352: -/***/ (function(module, __unusedexports, __webpack_require__) { + onHeaders () { + throw new SocketError('bad upgrade', null) + } -"use strict"; + onUpgrade (statusCode, rawHeaders, socket) { + assert(statusCode === 101) + const { callback, opaque, context } = this -var esprima; + removeSignal(this) -// Browserified version does not have esprima -// -// 1. For node.js just require module as deps -// 2. For browser try to require mudule via external AMD system. -// If not found - try to fallback to window.esprima. If not -// found too - then fail to parse. -// -try { - // workaround to exclude package from browserify list. - var _require = require; - esprima = _require('esprima'); -} catch (_) { - /* eslint-disable no-redeclare */ - /* global window */ - if (typeof window !== 'undefined') esprima = window.esprima; -} + this.callback = null + const headers = this.responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders) + this.runInAsyncScope(callback, null, null, { + headers, + socket, + opaque, + context + }) + } -var Type = __webpack_require__(4945); + onError (err) { + const { callback, opaque } = this -function resolveJavascriptFunction(data) { - if (data === null) return false; + removeSignal(this) - try { - var source = '(' + data + ')', - ast = esprima.parse(source, { range: true }); - - if (ast.type !== 'Program' || - ast.body.length !== 1 || - ast.body[0].type !== 'ExpressionStatement' || - (ast.body[0].expression.type !== 'ArrowFunctionExpression' && - ast.body[0].expression.type !== 'FunctionExpression')) { - return false; + if (callback) { + this.callback = null + queueMicrotask(() => { + this.runInAsyncScope(callback, null, err, { opaque }) + }) } - - return true; - } catch (err) { - return false; } } -function constructJavascriptFunction(data) { - /*jslint evil:true*/ - - var source = '(' + data + ')', - ast = esprima.parse(source, { range: true }), - params = [], - body; - - if (ast.type !== 'Program' || - ast.body.length !== 1 || - ast.body[0].type !== 'ExpressionStatement' || - (ast.body[0].expression.type !== 'ArrowFunctionExpression' && - ast.body[0].expression.type !== 'FunctionExpression')) { - throw new Error('Failed to resolve function'); +function upgrade (opts, callback) { + if (callback === undefined) { + return new Promise((resolve, reject) => { + upgrade.call(this, opts, (err, data) => { + return err ? reject(err) : resolve(data) + }) + }) } - ast.body[0].expression.params.forEach(function (param) { - params.push(param.name); - }); - - body = ast.body[0].expression.body.range; - - // Esprima's ranges include the first '{' and the last '}' characters on - // function expressions. So cut them out. - if (ast.body[0].expression.body.type === 'BlockStatement') { - /*eslint-disable no-new-func*/ - return new Function(params, source.slice(body[0] + 1, body[1] - 1)); + try { + const upgradeHandler = new UpgradeHandler(opts, callback) + this.dispatch({ + ...opts, + method: opts.method || 'GET', + upgrade: opts.protocol || 'Websocket' + }, upgradeHandler) + } catch (err) { + if (typeof callback !== 'function') { + throw err + } + const opaque = opts?.opaque + queueMicrotask(() => callback(err, { opaque })) } - // ES6 arrow functions can omit the BlockStatement. In that case, just return - // the body. - /*eslint-disable no-new-func*/ - return new Function(params, 'return ' + source.slice(body[0], body[1])); -} - -function representJavascriptFunction(object /*, style*/) { - return object.toString(); -} - -function isFunction(object) { - return Object.prototype.toString.call(object) === '[object Function]'; } -module.exports = new Type('tag:yaml.org,2002:js/function', { - kind: 'scalar', - resolve: resolveJavascriptFunction, - construct: constructJavascriptFunction, - predicate: isFunction, - represent: representJavascriptFunction -}); +module.exports = upgrade /***/ }), -/***/ 4371: -/***/ (function(module) { +/***/ 6615: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = {"pagination":{"GetTranscript":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"}}}; +"use strict"; -/***/ }), -/***/ 4373: -/***/ (function(module) { +module.exports.request = __nccwpck_require__(4043) +module.exports.stream = __nccwpck_require__(3560) +module.exports.pipeline = __nccwpck_require__(6862) +module.exports.upgrade = __nccwpck_require__(1882) +module.exports.connect = __nccwpck_require__(2279) -module.exports = {"pagination":{"ListPlacements":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken","result_key":"placements"},"ListProjects":{"input_token":"nextToken","limit_key":"maxResults","output_token":"nextToken","result_key":"projects"}}}; /***/ }), -/***/ 4380: -/***/ (function(module) { - -module.exports = {"version":2,"waiters":{"EnvironmentExists":{"delay":20,"maxAttempts":20,"operation":"DescribeEnvironments","acceptors":[{"state":"success","matcher":"pathAll","argument":"Environments[].Status","expected":"Ready"},{"state":"retry","matcher":"pathAll","argument":"Environments[].Status","expected":"Launching"}]},"EnvironmentUpdated":{"delay":20,"maxAttempts":20,"operation":"DescribeEnvironments","acceptors":[{"state":"success","matcher":"pathAll","argument":"Environments[].Status","expected":"Ready"},{"state":"retry","matcher":"pathAll","argument":"Environments[].Status","expected":"Updating"}]},"EnvironmentTerminated":{"delay":20,"maxAttempts":20,"operation":"DescribeEnvironments","acceptors":[{"state":"success","matcher":"pathAll","argument":"Environments[].Status","expected":"Terminated"},{"state":"retry","matcher":"pathAll","argument":"Environments[].Status","expected":"Terminating"}]}}}; +/***/ 9927: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -/***/ }), +"use strict"; +// Ported from https://github.com/nodejs/undici/pull/907 + + + +const assert = __nccwpck_require__(4589) +const { Readable } = __nccwpck_require__(7075) +const { RequestAbortedError, NotSupportedError, InvalidArgumentError, AbortError } = __nccwpck_require__(8707) +const util = __nccwpck_require__(3440) +const { ReadableStreamFrom } = __nccwpck_require__(3440) + +const kConsume = Symbol('kConsume') +const kReading = Symbol('kReading') +const kBody = Symbol('kBody') +const kAbort = Symbol('kAbort') +const kContentType = Symbol('kContentType') +const kContentLength = Symbol('kContentLength') + +const noop = () => {} + +class BodyReadable extends Readable { + constructor ({ + resume, + abort, + contentType = '', + contentLength, + highWaterMark = 64 * 1024 // Same as nodejs fs streams. + }) { + super({ + autoDestroy: true, + read: resume, + highWaterMark + }) -/***/ 4388: -/***/ (function(module, __unusedexports, __webpack_require__) { + this._readableState.dataEmitted = false -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; + this[kAbort] = abort + this[kConsume] = null + this[kBody] = null + this[kContentType] = contentType + this[kContentLength] = contentLength -apiLoader.services['honeycode'] = {}; -AWS.Honeycode = Service.defineService('honeycode', ['2020-03-01']); -Object.defineProperty(apiLoader.services['honeycode'], '2020-03-01', { - get: function get() { - var model = __webpack_require__(8343); - model.paginators = __webpack_require__(1346).pagination; - return model; - }, - enumerable: true, - configurable: true -}); + // Is stream being consumed through Readable API? + // This is an optimization so that we avoid checking + // for 'data' and 'readable' listeners in the hot path + // inside push(). + this[kReading] = false + } -module.exports = AWS.Honeycode; + destroy (err) { + if (!err && !this._readableState.endEmitted) { + err = new RequestAbortedError() + } + if (err) { + this[kAbort]() + } -/***/ }), + return super.destroy(err) + } -/***/ 4392: -/***/ (function(module) { + _destroy (err, callback) { + // Workaround for Node "bug". If the stream is destroyed in same + // tick as it is created, then a user who is waiting for a + // promise (i.e micro tick) for installing a 'error' listener will + // never get a chance and will always encounter an unhandled exception. + if (!this[kReading]) { + setImmediate(() => { + callback(err) + }) + } else { + callback(err) + } + } -module.exports = {"version":"2.0","metadata":{"apiVersion":"2015-02-02","endpointPrefix":"elasticache","protocol":"query","serviceFullName":"Amazon ElastiCache","serviceId":"ElastiCache","signatureVersion":"v4","uid":"elasticache-2015-02-02","xmlNamespace":"http://elasticache.amazonaws.com/doc/2015-02-02/"},"operations":{"AddTagsToResource":{"input":{"type":"structure","required":["ResourceName","Tags"],"members":{"ResourceName":{},"Tags":{"shape":"S3"}}},"output":{"shape":"S5","resultWrapper":"AddTagsToResourceResult"}},"AuthorizeCacheSecurityGroupIngress":{"input":{"type":"structure","required":["CacheSecurityGroupName","EC2SecurityGroupName","EC2SecurityGroupOwnerId"],"members":{"CacheSecurityGroupName":{},"EC2SecurityGroupName":{},"EC2SecurityGroupOwnerId":{}}},"output":{"resultWrapper":"AuthorizeCacheSecurityGroupIngressResult","type":"structure","members":{"CacheSecurityGroup":{"shape":"S8"}}}},"BatchApplyUpdateAction":{"input":{"type":"structure","required":["ServiceUpdateName"],"members":{"ReplicationGroupIds":{"shape":"Sc"},"CacheClusterIds":{"shape":"Sd"},"ServiceUpdateName":{}}},"output":{"shape":"Se","resultWrapper":"BatchApplyUpdateActionResult"}},"BatchStopUpdateAction":{"input":{"type":"structure","required":["ServiceUpdateName"],"members":{"ReplicationGroupIds":{"shape":"Sc"},"CacheClusterIds":{"shape":"Sd"},"ServiceUpdateName":{}}},"output":{"shape":"Se","resultWrapper":"BatchStopUpdateActionResult"}},"CompleteMigration":{"input":{"type":"structure","required":["ReplicationGroupId"],"members":{"ReplicationGroupId":{},"Force":{"type":"boolean"}}},"output":{"resultWrapper":"CompleteMigrationResult","type":"structure","members":{"ReplicationGroup":{"shape":"So"}}}},"CopySnapshot":{"input":{"type":"structure","required":["SourceSnapshotName","TargetSnapshotName"],"members":{"SourceSnapshotName":{},"TargetSnapshotName":{},"TargetBucket":{},"KmsKeyId":{}}},"output":{"resultWrapper":"CopySnapshotResult","type":"structure","members":{"Snapshot":{"shape":"S1a"}}}},"CreateCacheCluster":{"input":{"type":"structure","required":["CacheClusterId"],"members":{"CacheClusterId":{},"ReplicationGroupId":{},"AZMode":{},"PreferredAvailabilityZone":{},"PreferredAvailabilityZones":{"shape":"S1i"},"NumCacheNodes":{"type":"integer"},"CacheNodeType":{},"Engine":{},"EngineVersion":{},"CacheParameterGroupName":{},"CacheSubnetGroupName":{},"CacheSecurityGroupNames":{"shape":"S1j"},"SecurityGroupIds":{"shape":"S1k"},"Tags":{"shape":"S3"},"SnapshotArns":{"shape":"S1l"},"SnapshotName":{},"PreferredMaintenanceWindow":{},"Port":{"type":"integer"},"NotificationTopicArn":{},"AutoMinorVersionUpgrade":{"type":"boolean"},"SnapshotRetentionLimit":{"type":"integer"},"SnapshotWindow":{},"AuthToken":{}}},"output":{"resultWrapper":"CreateCacheClusterResult","type":"structure","members":{"CacheCluster":{"shape":"S1n"}}}},"CreateCacheParameterGroup":{"input":{"type":"structure","required":["CacheParameterGroupName","CacheParameterGroupFamily","Description"],"members":{"CacheParameterGroupName":{},"CacheParameterGroupFamily":{},"Description":{}}},"output":{"resultWrapper":"CreateCacheParameterGroupResult","type":"structure","members":{"CacheParameterGroup":{"shape":"S20"}}}},"CreateCacheSecurityGroup":{"input":{"type":"structure","required":["CacheSecurityGroupName","Description"],"members":{"CacheSecurityGroupName":{},"Description":{}}},"output":{"resultWrapper":"CreateCacheSecurityGroupResult","type":"structure","members":{"CacheSecurityGroup":{"shape":"S8"}}}},"CreateCacheSubnetGroup":{"input":{"type":"structure","required":["CacheSubnetGroupName","CacheSubnetGroupDescription","SubnetIds"],"members":{"CacheSubnetGroupName":{},"CacheSubnetGroupDescription":{},"SubnetIds":{"shape":"S24"}}},"output":{"resultWrapper":"CreateCacheSubnetGroupResult","type":"structure","members":{"CacheSubnetGroup":{"shape":"S26"}}}},"CreateGlobalReplicationGroup":{"input":{"type":"structure","required":["GlobalReplicationGroupIdSuffix","PrimaryReplicationGroupId"],"members":{"GlobalReplicationGroupIdSuffix":{},"GlobalReplicationGroupDescription":{},"PrimaryReplicationGroupId":{}}},"output":{"resultWrapper":"CreateGlobalReplicationGroupResult","type":"structure","members":{"GlobalReplicationGroup":{"shape":"S2c"}}}},"CreateReplicationGroup":{"input":{"type":"structure","required":["ReplicationGroupId","ReplicationGroupDescription"],"members":{"ReplicationGroupId":{},"ReplicationGroupDescription":{},"GlobalReplicationGroupId":{},"PrimaryClusterId":{},"AutomaticFailoverEnabled":{"type":"boolean"},"MultiAZEnabled":{"type":"boolean"},"NumCacheClusters":{"type":"integer"},"PreferredCacheClusterAZs":{"shape":"S1f"},"NumNodeGroups":{"type":"integer"},"ReplicasPerNodeGroup":{"type":"integer"},"NodeGroupConfiguration":{"type":"list","member":{"shape":"S1d","locationName":"NodeGroupConfiguration"}},"CacheNodeType":{},"Engine":{},"EngineVersion":{},"CacheParameterGroupName":{},"CacheSubnetGroupName":{},"CacheSecurityGroupNames":{"shape":"S1j"},"SecurityGroupIds":{"shape":"S1k"},"Tags":{"shape":"S3"},"SnapshotArns":{"shape":"S1l"},"SnapshotName":{},"PreferredMaintenanceWindow":{},"Port":{"type":"integer"},"NotificationTopicArn":{},"AutoMinorVersionUpgrade":{"type":"boolean"},"SnapshotRetentionLimit":{"type":"integer"},"SnapshotWindow":{},"AuthToken":{},"TransitEncryptionEnabled":{"type":"boolean"},"AtRestEncryptionEnabled":{"type":"boolean"},"KmsKeyId":{}}},"output":{"resultWrapper":"CreateReplicationGroupResult","type":"structure","members":{"ReplicationGroup":{"shape":"So"}}}},"CreateSnapshot":{"input":{"type":"structure","required":["SnapshotName"],"members":{"ReplicationGroupId":{},"CacheClusterId":{},"SnapshotName":{},"KmsKeyId":{}}},"output":{"resultWrapper":"CreateSnapshotResult","type":"structure","members":{"Snapshot":{"shape":"S1a"}}}},"DecreaseNodeGroupsInGlobalReplicationGroup":{"input":{"type":"structure","required":["GlobalReplicationGroupId","NodeGroupCount","ApplyImmediately"],"members":{"GlobalReplicationGroupId":{},"NodeGroupCount":{"type":"integer"},"GlobalNodeGroupsToRemove":{"shape":"S2n"},"GlobalNodeGroupsToRetain":{"shape":"S2n"},"ApplyImmediately":{"type":"boolean"}}},"output":{"resultWrapper":"DecreaseNodeGroupsInGlobalReplicationGroupResult","type":"structure","members":{"GlobalReplicationGroup":{"shape":"S2c"}}}},"DecreaseReplicaCount":{"input":{"type":"structure","required":["ReplicationGroupId","ApplyImmediately"],"members":{"ReplicationGroupId":{},"NewReplicaCount":{"type":"integer"},"ReplicaConfiguration":{"shape":"S2q"},"ReplicasToRemove":{"type":"list","member":{}},"ApplyImmediately":{"type":"boolean"}}},"output":{"resultWrapper":"DecreaseReplicaCountResult","type":"structure","members":{"ReplicationGroup":{"shape":"So"}}}},"DeleteCacheCluster":{"input":{"type":"structure","required":["CacheClusterId"],"members":{"CacheClusterId":{},"FinalSnapshotIdentifier":{}}},"output":{"resultWrapper":"DeleteCacheClusterResult","type":"structure","members":{"CacheCluster":{"shape":"S1n"}}}},"DeleteCacheParameterGroup":{"input":{"type":"structure","required":["CacheParameterGroupName"],"members":{"CacheParameterGroupName":{}}}},"DeleteCacheSecurityGroup":{"input":{"type":"structure","required":["CacheSecurityGroupName"],"members":{"CacheSecurityGroupName":{}}}},"DeleteCacheSubnetGroup":{"input":{"type":"structure","required":["CacheSubnetGroupName"],"members":{"CacheSubnetGroupName":{}}}},"DeleteGlobalReplicationGroup":{"input":{"type":"structure","required":["GlobalReplicationGroupId","RetainPrimaryReplicationGroup"],"members":{"GlobalReplicationGroupId":{},"RetainPrimaryReplicationGroup":{"type":"boolean"}}},"output":{"resultWrapper":"DeleteGlobalReplicationGroupResult","type":"structure","members":{"GlobalReplicationGroup":{"shape":"S2c"}}}},"DeleteReplicationGroup":{"input":{"type":"structure","required":["ReplicationGroupId"],"members":{"ReplicationGroupId":{},"RetainPrimaryCluster":{"type":"boolean"},"FinalSnapshotIdentifier":{}}},"output":{"resultWrapper":"DeleteReplicationGroupResult","type":"structure","members":{"ReplicationGroup":{"shape":"So"}}}},"DeleteSnapshot":{"input":{"type":"structure","required":["SnapshotName"],"members":{"SnapshotName":{}}},"output":{"resultWrapper":"DeleteSnapshotResult","type":"structure","members":{"Snapshot":{"shape":"S1a"}}}},"DescribeCacheClusters":{"input":{"type":"structure","members":{"CacheClusterId":{},"MaxRecords":{"type":"integer"},"Marker":{},"ShowCacheNodeInfo":{"type":"boolean"},"ShowCacheClustersNotInReplicationGroups":{"type":"boolean"}}},"output":{"resultWrapper":"DescribeCacheClustersResult","type":"structure","members":{"Marker":{},"CacheClusters":{"type":"list","member":{"shape":"S1n","locationName":"CacheCluster"}}}}},"DescribeCacheEngineVersions":{"input":{"type":"structure","members":{"Engine":{},"EngineVersion":{},"CacheParameterGroupFamily":{},"MaxRecords":{"type":"integer"},"Marker":{},"DefaultOnly":{"type":"boolean"}}},"output":{"resultWrapper":"DescribeCacheEngineVersionsResult","type":"structure","members":{"Marker":{},"CacheEngineVersions":{"type":"list","member":{"locationName":"CacheEngineVersion","type":"structure","members":{"Engine":{},"EngineVersion":{},"CacheParameterGroupFamily":{},"CacheEngineDescription":{},"CacheEngineVersionDescription":{}}}}}}},"DescribeCacheParameterGroups":{"input":{"type":"structure","members":{"CacheParameterGroupName":{},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeCacheParameterGroupsResult","type":"structure","members":{"Marker":{},"CacheParameterGroups":{"type":"list","member":{"shape":"S20","locationName":"CacheParameterGroup"}}}}},"DescribeCacheParameters":{"input":{"type":"structure","required":["CacheParameterGroupName"],"members":{"CacheParameterGroupName":{},"Source":{},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeCacheParametersResult","type":"structure","members":{"Marker":{},"Parameters":{"shape":"S3h"},"CacheNodeTypeSpecificParameters":{"shape":"S3k"}}}},"DescribeCacheSecurityGroups":{"input":{"type":"structure","members":{"CacheSecurityGroupName":{},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeCacheSecurityGroupsResult","type":"structure","members":{"Marker":{},"CacheSecurityGroups":{"type":"list","member":{"shape":"S8","locationName":"CacheSecurityGroup"}}}}},"DescribeCacheSubnetGroups":{"input":{"type":"structure","members":{"CacheSubnetGroupName":{},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeCacheSubnetGroupsResult","type":"structure","members":{"Marker":{},"CacheSubnetGroups":{"type":"list","member":{"shape":"S26","locationName":"CacheSubnetGroup"}}}}},"DescribeEngineDefaultParameters":{"input":{"type":"structure","required":["CacheParameterGroupFamily"],"members":{"CacheParameterGroupFamily":{},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeEngineDefaultParametersResult","type":"structure","members":{"EngineDefaults":{"type":"structure","members":{"CacheParameterGroupFamily":{},"Marker":{},"Parameters":{"shape":"S3h"},"CacheNodeTypeSpecificParameters":{"shape":"S3k"}},"wrapper":true}}}},"DescribeEvents":{"input":{"type":"structure","members":{"SourceIdentifier":{},"SourceType":{},"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"Duration":{"type":"integer"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeEventsResult","type":"structure","members":{"Marker":{},"Events":{"type":"list","member":{"locationName":"Event","type":"structure","members":{"SourceIdentifier":{},"SourceType":{},"Message":{},"Date":{"type":"timestamp"}}}}}}},"DescribeGlobalReplicationGroups":{"input":{"type":"structure","members":{"GlobalReplicationGroupId":{},"MaxRecords":{"type":"integer"},"Marker":{},"ShowMemberInfo":{"type":"boolean"}}},"output":{"resultWrapper":"DescribeGlobalReplicationGroupsResult","type":"structure","members":{"Marker":{},"GlobalReplicationGroups":{"type":"list","member":{"shape":"S2c","locationName":"GlobalReplicationGroup"}}}}},"DescribeReplicationGroups":{"input":{"type":"structure","members":{"ReplicationGroupId":{},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeReplicationGroupsResult","type":"structure","members":{"Marker":{},"ReplicationGroups":{"type":"list","member":{"shape":"So","locationName":"ReplicationGroup"}}}}},"DescribeReservedCacheNodes":{"input":{"type":"structure","members":{"ReservedCacheNodeId":{},"ReservedCacheNodesOfferingId":{},"CacheNodeType":{},"Duration":{},"ProductDescription":{},"OfferingType":{},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeReservedCacheNodesResult","type":"structure","members":{"Marker":{},"ReservedCacheNodes":{"type":"list","member":{"shape":"S4b","locationName":"ReservedCacheNode"}}}}},"DescribeReservedCacheNodesOfferings":{"input":{"type":"structure","members":{"ReservedCacheNodesOfferingId":{},"CacheNodeType":{},"Duration":{},"ProductDescription":{},"OfferingType":{},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeReservedCacheNodesOfferingsResult","type":"structure","members":{"Marker":{},"ReservedCacheNodesOfferings":{"type":"list","member":{"locationName":"ReservedCacheNodesOffering","type":"structure","members":{"ReservedCacheNodesOfferingId":{},"CacheNodeType":{},"Duration":{"type":"integer"},"FixedPrice":{"type":"double"},"UsagePrice":{"type":"double"},"ProductDescription":{},"OfferingType":{},"RecurringCharges":{"shape":"S4c"}},"wrapper":true}}}}},"DescribeServiceUpdates":{"input":{"type":"structure","members":{"ServiceUpdateName":{},"ServiceUpdateStatus":{"shape":"S4j"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeServiceUpdatesResult","type":"structure","members":{"Marker":{},"ServiceUpdates":{"type":"list","member":{"locationName":"ServiceUpdate","type":"structure","members":{"ServiceUpdateName":{},"ServiceUpdateReleaseDate":{"type":"timestamp"},"ServiceUpdateEndDate":{"type":"timestamp"},"ServiceUpdateSeverity":{},"ServiceUpdateRecommendedApplyByDate":{"type":"timestamp"},"ServiceUpdateStatus":{},"ServiceUpdateDescription":{},"ServiceUpdateType":{},"Engine":{},"EngineVersion":{},"AutoUpdateAfterRecommendedApplyByDate":{"type":"boolean"},"EstimatedUpdateTime":{}}}}}}},"DescribeSnapshots":{"input":{"type":"structure","members":{"ReplicationGroupId":{},"CacheClusterId":{},"SnapshotName":{},"SnapshotSource":{},"Marker":{},"MaxRecords":{"type":"integer"},"ShowNodeGroupConfig":{"type":"boolean"}}},"output":{"resultWrapper":"DescribeSnapshotsResult","type":"structure","members":{"Marker":{},"Snapshots":{"type":"list","member":{"shape":"S1a","locationName":"Snapshot"}}}}},"DescribeUpdateActions":{"input":{"type":"structure","members":{"ServiceUpdateName":{},"ReplicationGroupIds":{"shape":"Sc"},"CacheClusterIds":{"shape":"Sd"},"Engine":{},"ServiceUpdateStatus":{"shape":"S4j"},"ServiceUpdateTimeRange":{"type":"structure","members":{"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"}}},"UpdateActionStatus":{"type":"list","member":{}},"ShowNodeLevelUpdateStatus":{"type":"boolean"},"MaxRecords":{"type":"integer"},"Marker":{}}},"output":{"resultWrapper":"DescribeUpdateActionsResult","type":"structure","members":{"Marker":{},"UpdateActions":{"type":"list","member":{"locationName":"UpdateAction","type":"structure","members":{"ReplicationGroupId":{},"CacheClusterId":{},"ServiceUpdateName":{},"ServiceUpdateReleaseDate":{"type":"timestamp"},"ServiceUpdateSeverity":{},"ServiceUpdateStatus":{},"ServiceUpdateRecommendedApplyByDate":{"type":"timestamp"},"ServiceUpdateType":{},"UpdateActionAvailableDate":{"type":"timestamp"},"UpdateActionStatus":{},"NodesUpdated":{},"UpdateActionStatusModifiedDate":{"type":"timestamp"},"SlaMet":{},"NodeGroupUpdateStatus":{"type":"list","member":{"locationName":"NodeGroupUpdateStatus","type":"structure","members":{"NodeGroupId":{},"NodeGroupMemberUpdateStatus":{"type":"list","member":{"locationName":"NodeGroupMemberUpdateStatus","type":"structure","members":{"CacheClusterId":{},"CacheNodeId":{},"NodeUpdateStatus":{},"NodeDeletionDate":{"type":"timestamp"},"NodeUpdateStartDate":{"type":"timestamp"},"NodeUpdateEndDate":{"type":"timestamp"},"NodeUpdateInitiatedBy":{},"NodeUpdateInitiatedDate":{"type":"timestamp"},"NodeUpdateStatusModifiedDate":{"type":"timestamp"}}}}}}},"CacheNodeUpdateStatus":{"type":"list","member":{"locationName":"CacheNodeUpdateStatus","type":"structure","members":{"CacheNodeId":{},"NodeUpdateStatus":{},"NodeDeletionDate":{"type":"timestamp"},"NodeUpdateStartDate":{"type":"timestamp"},"NodeUpdateEndDate":{"type":"timestamp"},"NodeUpdateInitiatedBy":{},"NodeUpdateInitiatedDate":{"type":"timestamp"},"NodeUpdateStatusModifiedDate":{"type":"timestamp"}}}},"EstimatedUpdateTime":{},"Engine":{}}}}}}},"DisassociateGlobalReplicationGroup":{"input":{"type":"structure","required":["GlobalReplicationGroupId","ReplicationGroupId","ReplicationGroupRegion"],"members":{"GlobalReplicationGroupId":{},"ReplicationGroupId":{},"ReplicationGroupRegion":{}}},"output":{"resultWrapper":"DisassociateGlobalReplicationGroupResult","type":"structure","members":{"GlobalReplicationGroup":{"shape":"S2c"}}}},"FailoverGlobalReplicationGroup":{"input":{"type":"structure","required":["GlobalReplicationGroupId","PrimaryRegion","PrimaryReplicationGroupId"],"members":{"GlobalReplicationGroupId":{},"PrimaryRegion":{},"PrimaryReplicationGroupId":{}}},"output":{"resultWrapper":"FailoverGlobalReplicationGroupResult","type":"structure","members":{"GlobalReplicationGroup":{"shape":"S2c"}}}},"IncreaseNodeGroupsInGlobalReplicationGroup":{"input":{"type":"structure","required":["GlobalReplicationGroupId","NodeGroupCount","ApplyImmediately"],"members":{"GlobalReplicationGroupId":{},"NodeGroupCount":{"type":"integer"},"RegionalConfigurations":{"type":"list","member":{"locationName":"RegionalConfiguration","type":"structure","required":["ReplicationGroupId","ReplicationGroupRegion","ReshardingConfiguration"],"members":{"ReplicationGroupId":{},"ReplicationGroupRegion":{},"ReshardingConfiguration":{"shape":"S5f"}}}},"ApplyImmediately":{"type":"boolean"}}},"output":{"resultWrapper":"IncreaseNodeGroupsInGlobalReplicationGroupResult","type":"structure","members":{"GlobalReplicationGroup":{"shape":"S2c"}}}},"IncreaseReplicaCount":{"input":{"type":"structure","required":["ReplicationGroupId","ApplyImmediately"],"members":{"ReplicationGroupId":{},"NewReplicaCount":{"type":"integer"},"ReplicaConfiguration":{"shape":"S2q"},"ApplyImmediately":{"type":"boolean"}}},"output":{"resultWrapper":"IncreaseReplicaCountResult","type":"structure","members":{"ReplicationGroup":{"shape":"So"}}}},"ListAllowedNodeTypeModifications":{"input":{"type":"structure","members":{"CacheClusterId":{},"ReplicationGroupId":{}}},"output":{"resultWrapper":"ListAllowedNodeTypeModificationsResult","type":"structure","members":{"ScaleUpModifications":{"shape":"S5m"},"ScaleDownModifications":{"shape":"S5m"}}}},"ListTagsForResource":{"input":{"type":"structure","required":["ResourceName"],"members":{"ResourceName":{}}},"output":{"shape":"S5","resultWrapper":"ListTagsForResourceResult"}},"ModifyCacheCluster":{"input":{"type":"structure","required":["CacheClusterId"],"members":{"CacheClusterId":{},"NumCacheNodes":{"type":"integer"},"CacheNodeIdsToRemove":{"shape":"S1p"},"AZMode":{},"NewAvailabilityZones":{"shape":"S1i"},"CacheSecurityGroupNames":{"shape":"S1j"},"SecurityGroupIds":{"shape":"S1k"},"PreferredMaintenanceWindow":{},"NotificationTopicArn":{},"CacheParameterGroupName":{},"NotificationTopicStatus":{},"ApplyImmediately":{"type":"boolean"},"EngineVersion":{},"AutoMinorVersionUpgrade":{"type":"boolean"},"SnapshotRetentionLimit":{"type":"integer"},"SnapshotWindow":{},"CacheNodeType":{},"AuthToken":{},"AuthTokenUpdateStrategy":{}}},"output":{"resultWrapper":"ModifyCacheClusterResult","type":"structure","members":{"CacheCluster":{"shape":"S1n"}}}},"ModifyCacheParameterGroup":{"input":{"type":"structure","required":["CacheParameterGroupName","ParameterNameValues"],"members":{"CacheParameterGroupName":{},"ParameterNameValues":{"shape":"S5s"}}},"output":{"shape":"S5u","resultWrapper":"ModifyCacheParameterGroupResult"}},"ModifyCacheSubnetGroup":{"input":{"type":"structure","required":["CacheSubnetGroupName"],"members":{"CacheSubnetGroupName":{},"CacheSubnetGroupDescription":{},"SubnetIds":{"shape":"S24"}}},"output":{"resultWrapper":"ModifyCacheSubnetGroupResult","type":"structure","members":{"CacheSubnetGroup":{"shape":"S26"}}}},"ModifyGlobalReplicationGroup":{"input":{"type":"structure","required":["GlobalReplicationGroupId","ApplyImmediately"],"members":{"GlobalReplicationGroupId":{},"ApplyImmediately":{"type":"boolean"},"CacheNodeType":{},"EngineVersion":{},"GlobalReplicationGroupDescription":{},"AutomaticFailoverEnabled":{"type":"boolean"}}},"output":{"resultWrapper":"ModifyGlobalReplicationGroupResult","type":"structure","members":{"GlobalReplicationGroup":{"shape":"S2c"}}}},"ModifyReplicationGroup":{"input":{"type":"structure","required":["ReplicationGroupId"],"members":{"ReplicationGroupId":{},"ReplicationGroupDescription":{},"PrimaryClusterId":{},"SnapshottingClusterId":{},"AutomaticFailoverEnabled":{"type":"boolean"},"MultiAZEnabled":{"type":"boolean"},"NodeGroupId":{"deprecated":true},"CacheSecurityGroupNames":{"shape":"S1j"},"SecurityGroupIds":{"shape":"S1k"},"PreferredMaintenanceWindow":{},"NotificationTopicArn":{},"CacheParameterGroupName":{},"NotificationTopicStatus":{},"ApplyImmediately":{"type":"boolean"},"EngineVersion":{},"AutoMinorVersionUpgrade":{"type":"boolean"},"SnapshotRetentionLimit":{"type":"integer"},"SnapshotWindow":{},"CacheNodeType":{},"AuthToken":{},"AuthTokenUpdateStrategy":{}}},"output":{"resultWrapper":"ModifyReplicationGroupResult","type":"structure","members":{"ReplicationGroup":{"shape":"So"}}}},"ModifyReplicationGroupShardConfiguration":{"input":{"type":"structure","required":["ReplicationGroupId","NodeGroupCount","ApplyImmediately"],"members":{"ReplicationGroupId":{},"NodeGroupCount":{"type":"integer"},"ApplyImmediately":{"type":"boolean"},"ReshardingConfiguration":{"shape":"S5f"},"NodeGroupsToRemove":{"type":"list","member":{"locationName":"NodeGroupToRemove"}},"NodeGroupsToRetain":{"type":"list","member":{"locationName":"NodeGroupToRetain"}}}},"output":{"resultWrapper":"ModifyReplicationGroupShardConfigurationResult","type":"structure","members":{"ReplicationGroup":{"shape":"So"}}}},"PurchaseReservedCacheNodesOffering":{"input":{"type":"structure","required":["ReservedCacheNodesOfferingId"],"members":{"ReservedCacheNodesOfferingId":{},"ReservedCacheNodeId":{},"CacheNodeCount":{"type":"integer"}}},"output":{"resultWrapper":"PurchaseReservedCacheNodesOfferingResult","type":"structure","members":{"ReservedCacheNode":{"shape":"S4b"}}}},"RebalanceSlotsInGlobalReplicationGroup":{"input":{"type":"structure","required":["GlobalReplicationGroupId","ApplyImmediately"],"members":{"GlobalReplicationGroupId":{},"ApplyImmediately":{"type":"boolean"}}},"output":{"resultWrapper":"RebalanceSlotsInGlobalReplicationGroupResult","type":"structure","members":{"GlobalReplicationGroup":{"shape":"S2c"}}}},"RebootCacheCluster":{"input":{"type":"structure","required":["CacheClusterId","CacheNodeIdsToReboot"],"members":{"CacheClusterId":{},"CacheNodeIdsToReboot":{"shape":"S1p"}}},"output":{"resultWrapper":"RebootCacheClusterResult","type":"structure","members":{"CacheCluster":{"shape":"S1n"}}}},"RemoveTagsFromResource":{"input":{"type":"structure","required":["ResourceName","TagKeys"],"members":{"ResourceName":{},"TagKeys":{"type":"list","member":{}}}},"output":{"shape":"S5","resultWrapper":"RemoveTagsFromResourceResult"}},"ResetCacheParameterGroup":{"input":{"type":"structure","required":["CacheParameterGroupName"],"members":{"CacheParameterGroupName":{},"ResetAllParameters":{"type":"boolean"},"ParameterNameValues":{"shape":"S5s"}}},"output":{"shape":"S5u","resultWrapper":"ResetCacheParameterGroupResult"}},"RevokeCacheSecurityGroupIngress":{"input":{"type":"structure","required":["CacheSecurityGroupName","EC2SecurityGroupName","EC2SecurityGroupOwnerId"],"members":{"CacheSecurityGroupName":{},"EC2SecurityGroupName":{},"EC2SecurityGroupOwnerId":{}}},"output":{"resultWrapper":"RevokeCacheSecurityGroupIngressResult","type":"structure","members":{"CacheSecurityGroup":{"shape":"S8"}}}},"StartMigration":{"input":{"type":"structure","required":["ReplicationGroupId","CustomerNodeEndpointList"],"members":{"ReplicationGroupId":{},"CustomerNodeEndpointList":{"type":"list","member":{"type":"structure","members":{"Address":{},"Port":{"type":"integer"}}}}}},"output":{"resultWrapper":"StartMigrationResult","type":"structure","members":{"ReplicationGroup":{"shape":"So"}}}},"TestFailover":{"input":{"type":"structure","required":["ReplicationGroupId","NodeGroupId"],"members":{"ReplicationGroupId":{},"NodeGroupId":{}}},"output":{"resultWrapper":"TestFailoverResult","type":"structure","members":{"ReplicationGroup":{"shape":"So"}}}}},"shapes":{"S3":{"type":"list","member":{"locationName":"Tag","type":"structure","members":{"Key":{},"Value":{}}}},"S5":{"type":"structure","members":{"TagList":{"shape":"S3"}}},"S8":{"type":"structure","members":{"OwnerId":{},"CacheSecurityGroupName":{},"Description":{},"EC2SecurityGroups":{"type":"list","member":{"locationName":"EC2SecurityGroup","type":"structure","members":{"Status":{},"EC2SecurityGroupName":{},"EC2SecurityGroupOwnerId":{}}}},"ARN":{}},"wrapper":true},"Sc":{"type":"list","member":{}},"Sd":{"type":"list","member":{}},"Se":{"type":"structure","members":{"ProcessedUpdateActions":{"type":"list","member":{"locationName":"ProcessedUpdateAction","type":"structure","members":{"ReplicationGroupId":{},"CacheClusterId":{},"ServiceUpdateName":{},"UpdateActionStatus":{}}}},"UnprocessedUpdateActions":{"type":"list","member":{"locationName":"UnprocessedUpdateAction","type":"structure","members":{"ReplicationGroupId":{},"CacheClusterId":{},"ServiceUpdateName":{},"ErrorType":{},"ErrorMessage":{}}}}}},"So":{"type":"structure","members":{"ReplicationGroupId":{},"Description":{},"GlobalReplicationGroupInfo":{"type":"structure","members":{"GlobalReplicationGroupId":{},"GlobalReplicationGroupMemberRole":{}}},"Status":{},"PendingModifiedValues":{"type":"structure","members":{"PrimaryClusterId":{},"AutomaticFailoverStatus":{},"Resharding":{"type":"structure","members":{"SlotMigration":{"type":"structure","members":{"ProgressPercentage":{"type":"double"}}}}},"AuthTokenStatus":{}}},"MemberClusters":{"type":"list","member":{"locationName":"ClusterId"}},"NodeGroups":{"type":"list","member":{"locationName":"NodeGroup","type":"structure","members":{"NodeGroupId":{},"Status":{},"PrimaryEndpoint":{"shape":"Sz"},"ReaderEndpoint":{"shape":"Sz"},"Slots":{},"NodeGroupMembers":{"type":"list","member":{"locationName":"NodeGroupMember","type":"structure","members":{"CacheClusterId":{},"CacheNodeId":{},"ReadEndpoint":{"shape":"Sz"},"PreferredAvailabilityZone":{},"CurrentRole":{}}}}}}},"SnapshottingClusterId":{},"AutomaticFailover":{},"MultiAZ":{},"ConfigurationEndpoint":{"shape":"Sz"},"SnapshotRetentionLimit":{"type":"integer"},"SnapshotWindow":{},"ClusterEnabled":{"type":"boolean"},"CacheNodeType":{},"AuthTokenEnabled":{"type":"boolean"},"AuthTokenLastModifiedDate":{"type":"timestamp"},"TransitEncryptionEnabled":{"type":"boolean"},"AtRestEncryptionEnabled":{"type":"boolean"},"KmsKeyId":{},"ARN":{}},"wrapper":true},"Sz":{"type":"structure","members":{"Address":{},"Port":{"type":"integer"}}},"S1a":{"type":"structure","members":{"SnapshotName":{},"ReplicationGroupId":{},"ReplicationGroupDescription":{},"CacheClusterId":{},"SnapshotStatus":{},"SnapshotSource":{},"CacheNodeType":{},"Engine":{},"EngineVersion":{},"NumCacheNodes":{"type":"integer"},"PreferredAvailabilityZone":{},"CacheClusterCreateTime":{"type":"timestamp"},"PreferredMaintenanceWindow":{},"TopicArn":{},"Port":{"type":"integer"},"CacheParameterGroupName":{},"CacheSubnetGroupName":{},"VpcId":{},"AutoMinorVersionUpgrade":{"type":"boolean"},"SnapshotRetentionLimit":{"type":"integer"},"SnapshotWindow":{},"NumNodeGroups":{"type":"integer"},"AutomaticFailover":{},"NodeSnapshots":{"type":"list","member":{"locationName":"NodeSnapshot","type":"structure","members":{"CacheClusterId":{},"NodeGroupId":{},"CacheNodeId":{},"NodeGroupConfiguration":{"shape":"S1d"},"CacheSize":{},"CacheNodeCreateTime":{"type":"timestamp"},"SnapshotCreateTime":{"type":"timestamp"}},"wrapper":true}},"KmsKeyId":{},"ARN":{}},"wrapper":true},"S1d":{"type":"structure","members":{"NodeGroupId":{},"Slots":{},"ReplicaCount":{"type":"integer"},"PrimaryAvailabilityZone":{},"ReplicaAvailabilityZones":{"shape":"S1f"}}},"S1f":{"type":"list","member":{"locationName":"AvailabilityZone"}},"S1i":{"type":"list","member":{"locationName":"PreferredAvailabilityZone"}},"S1j":{"type":"list","member":{"locationName":"CacheSecurityGroupName"}},"S1k":{"type":"list","member":{"locationName":"SecurityGroupId"}},"S1l":{"type":"list","member":{"locationName":"SnapshotArn"}},"S1n":{"type":"structure","members":{"CacheClusterId":{},"ConfigurationEndpoint":{"shape":"Sz"},"ClientDownloadLandingPage":{},"CacheNodeType":{},"Engine":{},"EngineVersion":{},"CacheClusterStatus":{},"NumCacheNodes":{"type":"integer"},"PreferredAvailabilityZone":{},"CacheClusterCreateTime":{"type":"timestamp"},"PreferredMaintenanceWindow":{},"PendingModifiedValues":{"type":"structure","members":{"NumCacheNodes":{"type":"integer"},"CacheNodeIdsToRemove":{"shape":"S1p"},"EngineVersion":{},"CacheNodeType":{},"AuthTokenStatus":{}}},"NotificationConfiguration":{"type":"structure","members":{"TopicArn":{},"TopicStatus":{}}},"CacheSecurityGroups":{"type":"list","member":{"locationName":"CacheSecurityGroup","type":"structure","members":{"CacheSecurityGroupName":{},"Status":{}}}},"CacheParameterGroup":{"type":"structure","members":{"CacheParameterGroupName":{},"ParameterApplyStatus":{},"CacheNodeIdsToReboot":{"shape":"S1p"}}},"CacheSubnetGroupName":{},"CacheNodes":{"type":"list","member":{"locationName":"CacheNode","type":"structure","members":{"CacheNodeId":{},"CacheNodeStatus":{},"CacheNodeCreateTime":{"type":"timestamp"},"Endpoint":{"shape":"Sz"},"ParameterGroupStatus":{},"SourceCacheNodeId":{},"CustomerAvailabilityZone":{}}}},"AutoMinorVersionUpgrade":{"type":"boolean"},"SecurityGroups":{"type":"list","member":{"type":"structure","members":{"SecurityGroupId":{},"Status":{}}}},"ReplicationGroupId":{},"SnapshotRetentionLimit":{"type":"integer"},"SnapshotWindow":{},"AuthTokenEnabled":{"type":"boolean"},"AuthTokenLastModifiedDate":{"type":"timestamp"},"TransitEncryptionEnabled":{"type":"boolean"},"AtRestEncryptionEnabled":{"type":"boolean"},"ARN":{}},"wrapper":true},"S1p":{"type":"list","member":{"locationName":"CacheNodeId"}},"S20":{"type":"structure","members":{"CacheParameterGroupName":{},"CacheParameterGroupFamily":{},"Description":{},"IsGlobal":{"type":"boolean"},"ARN":{}},"wrapper":true},"S24":{"type":"list","member":{"locationName":"SubnetIdentifier"}},"S26":{"type":"structure","members":{"CacheSubnetGroupName":{},"CacheSubnetGroupDescription":{},"VpcId":{},"Subnets":{"type":"list","member":{"locationName":"Subnet","type":"structure","members":{"SubnetIdentifier":{},"SubnetAvailabilityZone":{"type":"structure","members":{"Name":{}},"wrapper":true}}}},"ARN":{}},"wrapper":true},"S2c":{"type":"structure","members":{"GlobalReplicationGroupId":{},"GlobalReplicationGroupDescription":{},"Status":{},"CacheNodeType":{},"Engine":{},"EngineVersion":{},"Members":{"type":"list","member":{"locationName":"GlobalReplicationGroupMember","type":"structure","members":{"ReplicationGroupId":{},"ReplicationGroupRegion":{},"Role":{},"AutomaticFailover":{},"Status":{}},"wrapper":true}},"ClusterEnabled":{"type":"boolean"},"GlobalNodeGroups":{"type":"list","member":{"locationName":"GlobalNodeGroup","type":"structure","members":{"GlobalNodeGroupId":{},"Slots":{}}}},"AuthTokenEnabled":{"type":"boolean"},"TransitEncryptionEnabled":{"type":"boolean"},"AtRestEncryptionEnabled":{"type":"boolean"},"ARN":{}},"wrapper":true},"S2n":{"type":"list","member":{"locationName":"GlobalNodeGroupId"}},"S2q":{"type":"list","member":{"locationName":"ConfigureShard","type":"structure","required":["NodeGroupId","NewReplicaCount"],"members":{"NodeGroupId":{},"NewReplicaCount":{"type":"integer"},"PreferredAvailabilityZones":{"shape":"S1i"}}}},"S3h":{"type":"list","member":{"locationName":"Parameter","type":"structure","members":{"ParameterName":{},"ParameterValue":{},"Description":{},"Source":{},"DataType":{},"AllowedValues":{},"IsModifiable":{"type":"boolean"},"MinimumEngineVersion":{},"ChangeType":{}}}},"S3k":{"type":"list","member":{"locationName":"CacheNodeTypeSpecificParameter","type":"structure","members":{"ParameterName":{},"Description":{},"Source":{},"DataType":{},"AllowedValues":{},"IsModifiable":{"type":"boolean"},"MinimumEngineVersion":{},"CacheNodeTypeSpecificValues":{"type":"list","member":{"locationName":"CacheNodeTypeSpecificValue","type":"structure","members":{"CacheNodeType":{},"Value":{}}}},"ChangeType":{}}}},"S4b":{"type":"structure","members":{"ReservedCacheNodeId":{},"ReservedCacheNodesOfferingId":{},"CacheNodeType":{},"StartTime":{"type":"timestamp"},"Duration":{"type":"integer"},"FixedPrice":{"type":"double"},"UsagePrice":{"type":"double"},"CacheNodeCount":{"type":"integer"},"ProductDescription":{},"OfferingType":{},"State":{},"RecurringCharges":{"shape":"S4c"},"ReservationARN":{}},"wrapper":true},"S4c":{"type":"list","member":{"locationName":"RecurringCharge","type":"structure","members":{"RecurringChargeAmount":{"type":"double"},"RecurringChargeFrequency":{}},"wrapper":true}},"S4j":{"type":"list","member":{}},"S5f":{"type":"list","member":{"locationName":"ReshardingConfiguration","type":"structure","members":{"NodeGroupId":{},"PreferredAvailabilityZones":{"shape":"S1f"}}}},"S5m":{"type":"list","member":{}},"S5s":{"type":"list","member":{"locationName":"ParameterNameValue","type":"structure","members":{"ParameterName":{},"ParameterValue":{}}}},"S5u":{"type":"structure","members":{"CacheParameterGroupName":{}}}}}; + on (ev, ...args) { + if (ev === 'data' || ev === 'readable') { + this[kReading] = true + } + return super.on(ev, ...args) + } -/***/ }), + addListener (ev, ...args) { + return this.on(ev, ...args) + } -/***/ 4400: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; + off (ev, ...args) { + const ret = super.off(ev, ...args) + if (ev === 'data' || ev === 'readable') { + this[kReading] = ( + this.listenerCount('data') > 0 || + this.listenerCount('readable') > 0 + ) + } + return ret + } -apiLoader.services['workspaces'] = {}; -AWS.WorkSpaces = Service.defineService('workspaces', ['2015-04-08']); -Object.defineProperty(apiLoader.services['workspaces'], '2015-04-08', { - get: function get() { - var model = __webpack_require__(5168); - model.paginators = __webpack_require__(7854).pagination; - return model; - }, - enumerable: true, - configurable: true -}); + removeListener (ev, ...args) { + return this.off(ev, ...args) + } -module.exports = AWS.WorkSpaces; + push (chunk) { + if (this[kConsume] && chunk !== null) { + consumePush(this[kConsume], chunk) + return this[kReading] ? super.push(chunk) : true + } + return super.push(chunk) + } + // https://fetch.spec.whatwg.org/#dom-body-text + async text () { + return consume(this, 'text') + } -/***/ }), + // https://fetch.spec.whatwg.org/#dom-body-json + async json () { + return consume(this, 'json') + } -/***/ 4409: -/***/ (function(module) { + // https://fetch.spec.whatwg.org/#dom-body-blob + async blob () { + return consume(this, 'blob') + } -module.exports = {"pagination":{"ListEventTypes":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"EventTypes"},"ListNotificationRules":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"NotificationRules"},"ListTargets":{"input_token":"NextToken","limit_key":"MaxResults","output_token":"NextToken","result_key":"Targets"}}}; + // https://fetch.spec.whatwg.org/#dom-body-bytes + async bytes () { + return consume(this, 'bytes') + } -/***/ }), + // https://fetch.spec.whatwg.org/#dom-body-arraybuffer + async arrayBuffer () { + return consume(this, 'arrayBuffer') + } -/***/ 4431: -/***/ (function(__unusedmodule, exports, __webpack_require__) { + // https://fetch.spec.whatwg.org/#dom-body-formdata + async formData () { + // TODO: Implement. + throw new NotSupportedError() + } -"use strict"; + // https://fetch.spec.whatwg.org/#dom-body-bodyused + get bodyUsed () { + return util.isDisturbed(this) + } -var __importStar = (this && this.__importStar) || function (mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k]; - result["default"] = mod; - return result; -}; -Object.defineProperty(exports, "__esModule", { value: true }); -const os = __importStar(__webpack_require__(2087)); -/** - * Commands - * - * Command Format: - * ::name key=value,key=value::message - * - * Examples: - * ::warning::This is the message - * ::set-env name=MY_VAR::some value - */ -function issueCommand(command, properties, message) { - const cmd = new Command(command, properties, message); - process.stdout.write(cmd.toString() + os.EOL); -} -exports.issueCommand = issueCommand; -function issue(name, message = '') { - issueCommand(name, {}, message); -} -exports.issue = issue; -const CMD_STRING = '::'; -class Command { - constructor(command, properties, message) { - if (!command) { - command = 'missing.command'; - } - this.command = command; - this.properties = properties; - this.message = message; - } - toString() { - let cmdStr = CMD_STRING + this.command; - if (this.properties && Object.keys(this.properties).length > 0) { - cmdStr += ' '; - let first = true; - for (const key in this.properties) { - if (this.properties.hasOwnProperty(key)) { - const val = this.properties[key]; - if (val) { - if (first) { - first = false; - } - else { - cmdStr += ','; - } - cmdStr += `${key}=${escapeProperty(val)}`; - } - } - } - } - cmdStr += `${CMD_STRING}${escapeData(this.message)}`; - return cmdStr; - } -} -/** - * Sanitizes an input into a string so it can be passed into issueCommand safely - * @param input input to sanitize into a string - */ -function toCommandValue(input) { - if (input === null || input === undefined) { - return ''; - } - else if (typeof input === 'string' || input instanceof String) { - return input; + // https://fetch.spec.whatwg.org/#dom-body-body + get body () { + if (!this[kBody]) { + this[kBody] = ReadableStreamFrom(this) + if (this[kConsume]) { + // TODO: Is this the best way to force a lock? + this[kBody].getReader() // Ensure stream is locked. + assert(this[kBody].locked) + } } - return JSON.stringify(input); -} -exports.toCommandValue = toCommandValue; -function escapeData(s) { - return toCommandValue(s) - .replace(/%/g, '%25') - .replace(/\r/g, '%0D') - .replace(/\n/g, '%0A'); -} -function escapeProperty(s) { - return toCommandValue(s) - .replace(/%/g, '%25') - .replace(/\r/g, '%0D') - .replace(/\n/g, '%0A') - .replace(/:/g, '%3A') - .replace(/,/g, '%2C'); -} -//# sourceMappingURL=command.js.map - -/***/ }), - -/***/ 4437: -/***/ (function(module) { - -module.exports = {"pagination":{"ListMeshes":{"input_token":"nextToken","limit_key":"limit","output_token":"nextToken","result_key":"meshes"},"ListRoutes":{"input_token":"nextToken","limit_key":"limit","output_token":"nextToken","result_key":"routes"},"ListVirtualNodes":{"input_token":"nextToken","limit_key":"limit","output_token":"nextToken","result_key":"virtualNodes"},"ListVirtualRouters":{"input_token":"nextToken","limit_key":"limit","output_token":"nextToken","result_key":"virtualRouters"}}}; - -/***/ }), - -/***/ 4444: -/***/ (function(module) { + return this[kBody] + } -module.exports = {"metadata":{"apiVersion":"2017-10-14","endpointPrefix":"medialive","signingName":"medialive","serviceFullName":"AWS Elemental MediaLive","serviceId":"MediaLive","protocol":"rest-json","uid":"medialive-2017-10-14","signatureVersion":"v4","serviceAbbreviation":"MediaLive","jsonVersion":"1.1"},"operations":{"BatchUpdateSchedule":{"http":{"method":"PUT","requestUri":"/prod/channels/{channelId}/schedule","responseCode":200},"input":{"type":"structure","members":{"ChannelId":{"location":"uri","locationName":"channelId"},"Creates":{"locationName":"creates","type":"structure","members":{"ScheduleActions":{"shape":"S4","locationName":"scheduleActions"}},"required":["ScheduleActions"]},"Deletes":{"locationName":"deletes","type":"structure","members":{"ActionNames":{"shape":"Sf","locationName":"actionNames"}},"required":["ActionNames"]}},"required":["ChannelId"]},"output":{"type":"structure","members":{"Creates":{"locationName":"creates","type":"structure","members":{"ScheduleActions":{"shape":"S4","locationName":"scheduleActions"}},"required":["ScheduleActions"]},"Deletes":{"locationName":"deletes","type":"structure","members":{"ScheduleActions":{"shape":"S4","locationName":"scheduleActions"}},"required":["ScheduleActions"]}}}},"CreateChannel":{"http":{"requestUri":"/prod/channels","responseCode":201},"input":{"type":"structure","members":{"ChannelClass":{"locationName":"channelClass"},"Destinations":{"shape":"S1k","locationName":"destinations"},"EncoderSettings":{"shape":"S1s","locationName":"encoderSettings"},"InputAttachments":{"shape":"Sau","locationName":"inputAttachments"},"InputSpecification":{"shape":"Sc0","locationName":"inputSpecification"},"LogLevel":{"locationName":"logLevel"},"Name":{"locationName":"name"},"RequestId":{"locationName":"requestId","idempotencyToken":true},"Reserved":{"locationName":"reserved","deprecated":true},"RoleArn":{"locationName":"roleArn"},"Tags":{"shape":"Sc5","locationName":"tags"}}},"output":{"type":"structure","members":{"Channel":{"shape":"Sc7","locationName":"channel"}}}},"CreateInput":{"http":{"requestUri":"/prod/inputs","responseCode":201},"input":{"type":"structure","members":{"Destinations":{"shape":"Sce","locationName":"destinations"},"InputDevices":{"shape":"Scg","locationName":"inputDevices"},"InputSecurityGroups":{"shape":"Sf","locationName":"inputSecurityGroups"},"MediaConnectFlows":{"shape":"Sci","locationName":"mediaConnectFlows"},"Name":{"locationName":"name"},"RequestId":{"locationName":"requestId","idempotencyToken":true},"RoleArn":{"locationName":"roleArn"},"Sources":{"shape":"Sck","locationName":"sources"},"Tags":{"shape":"Sc5","locationName":"tags"},"Type":{"locationName":"type"},"Vpc":{"locationName":"vpc","type":"structure","members":{"SecurityGroupIds":{"shape":"Sf","locationName":"securityGroupIds"},"SubnetIds":{"shape":"Sf","locationName":"subnetIds"}},"required":["SubnetIds"]}}},"output":{"type":"structure","members":{"Input":{"shape":"Scp","locationName":"input"}}}},"CreateInputSecurityGroup":{"http":{"requestUri":"/prod/inputSecurityGroups","responseCode":200},"input":{"type":"structure","members":{"Tags":{"shape":"Sc5","locationName":"tags"},"WhitelistRules":{"shape":"Sd1","locationName":"whitelistRules"}}},"output":{"type":"structure","members":{"SecurityGroup":{"shape":"Sd4","locationName":"securityGroup"}}}},"CreateMultiplex":{"http":{"requestUri":"/prod/multiplexes","responseCode":201},"input":{"type":"structure","members":{"AvailabilityZones":{"shape":"Sf","locationName":"availabilityZones"},"MultiplexSettings":{"shape":"Sd9","locationName":"multiplexSettings"},"Name":{"locationName":"name"},"RequestId":{"locationName":"requestId","idempotencyToken":true},"Tags":{"shape":"Sc5","locationName":"tags"}},"required":["RequestId","MultiplexSettings","AvailabilityZones","Name"]},"output":{"type":"structure","members":{"Multiplex":{"shape":"Sde","locationName":"multiplex"}}}},"CreateMultiplexProgram":{"http":{"requestUri":"/prod/multiplexes/{multiplexId}/programs","responseCode":201},"input":{"type":"structure","members":{"MultiplexId":{"location":"uri","locationName":"multiplexId"},"MultiplexProgramSettings":{"shape":"Sdk","locationName":"multiplexProgramSettings"},"ProgramName":{"locationName":"programName"},"RequestId":{"locationName":"requestId","idempotencyToken":true}},"required":["MultiplexId","RequestId","MultiplexProgramSettings","ProgramName"]},"output":{"type":"structure","members":{"MultiplexProgram":{"shape":"Sds","locationName":"multiplexProgram"}}}},"CreateTags":{"http":{"requestUri":"/prod/tags/{resource-arn}","responseCode":204},"input":{"type":"structure","members":{"ResourceArn":{"location":"uri","locationName":"resource-arn"},"Tags":{"shape":"Sc5","locationName":"tags"}},"required":["ResourceArn"]}},"DeleteChannel":{"http":{"method":"DELETE","requestUri":"/prod/channels/{channelId}","responseCode":200},"input":{"type":"structure","members":{"ChannelId":{"location":"uri","locationName":"channelId"}},"required":["ChannelId"]},"output":{"type":"structure","members":{"Arn":{"locationName":"arn"},"ChannelClass":{"locationName":"channelClass"},"Destinations":{"shape":"S1k","locationName":"destinations"},"EgressEndpoints":{"shape":"Sc8","locationName":"egressEndpoints"},"EncoderSettings":{"shape":"S1s","locationName":"encoderSettings"},"Id":{"locationName":"id"},"InputAttachments":{"shape":"Sau","locationName":"inputAttachments"},"InputSpecification":{"shape":"Sc0","locationName":"inputSpecification"},"LogLevel":{"locationName":"logLevel"},"Name":{"locationName":"name"},"PipelineDetails":{"shape":"Sca","locationName":"pipelineDetails"},"PipelinesRunningCount":{"locationName":"pipelinesRunningCount","type":"integer"},"RoleArn":{"locationName":"roleArn"},"State":{"locationName":"state"},"Tags":{"shape":"Sc5","locationName":"tags"}}}},"DeleteInput":{"http":{"method":"DELETE","requestUri":"/prod/inputs/{inputId}","responseCode":200},"input":{"type":"structure","members":{"InputId":{"location":"uri","locationName":"inputId"}},"required":["InputId"]},"output":{"type":"structure","members":{}}},"DeleteInputSecurityGroup":{"http":{"method":"DELETE","requestUri":"/prod/inputSecurityGroups/{inputSecurityGroupId}","responseCode":200},"input":{"type":"structure","members":{"InputSecurityGroupId":{"location":"uri","locationName":"inputSecurityGroupId"}},"required":["InputSecurityGroupId"]},"output":{"type":"structure","members":{}}},"DeleteMultiplex":{"http":{"method":"DELETE","requestUri":"/prod/multiplexes/{multiplexId}","responseCode":202},"input":{"type":"structure","members":{"MultiplexId":{"location":"uri","locationName":"multiplexId"}},"required":["MultiplexId"]},"output":{"type":"structure","members":{"Arn":{"locationName":"arn"},"AvailabilityZones":{"shape":"Sf","locationName":"availabilityZones"},"Destinations":{"shape":"Sdf","locationName":"destinations"},"Id":{"locationName":"id"},"MultiplexSettings":{"shape":"Sd9","locationName":"multiplexSettings"},"Name":{"locationName":"name"},"PipelinesRunningCount":{"locationName":"pipelinesRunningCount","type":"integer"},"ProgramCount":{"locationName":"programCount","type":"integer"},"State":{"locationName":"state"},"Tags":{"shape":"Sc5","locationName":"tags"}}}},"DeleteMultiplexProgram":{"http":{"method":"DELETE","requestUri":"/prod/multiplexes/{multiplexId}/programs/{programName}","responseCode":200},"input":{"type":"structure","members":{"MultiplexId":{"location":"uri","locationName":"multiplexId"},"ProgramName":{"location":"uri","locationName":"programName"}},"required":["MultiplexId","ProgramName"]},"output":{"type":"structure","members":{"ChannelId":{"locationName":"channelId"},"MultiplexProgramSettings":{"shape":"Sdk","locationName":"multiplexProgramSettings"},"PacketIdentifiersMap":{"shape":"Sdt","locationName":"packetIdentifiersMap"},"ProgramName":{"locationName":"programName"}}}},"DeleteReservation":{"http":{"method":"DELETE","requestUri":"/prod/reservations/{reservationId}","responseCode":200},"input":{"type":"structure","members":{"ReservationId":{"location":"uri","locationName":"reservationId"}},"required":["ReservationId"]},"output":{"type":"structure","members":{"Arn":{"locationName":"arn"},"Count":{"locationName":"count","type":"integer"},"CurrencyCode":{"locationName":"currencyCode"},"Duration":{"locationName":"duration","type":"integer"},"DurationUnits":{"locationName":"durationUnits"},"End":{"locationName":"end"},"FixedPrice":{"locationName":"fixedPrice","type":"double"},"Name":{"locationName":"name"},"OfferingDescription":{"locationName":"offeringDescription"},"OfferingId":{"locationName":"offeringId"},"OfferingType":{"locationName":"offeringType"},"Region":{"locationName":"region"},"ReservationId":{"locationName":"reservationId"},"ResourceSpecification":{"shape":"Sea","locationName":"resourceSpecification"},"Start":{"locationName":"start"},"State":{"locationName":"state"},"Tags":{"shape":"Sc5","locationName":"tags"},"UsagePrice":{"locationName":"usagePrice","type":"double"}}}},"DeleteSchedule":{"http":{"method":"DELETE","requestUri":"/prod/channels/{channelId}/schedule","responseCode":200},"input":{"type":"structure","members":{"ChannelId":{"location":"uri","locationName":"channelId"}},"required":["ChannelId"]},"output":{"type":"structure","members":{}}},"DeleteTags":{"http":{"method":"DELETE","requestUri":"/prod/tags/{resource-arn}","responseCode":204},"input":{"type":"structure","members":{"ResourceArn":{"location":"uri","locationName":"resource-arn"},"TagKeys":{"shape":"Sf","location":"querystring","locationName":"tagKeys"}},"required":["TagKeys","ResourceArn"]}},"DescribeChannel":{"http":{"method":"GET","requestUri":"/prod/channels/{channelId}","responseCode":200},"input":{"type":"structure","members":{"ChannelId":{"location":"uri","locationName":"channelId"}},"required":["ChannelId"]},"output":{"type":"structure","members":{"Arn":{"locationName":"arn"},"ChannelClass":{"locationName":"channelClass"},"Destinations":{"shape":"S1k","locationName":"destinations"},"EgressEndpoints":{"shape":"Sc8","locationName":"egressEndpoints"},"EncoderSettings":{"shape":"S1s","locationName":"encoderSettings"},"Id":{"locationName":"id"},"InputAttachments":{"shape":"Sau","locationName":"inputAttachments"},"InputSpecification":{"shape":"Sc0","locationName":"inputSpecification"},"LogLevel":{"locationName":"logLevel"},"Name":{"locationName":"name"},"PipelineDetails":{"shape":"Sca","locationName":"pipelineDetails"},"PipelinesRunningCount":{"locationName":"pipelinesRunningCount","type":"integer"},"RoleArn":{"locationName":"roleArn"},"State":{"locationName":"state"},"Tags":{"shape":"Sc5","locationName":"tags"}}}},"DescribeInput":{"http":{"method":"GET","requestUri":"/prod/inputs/{inputId}","responseCode":200},"input":{"type":"structure","members":{"InputId":{"location":"uri","locationName":"inputId"}},"required":["InputId"]},"output":{"type":"structure","members":{"Arn":{"locationName":"arn"},"AttachedChannels":{"shape":"Sf","locationName":"attachedChannels"},"Destinations":{"shape":"Scq","locationName":"destinations"},"Id":{"locationName":"id"},"InputClass":{"locationName":"inputClass"},"InputDevices":{"shape":"Scg","locationName":"inputDevices"},"InputSourceType":{"locationName":"inputSourceType"},"MediaConnectFlows":{"shape":"Scv","locationName":"mediaConnectFlows"},"Name":{"locationName":"name"},"RoleArn":{"locationName":"roleArn"},"SecurityGroups":{"shape":"Sf","locationName":"securityGroups"},"Sources":{"shape":"Scx","locationName":"sources"},"State":{"locationName":"state"},"Tags":{"shape":"Sc5","locationName":"tags"},"Type":{"locationName":"type"}}}},"DescribeInputDevice":{"http":{"method":"GET","requestUri":"/prod/inputDevices/{inputDeviceId}","responseCode":200},"input":{"type":"structure","members":{"InputDeviceId":{"location":"uri","locationName":"inputDeviceId"}},"required":["InputDeviceId"]},"output":{"type":"structure","members":{"Arn":{"locationName":"arn"},"ConnectionState":{"locationName":"connectionState"},"DeviceSettingsSyncState":{"locationName":"deviceSettingsSyncState"},"HdDeviceSettings":{"shape":"Seu","locationName":"hdDeviceSettings"},"Id":{"locationName":"id"},"MacAddress":{"locationName":"macAddress"},"Name":{"locationName":"name"},"NetworkSettings":{"shape":"Sez","locationName":"networkSettings"},"SerialNumber":{"locationName":"serialNumber"},"Type":{"locationName":"type"}}}},"DescribeInputDeviceThumbnail":{"http":{"method":"GET","requestUri":"/prod/inputDevices/{inputDeviceId}/thumbnailData","responseCode":200},"input":{"type":"structure","members":{"InputDeviceId":{"location":"uri","locationName":"inputDeviceId"},"Accept":{"location":"header","locationName":"accept"}},"required":["InputDeviceId","Accept"]},"output":{"type":"structure","members":{"Body":{"locationName":"body","type":"blob","streaming":true,"description":"The binary data for the thumbnail that the Link device has most recently sent to MediaLive."},"ContentType":{"location":"header","locationName":"Content-Type"},"ContentLength":{"location":"header","locationName":"Content-Length","type":"long"},"ETag":{"location":"header","locationName":"ETag"},"LastModified":{"location":"header","locationName":"Last-Modified","type":"timestamp"}},"payload":"Body"}},"DescribeInputSecurityGroup":{"http":{"method":"GET","requestUri":"/prod/inputSecurityGroups/{inputSecurityGroupId}","responseCode":200},"input":{"type":"structure","members":{"InputSecurityGroupId":{"location":"uri","locationName":"inputSecurityGroupId"}},"required":["InputSecurityGroupId"]},"output":{"type":"structure","members":{"Arn":{"locationName":"arn"},"Id":{"locationName":"id"},"Inputs":{"shape":"Sf","locationName":"inputs"},"State":{"locationName":"state"},"Tags":{"shape":"Sc5","locationName":"tags"},"WhitelistRules":{"shape":"Sd6","locationName":"whitelistRules"}}}},"DescribeMultiplex":{"http":{"method":"GET","requestUri":"/prod/multiplexes/{multiplexId}","responseCode":200},"input":{"type":"structure","members":{"MultiplexId":{"location":"uri","locationName":"multiplexId"}},"required":["MultiplexId"]},"output":{"type":"structure","members":{"Arn":{"locationName":"arn"},"AvailabilityZones":{"shape":"Sf","locationName":"availabilityZones"},"Destinations":{"shape":"Sdf","locationName":"destinations"},"Id":{"locationName":"id"},"MultiplexSettings":{"shape":"Sd9","locationName":"multiplexSettings"},"Name":{"locationName":"name"},"PipelinesRunningCount":{"locationName":"pipelinesRunningCount","type":"integer"},"ProgramCount":{"locationName":"programCount","type":"integer"},"State":{"locationName":"state"},"Tags":{"shape":"Sc5","locationName":"tags"}}}},"DescribeMultiplexProgram":{"http":{"method":"GET","requestUri":"/prod/multiplexes/{multiplexId}/programs/{programName}","responseCode":200},"input":{"type":"structure","members":{"MultiplexId":{"location":"uri","locationName":"multiplexId"},"ProgramName":{"location":"uri","locationName":"programName"}},"required":["MultiplexId","ProgramName"]},"output":{"type":"structure","members":{"ChannelId":{"locationName":"channelId"},"MultiplexProgramSettings":{"shape":"Sdk","locationName":"multiplexProgramSettings"},"PacketIdentifiersMap":{"shape":"Sdt","locationName":"packetIdentifiersMap"},"ProgramName":{"locationName":"programName"}}}},"DescribeOffering":{"http":{"method":"GET","requestUri":"/prod/offerings/{offeringId}","responseCode":200},"input":{"type":"structure","members":{"OfferingId":{"location":"uri","locationName":"offeringId"}},"required":["OfferingId"]},"output":{"type":"structure","members":{"Arn":{"locationName":"arn"},"CurrencyCode":{"locationName":"currencyCode"},"Duration":{"locationName":"duration","type":"integer"},"DurationUnits":{"locationName":"durationUnits"},"FixedPrice":{"locationName":"fixedPrice","type":"double"},"OfferingDescription":{"locationName":"offeringDescription"},"OfferingId":{"locationName":"offeringId"},"OfferingType":{"locationName":"offeringType"},"Region":{"locationName":"region"},"ResourceSpecification":{"shape":"Sea","locationName":"resourceSpecification"},"UsagePrice":{"locationName":"usagePrice","type":"double"}}}},"DescribeReservation":{"http":{"method":"GET","requestUri":"/prod/reservations/{reservationId}","responseCode":200},"input":{"type":"structure","members":{"ReservationId":{"location":"uri","locationName":"reservationId"}},"required":["ReservationId"]},"output":{"type":"structure","members":{"Arn":{"locationName":"arn"},"Count":{"locationName":"count","type":"integer"},"CurrencyCode":{"locationName":"currencyCode"},"Duration":{"locationName":"duration","type":"integer"},"DurationUnits":{"locationName":"durationUnits"},"End":{"locationName":"end"},"FixedPrice":{"locationName":"fixedPrice","type":"double"},"Name":{"locationName":"name"},"OfferingDescription":{"locationName":"offeringDescription"},"OfferingId":{"locationName":"offeringId"},"OfferingType":{"locationName":"offeringType"},"Region":{"locationName":"region"},"ReservationId":{"locationName":"reservationId"},"ResourceSpecification":{"shape":"Sea","locationName":"resourceSpecification"},"Start":{"locationName":"start"},"State":{"locationName":"state"},"Tags":{"shape":"Sc5","locationName":"tags"},"UsagePrice":{"locationName":"usagePrice","type":"double"}}}},"DescribeSchedule":{"http":{"method":"GET","requestUri":"/prod/channels/{channelId}/schedule","responseCode":200},"input":{"type":"structure","members":{"ChannelId":{"location":"uri","locationName":"channelId"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}},"required":["ChannelId"]},"output":{"type":"structure","members":{"NextToken":{"locationName":"nextToken"},"ScheduleActions":{"shape":"S4","locationName":"scheduleActions"}}}},"ListChannels":{"http":{"method":"GET","requestUri":"/prod/channels","responseCode":200},"input":{"type":"structure","members":{"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"Channels":{"locationName":"channels","type":"list","member":{"type":"structure","members":{"Arn":{"locationName":"arn"},"ChannelClass":{"locationName":"channelClass"},"Destinations":{"shape":"S1k","locationName":"destinations"},"EgressEndpoints":{"shape":"Sc8","locationName":"egressEndpoints"},"Id":{"locationName":"id"},"InputAttachments":{"shape":"Sau","locationName":"inputAttachments"},"InputSpecification":{"shape":"Sc0","locationName":"inputSpecification"},"LogLevel":{"locationName":"logLevel"},"Name":{"locationName":"name"},"PipelinesRunningCount":{"locationName":"pipelinesRunningCount","type":"integer"},"RoleArn":{"locationName":"roleArn"},"State":{"locationName":"state"},"Tags":{"shape":"Sc5","locationName":"tags"}}}},"NextToken":{"locationName":"nextToken"}}}},"ListInputDevices":{"http":{"method":"GET","requestUri":"/prod/inputDevices","responseCode":200},"input":{"type":"structure","members":{"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"InputDevices":{"locationName":"inputDevices","type":"list","member":{"type":"structure","members":{"Arn":{"locationName":"arn"},"ConnectionState":{"locationName":"connectionState"},"DeviceSettingsSyncState":{"locationName":"deviceSettingsSyncState"},"HdDeviceSettings":{"shape":"Seu","locationName":"hdDeviceSettings"},"Id":{"locationName":"id"},"MacAddress":{"locationName":"macAddress"},"Name":{"locationName":"name"},"NetworkSettings":{"shape":"Sez","locationName":"networkSettings"},"SerialNumber":{"locationName":"serialNumber"},"Type":{"locationName":"type"}}}},"NextToken":{"locationName":"nextToken"}}}},"ListInputSecurityGroups":{"http":{"method":"GET","requestUri":"/prod/inputSecurityGroups","responseCode":200},"input":{"type":"structure","members":{"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"InputSecurityGroups":{"locationName":"inputSecurityGroups","type":"list","member":{"shape":"Sd4"}},"NextToken":{"locationName":"nextToken"}}}},"ListInputs":{"http":{"method":"GET","requestUri":"/prod/inputs","responseCode":200},"input":{"type":"structure","members":{"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"Inputs":{"locationName":"inputs","type":"list","member":{"shape":"Scp"}},"NextToken":{"locationName":"nextToken"}}}},"ListMultiplexPrograms":{"http":{"method":"GET","requestUri":"/prod/multiplexes/{multiplexId}/programs","responseCode":200},"input":{"type":"structure","members":{"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"MultiplexId":{"location":"uri","locationName":"multiplexId"},"NextToken":{"location":"querystring","locationName":"nextToken"}},"required":["MultiplexId"]},"output":{"type":"structure","members":{"MultiplexPrograms":{"locationName":"multiplexPrograms","type":"list","member":{"type":"structure","members":{"ChannelId":{"locationName":"channelId"},"ProgramName":{"locationName":"programName"}}}},"NextToken":{"locationName":"nextToken"}}}},"ListMultiplexes":{"http":{"method":"GET","requestUri":"/prod/multiplexes","responseCode":200},"input":{"type":"structure","members":{"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"NextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"Multiplexes":{"locationName":"multiplexes","type":"list","member":{"type":"structure","members":{"Arn":{"locationName":"arn"},"AvailabilityZones":{"shape":"Sf","locationName":"availabilityZones"},"Id":{"locationName":"id"},"MultiplexSettings":{"locationName":"multiplexSettings","type":"structure","members":{"TransportStreamBitrate":{"locationName":"transportStreamBitrate","type":"integer"}}},"Name":{"locationName":"name"},"PipelinesRunningCount":{"locationName":"pipelinesRunningCount","type":"integer"},"ProgramCount":{"locationName":"programCount","type":"integer"},"State":{"locationName":"state"},"Tags":{"shape":"Sc5","locationName":"tags"}}}},"NextToken":{"locationName":"nextToken"}}}},"ListOfferings":{"http":{"method":"GET","requestUri":"/prod/offerings","responseCode":200},"input":{"type":"structure","members":{"ChannelClass":{"location":"querystring","locationName":"channelClass"},"ChannelConfiguration":{"location":"querystring","locationName":"channelConfiguration"},"Codec":{"location":"querystring","locationName":"codec"},"Duration":{"location":"querystring","locationName":"duration"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"MaximumBitrate":{"location":"querystring","locationName":"maximumBitrate"},"MaximumFramerate":{"location":"querystring","locationName":"maximumFramerate"},"NextToken":{"location":"querystring","locationName":"nextToken"},"Resolution":{"location":"querystring","locationName":"resolution"},"ResourceType":{"location":"querystring","locationName":"resourceType"},"SpecialFeature":{"location":"querystring","locationName":"specialFeature"},"VideoQuality":{"location":"querystring","locationName":"videoQuality"}}},"output":{"type":"structure","members":{"NextToken":{"locationName":"nextToken"},"Offerings":{"locationName":"offerings","type":"list","member":{"type":"structure","members":{"Arn":{"locationName":"arn"},"CurrencyCode":{"locationName":"currencyCode"},"Duration":{"locationName":"duration","type":"integer"},"DurationUnits":{"locationName":"durationUnits"},"FixedPrice":{"locationName":"fixedPrice","type":"double"},"OfferingDescription":{"locationName":"offeringDescription"},"OfferingId":{"locationName":"offeringId"},"OfferingType":{"locationName":"offeringType"},"Region":{"locationName":"region"},"ResourceSpecification":{"shape":"Sea","locationName":"resourceSpecification"},"UsagePrice":{"locationName":"usagePrice","type":"double"}}}}}}},"ListReservations":{"http":{"method":"GET","requestUri":"/prod/reservations","responseCode":200},"input":{"type":"structure","members":{"ChannelClass":{"location":"querystring","locationName":"channelClass"},"Codec":{"location":"querystring","locationName":"codec"},"MaxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"MaximumBitrate":{"location":"querystring","locationName":"maximumBitrate"},"MaximumFramerate":{"location":"querystring","locationName":"maximumFramerate"},"NextToken":{"location":"querystring","locationName":"nextToken"},"Resolution":{"location":"querystring","locationName":"resolution"},"ResourceType":{"location":"querystring","locationName":"resourceType"},"SpecialFeature":{"location":"querystring","locationName":"specialFeature"},"VideoQuality":{"location":"querystring","locationName":"videoQuality"}}},"output":{"type":"structure","members":{"NextToken":{"locationName":"nextToken"},"Reservations":{"locationName":"reservations","type":"list","member":{"shape":"Sgg"}}}}},"ListTagsForResource":{"http":{"method":"GET","requestUri":"/prod/tags/{resource-arn}","responseCode":200},"input":{"type":"structure","members":{"ResourceArn":{"location":"uri","locationName":"resource-arn"}},"required":["ResourceArn"]},"output":{"type":"structure","members":{"Tags":{"shape":"Sc5","locationName":"tags"}}}},"PurchaseOffering":{"http":{"requestUri":"/prod/offerings/{offeringId}/purchase","responseCode":201},"input":{"type":"structure","members":{"Count":{"locationName":"count","type":"integer"},"Name":{"locationName":"name"},"OfferingId":{"location":"uri","locationName":"offeringId"},"RequestId":{"locationName":"requestId","idempotencyToken":true},"Start":{"locationName":"start"},"Tags":{"shape":"Sc5","locationName":"tags"}},"required":["OfferingId","Count"]},"output":{"type":"structure","members":{"Reservation":{"shape":"Sgg","locationName":"reservation"}}}},"StartChannel":{"http":{"requestUri":"/prod/channels/{channelId}/start","responseCode":200},"input":{"type":"structure","members":{"ChannelId":{"location":"uri","locationName":"channelId"}},"required":["ChannelId"]},"output":{"type":"structure","members":{"Arn":{"locationName":"arn"},"ChannelClass":{"locationName":"channelClass"},"Destinations":{"shape":"S1k","locationName":"destinations"},"EgressEndpoints":{"shape":"Sc8","locationName":"egressEndpoints"},"EncoderSettings":{"shape":"S1s","locationName":"encoderSettings"},"Id":{"locationName":"id"},"InputAttachments":{"shape":"Sau","locationName":"inputAttachments"},"InputSpecification":{"shape":"Sc0","locationName":"inputSpecification"},"LogLevel":{"locationName":"logLevel"},"Name":{"locationName":"name"},"PipelineDetails":{"shape":"Sca","locationName":"pipelineDetails"},"PipelinesRunningCount":{"locationName":"pipelinesRunningCount","type":"integer"},"RoleArn":{"locationName":"roleArn"},"State":{"locationName":"state"},"Tags":{"shape":"Sc5","locationName":"tags"}}}},"StartMultiplex":{"http":{"requestUri":"/prod/multiplexes/{multiplexId}/start","responseCode":202},"input":{"type":"structure","members":{"MultiplexId":{"location":"uri","locationName":"multiplexId"}},"required":["MultiplexId"]},"output":{"type":"structure","members":{"Arn":{"locationName":"arn"},"AvailabilityZones":{"shape":"Sf","locationName":"availabilityZones"},"Destinations":{"shape":"Sdf","locationName":"destinations"},"Id":{"locationName":"id"},"MultiplexSettings":{"shape":"Sd9","locationName":"multiplexSettings"},"Name":{"locationName":"name"},"PipelinesRunningCount":{"locationName":"pipelinesRunningCount","type":"integer"},"ProgramCount":{"locationName":"programCount","type":"integer"},"State":{"locationName":"state"},"Tags":{"shape":"Sc5","locationName":"tags"}}}},"StopChannel":{"http":{"requestUri":"/prod/channels/{channelId}/stop","responseCode":200},"input":{"type":"structure","members":{"ChannelId":{"location":"uri","locationName":"channelId"}},"required":["ChannelId"]},"output":{"type":"structure","members":{"Arn":{"locationName":"arn"},"ChannelClass":{"locationName":"channelClass"},"Destinations":{"shape":"S1k","locationName":"destinations"},"EgressEndpoints":{"shape":"Sc8","locationName":"egressEndpoints"},"EncoderSettings":{"shape":"S1s","locationName":"encoderSettings"},"Id":{"locationName":"id"},"InputAttachments":{"shape":"Sau","locationName":"inputAttachments"},"InputSpecification":{"shape":"Sc0","locationName":"inputSpecification"},"LogLevel":{"locationName":"logLevel"},"Name":{"locationName":"name"},"PipelineDetails":{"shape":"Sca","locationName":"pipelineDetails"},"PipelinesRunningCount":{"locationName":"pipelinesRunningCount","type":"integer"},"RoleArn":{"locationName":"roleArn"},"State":{"locationName":"state"},"Tags":{"shape":"Sc5","locationName":"tags"}}}},"StopMultiplex":{"http":{"requestUri":"/prod/multiplexes/{multiplexId}/stop","responseCode":202},"input":{"type":"structure","members":{"MultiplexId":{"location":"uri","locationName":"multiplexId"}},"required":["MultiplexId"]},"output":{"type":"structure","members":{"Arn":{"locationName":"arn"},"AvailabilityZones":{"shape":"Sf","locationName":"availabilityZones"},"Destinations":{"shape":"Sdf","locationName":"destinations"},"Id":{"locationName":"id"},"MultiplexSettings":{"shape":"Sd9","locationName":"multiplexSettings"},"Name":{"locationName":"name"},"PipelinesRunningCount":{"locationName":"pipelinesRunningCount","type":"integer"},"ProgramCount":{"locationName":"programCount","type":"integer"},"State":{"locationName":"state"},"Tags":{"shape":"Sc5","locationName":"tags"}}}},"UpdateChannel":{"http":{"method":"PUT","requestUri":"/prod/channels/{channelId}","responseCode":200},"input":{"type":"structure","members":{"ChannelId":{"location":"uri","locationName":"channelId"},"Destinations":{"shape":"S1k","locationName":"destinations"},"EncoderSettings":{"shape":"S1s","locationName":"encoderSettings"},"InputAttachments":{"shape":"Sau","locationName":"inputAttachments"},"InputSpecification":{"shape":"Sc0","locationName":"inputSpecification"},"LogLevel":{"locationName":"logLevel"},"Name":{"locationName":"name"},"RoleArn":{"locationName":"roleArn"}},"required":["ChannelId"]},"output":{"type":"structure","members":{"Channel":{"shape":"Sc7","locationName":"channel"}}}},"UpdateChannelClass":{"http":{"method":"PUT","requestUri":"/prod/channels/{channelId}/channelClass","responseCode":200},"input":{"type":"structure","members":{"ChannelClass":{"locationName":"channelClass"},"ChannelId":{"location":"uri","locationName":"channelId"},"Destinations":{"shape":"S1k","locationName":"destinations"}},"required":["ChannelId","ChannelClass"]},"output":{"type":"structure","members":{"Channel":{"shape":"Sc7","locationName":"channel"}}}},"UpdateInput":{"http":{"method":"PUT","requestUri":"/prod/inputs/{inputId}","responseCode":200},"input":{"type":"structure","members":{"Destinations":{"shape":"Sce","locationName":"destinations"},"InputDevices":{"locationName":"inputDevices","type":"list","member":{"type":"structure","members":{"Id":{"locationName":"id"}}}},"InputId":{"location":"uri","locationName":"inputId"},"InputSecurityGroups":{"shape":"Sf","locationName":"inputSecurityGroups"},"MediaConnectFlows":{"shape":"Sci","locationName":"mediaConnectFlows"},"Name":{"locationName":"name"},"RoleArn":{"locationName":"roleArn"},"Sources":{"shape":"Sck","locationName":"sources"}},"required":["InputId"]},"output":{"type":"structure","members":{"Input":{"shape":"Scp","locationName":"input"}}}},"UpdateInputDevice":{"http":{"method":"PUT","requestUri":"/prod/inputDevices/{inputDeviceId}","responseCode":200},"input":{"type":"structure","members":{"HdDeviceSettings":{"locationName":"hdDeviceSettings","type":"structure","members":{"ConfiguredInput":{"locationName":"configuredInput"},"MaxBitrate":{"locationName":"maxBitrate","type":"integer"}}},"InputDeviceId":{"location":"uri","locationName":"inputDeviceId"},"Name":{"locationName":"name"}},"required":["InputDeviceId"]},"output":{"type":"structure","members":{"Arn":{"locationName":"arn"},"ConnectionState":{"locationName":"connectionState"},"DeviceSettingsSyncState":{"locationName":"deviceSettingsSyncState"},"HdDeviceSettings":{"shape":"Seu","locationName":"hdDeviceSettings"},"Id":{"locationName":"id"},"MacAddress":{"locationName":"macAddress"},"Name":{"locationName":"name"},"NetworkSettings":{"shape":"Sez","locationName":"networkSettings"},"SerialNumber":{"locationName":"serialNumber"},"Type":{"locationName":"type"}}}},"UpdateInputSecurityGroup":{"http":{"method":"PUT","requestUri":"/prod/inputSecurityGroups/{inputSecurityGroupId}","responseCode":200},"input":{"type":"structure","members":{"InputSecurityGroupId":{"location":"uri","locationName":"inputSecurityGroupId"},"Tags":{"shape":"Sc5","locationName":"tags"},"WhitelistRules":{"shape":"Sd1","locationName":"whitelistRules"}},"required":["InputSecurityGroupId"]},"output":{"type":"structure","members":{"SecurityGroup":{"shape":"Sd4","locationName":"securityGroup"}}}},"UpdateMultiplex":{"http":{"method":"PUT","requestUri":"/prod/multiplexes/{multiplexId}","responseCode":200},"input":{"type":"structure","members":{"MultiplexId":{"location":"uri","locationName":"multiplexId"},"MultiplexSettings":{"shape":"Sd9","locationName":"multiplexSettings"},"Name":{"locationName":"name"}},"required":["MultiplexId"]},"output":{"type":"structure","members":{"Multiplex":{"shape":"Sde","locationName":"multiplex"}}}},"UpdateMultiplexProgram":{"http":{"method":"PUT","requestUri":"/prod/multiplexes/{multiplexId}/programs/{programName}","responseCode":200},"input":{"type":"structure","members":{"MultiplexId":{"location":"uri","locationName":"multiplexId"},"MultiplexProgramSettings":{"shape":"Sdk","locationName":"multiplexProgramSettings"},"ProgramName":{"location":"uri","locationName":"programName"}},"required":["MultiplexId","ProgramName"]},"output":{"type":"structure","members":{"MultiplexProgram":{"shape":"Sds","locationName":"multiplexProgram"}}}},"UpdateReservation":{"http":{"method":"PUT","requestUri":"/prod/reservations/{reservationId}","responseCode":200},"input":{"type":"structure","members":{"Name":{"locationName":"name"},"ReservationId":{"location":"uri","locationName":"reservationId"}},"required":["ReservationId"]},"output":{"type":"structure","members":{"Reservation":{"shape":"Sgg","locationName":"reservation"}}}}},"shapes":{"S4":{"type":"list","member":{"type":"structure","members":{"ActionName":{"locationName":"actionName"},"ScheduleActionSettings":{"locationName":"scheduleActionSettings","type":"structure","members":{"HlsId3SegmentTaggingSettings":{"locationName":"hlsId3SegmentTaggingSettings","type":"structure","members":{"Tag":{"locationName":"tag"}},"required":["Tag"]},"HlsTimedMetadataSettings":{"locationName":"hlsTimedMetadataSettings","type":"structure","members":{"Id3":{"locationName":"id3"}},"required":["Id3"]},"InputPrepareSettings":{"locationName":"inputPrepareSettings","type":"structure","members":{"InputAttachmentNameReference":{"locationName":"inputAttachmentNameReference"},"InputClippingSettings":{"shape":"Sa","locationName":"inputClippingSettings"},"UrlPath":{"shape":"Sf","locationName":"urlPath"}}},"InputSwitchSettings":{"locationName":"inputSwitchSettings","type":"structure","members":{"InputAttachmentNameReference":{"locationName":"inputAttachmentNameReference"},"InputClippingSettings":{"shape":"Sa","locationName":"inputClippingSettings"},"UrlPath":{"shape":"Sf","locationName":"urlPath"}},"required":["InputAttachmentNameReference"]},"PauseStateSettings":{"locationName":"pauseStateSettings","type":"structure","members":{"Pipelines":{"locationName":"pipelines","type":"list","member":{"type":"structure","members":{"PipelineId":{"locationName":"pipelineId"}},"required":["PipelineId"]}}}},"Scte35ReturnToNetworkSettings":{"locationName":"scte35ReturnToNetworkSettings","type":"structure","members":{"SpliceEventId":{"locationName":"spliceEventId","type":"long"}},"required":["SpliceEventId"]},"Scte35SpliceInsertSettings":{"locationName":"scte35SpliceInsertSettings","type":"structure","members":{"Duration":{"locationName":"duration","type":"long"},"SpliceEventId":{"locationName":"spliceEventId","type":"long"}},"required":["SpliceEventId"]},"Scte35TimeSignalSettings":{"locationName":"scte35TimeSignalSettings","type":"structure","members":{"Scte35Descriptors":{"locationName":"scte35Descriptors","type":"list","member":{"type":"structure","members":{"Scte35DescriptorSettings":{"locationName":"scte35DescriptorSettings","type":"structure","members":{"SegmentationDescriptorScte35DescriptorSettings":{"locationName":"segmentationDescriptorScte35DescriptorSettings","type":"structure","members":{"DeliveryRestrictions":{"locationName":"deliveryRestrictions","type":"structure","members":{"ArchiveAllowedFlag":{"locationName":"archiveAllowedFlag"},"DeviceRestrictions":{"locationName":"deviceRestrictions"},"NoRegionalBlackoutFlag":{"locationName":"noRegionalBlackoutFlag"},"WebDeliveryAllowedFlag":{"locationName":"webDeliveryAllowedFlag"}},"required":["DeviceRestrictions","ArchiveAllowedFlag","WebDeliveryAllowedFlag","NoRegionalBlackoutFlag"]},"SegmentNum":{"locationName":"segmentNum","type":"integer"},"SegmentationCancelIndicator":{"locationName":"segmentationCancelIndicator"},"SegmentationDuration":{"locationName":"segmentationDuration","type":"long"},"SegmentationEventId":{"locationName":"segmentationEventId","type":"long"},"SegmentationTypeId":{"locationName":"segmentationTypeId","type":"integer"},"SegmentationUpid":{"locationName":"segmentationUpid"},"SegmentationUpidType":{"locationName":"segmentationUpidType","type":"integer"},"SegmentsExpected":{"locationName":"segmentsExpected","type":"integer"},"SubSegmentNum":{"locationName":"subSegmentNum","type":"integer"},"SubSegmentsExpected":{"locationName":"subSegmentsExpected","type":"integer"}},"required":["SegmentationEventId","SegmentationCancelIndicator"]}},"required":["SegmentationDescriptorScte35DescriptorSettings"]}},"required":["Scte35DescriptorSettings"]}}},"required":["Scte35Descriptors"]},"StaticImageActivateSettings":{"locationName":"staticImageActivateSettings","type":"structure","members":{"Duration":{"locationName":"duration","type":"integer"},"FadeIn":{"locationName":"fadeIn","type":"integer"},"FadeOut":{"locationName":"fadeOut","type":"integer"},"Height":{"locationName":"height","type":"integer"},"Image":{"shape":"S15","locationName":"image"},"ImageX":{"locationName":"imageX","type":"integer"},"ImageY":{"locationName":"imageY","type":"integer"},"Layer":{"locationName":"layer","type":"integer"},"Opacity":{"locationName":"opacity","type":"integer"},"Width":{"locationName":"width","type":"integer"}},"required":["Image"]},"StaticImageDeactivateSettings":{"locationName":"staticImageDeactivateSettings","type":"structure","members":{"FadeOut":{"locationName":"fadeOut","type":"integer"},"Layer":{"locationName":"layer","type":"integer"}}}}},"ScheduleActionStartSettings":{"locationName":"scheduleActionStartSettings","type":"structure","members":{"FixedModeScheduleActionStartSettings":{"locationName":"fixedModeScheduleActionStartSettings","type":"structure","members":{"Time":{"locationName":"time"}},"required":["Time"]},"FollowModeScheduleActionStartSettings":{"locationName":"followModeScheduleActionStartSettings","type":"structure","members":{"FollowPoint":{"locationName":"followPoint"},"ReferenceActionName":{"locationName":"referenceActionName"}},"required":["ReferenceActionName","FollowPoint"]},"ImmediateModeScheduleActionStartSettings":{"locationName":"immediateModeScheduleActionStartSettings","type":"structure","members":{}}}}},"required":["ActionName","ScheduleActionStartSettings","ScheduleActionSettings"]}},"Sa":{"type":"structure","members":{"InputTimecodeSource":{"locationName":"inputTimecodeSource"},"StartTimecode":{"locationName":"startTimecode","type":"structure","members":{"Timecode":{"locationName":"timecode"}}},"StopTimecode":{"locationName":"stopTimecode","type":"structure","members":{"LastFrameClippingBehavior":{"locationName":"lastFrameClippingBehavior"},"Timecode":{"locationName":"timecode"}}}},"required":["InputTimecodeSource"]},"Sf":{"type":"list","member":{}},"S15":{"type":"structure","members":{"PasswordParam":{"locationName":"passwordParam"},"Uri":{"locationName":"uri"},"Username":{"locationName":"username"}},"required":["Uri"]},"S1k":{"type":"list","member":{"type":"structure","members":{"Id":{"locationName":"id"},"MediaPackageSettings":{"locationName":"mediaPackageSettings","type":"list","member":{"type":"structure","members":{"ChannelId":{"locationName":"channelId"}}}},"MultiplexSettings":{"locationName":"multiplexSettings","type":"structure","members":{"MultiplexId":{"locationName":"multiplexId"},"ProgramName":{"locationName":"programName"}}},"Settings":{"locationName":"settings","type":"list","member":{"type":"structure","members":{"PasswordParam":{"locationName":"passwordParam"},"StreamName":{"locationName":"streamName"},"Url":{"locationName":"url"},"Username":{"locationName":"username"}}}}}}},"S1s":{"type":"structure","members":{"AudioDescriptions":{"locationName":"audioDescriptions","type":"list","member":{"type":"structure","members":{"AudioNormalizationSettings":{"locationName":"audioNormalizationSettings","type":"structure","members":{"Algorithm":{"locationName":"algorithm"},"AlgorithmControl":{"locationName":"algorithmControl"},"TargetLkfs":{"locationName":"targetLkfs","type":"double"}}},"AudioSelectorName":{"locationName":"audioSelectorName"},"AudioType":{"locationName":"audioType"},"AudioTypeControl":{"locationName":"audioTypeControl"},"CodecSettings":{"locationName":"codecSettings","type":"structure","members":{"AacSettings":{"locationName":"aacSettings","type":"structure","members":{"Bitrate":{"locationName":"bitrate","type":"double"},"CodingMode":{"locationName":"codingMode"},"InputType":{"locationName":"inputType"},"Profile":{"locationName":"profile"},"RateControlMode":{"locationName":"rateControlMode"},"RawFormat":{"locationName":"rawFormat"},"SampleRate":{"locationName":"sampleRate","type":"double"},"Spec":{"locationName":"spec"},"VbrQuality":{"locationName":"vbrQuality"}}},"Ac3Settings":{"locationName":"ac3Settings","type":"structure","members":{"Bitrate":{"locationName":"bitrate","type":"double"},"BitstreamMode":{"locationName":"bitstreamMode"},"CodingMode":{"locationName":"codingMode"},"Dialnorm":{"locationName":"dialnorm","type":"integer"},"DrcProfile":{"locationName":"drcProfile"},"LfeFilter":{"locationName":"lfeFilter"},"MetadataControl":{"locationName":"metadataControl"}}},"Eac3Settings":{"locationName":"eac3Settings","type":"structure","members":{"AttenuationControl":{"locationName":"attenuationControl"},"Bitrate":{"locationName":"bitrate","type":"double"},"BitstreamMode":{"locationName":"bitstreamMode"},"CodingMode":{"locationName":"codingMode"},"DcFilter":{"locationName":"dcFilter"},"Dialnorm":{"locationName":"dialnorm","type":"integer"},"DrcLine":{"locationName":"drcLine"},"DrcRf":{"locationName":"drcRf"},"LfeControl":{"locationName":"lfeControl"},"LfeFilter":{"locationName":"lfeFilter"},"LoRoCenterMixLevel":{"locationName":"loRoCenterMixLevel","type":"double"},"LoRoSurroundMixLevel":{"locationName":"loRoSurroundMixLevel","type":"double"},"LtRtCenterMixLevel":{"locationName":"ltRtCenterMixLevel","type":"double"},"LtRtSurroundMixLevel":{"locationName":"ltRtSurroundMixLevel","type":"double"},"MetadataControl":{"locationName":"metadataControl"},"PassthroughControl":{"locationName":"passthroughControl"},"PhaseControl":{"locationName":"phaseControl"},"StereoDownmix":{"locationName":"stereoDownmix"},"SurroundExMode":{"locationName":"surroundExMode"},"SurroundMode":{"locationName":"surroundMode"}}},"Mp2Settings":{"locationName":"mp2Settings","type":"structure","members":{"Bitrate":{"locationName":"bitrate","type":"double"},"CodingMode":{"locationName":"codingMode"},"SampleRate":{"locationName":"sampleRate","type":"double"}}},"PassThroughSettings":{"locationName":"passThroughSettings","type":"structure","members":{}}}},"LanguageCode":{"locationName":"languageCode"},"LanguageCodeControl":{"locationName":"languageCodeControl"},"Name":{"locationName":"name"},"RemixSettings":{"locationName":"remixSettings","type":"structure","members":{"ChannelMappings":{"locationName":"channelMappings","type":"list","member":{"type":"structure","members":{"InputChannelLevels":{"locationName":"inputChannelLevels","type":"list","member":{"type":"structure","members":{"Gain":{"locationName":"gain","type":"integer"},"InputChannel":{"locationName":"inputChannel","type":"integer"}},"required":["InputChannel","Gain"]}},"OutputChannel":{"locationName":"outputChannel","type":"integer"}},"required":["OutputChannel","InputChannelLevels"]}},"ChannelsIn":{"locationName":"channelsIn","type":"integer"},"ChannelsOut":{"locationName":"channelsOut","type":"integer"}},"required":["ChannelMappings"]},"StreamName":{"locationName":"streamName"}},"required":["AudioSelectorName","Name"]}},"AvailBlanking":{"locationName":"availBlanking","type":"structure","members":{"AvailBlankingImage":{"shape":"S15","locationName":"availBlankingImage"},"State":{"locationName":"state"}}},"AvailConfiguration":{"locationName":"availConfiguration","type":"structure","members":{"AvailSettings":{"locationName":"availSettings","type":"structure","members":{"Scte35SpliceInsert":{"locationName":"scte35SpliceInsert","type":"structure","members":{"AdAvailOffset":{"locationName":"adAvailOffset","type":"integer"},"NoRegionalBlackoutFlag":{"locationName":"noRegionalBlackoutFlag"},"WebDeliveryAllowedFlag":{"locationName":"webDeliveryAllowedFlag"}}},"Scte35TimeSignalApos":{"locationName":"scte35TimeSignalApos","type":"structure","members":{"AdAvailOffset":{"locationName":"adAvailOffset","type":"integer"},"NoRegionalBlackoutFlag":{"locationName":"noRegionalBlackoutFlag"},"WebDeliveryAllowedFlag":{"locationName":"webDeliveryAllowedFlag"}}}}}}},"BlackoutSlate":{"locationName":"blackoutSlate","type":"structure","members":{"BlackoutSlateImage":{"shape":"S15","locationName":"blackoutSlateImage"},"NetworkEndBlackout":{"locationName":"networkEndBlackout"},"NetworkEndBlackoutImage":{"shape":"S15","locationName":"networkEndBlackoutImage"},"NetworkId":{"locationName":"networkId"},"State":{"locationName":"state"}}},"CaptionDescriptions":{"locationName":"captionDescriptions","type":"list","member":{"type":"structure","members":{"CaptionSelectorName":{"locationName":"captionSelectorName"},"DestinationSettings":{"locationName":"destinationSettings","type":"structure","members":{"AribDestinationSettings":{"locationName":"aribDestinationSettings","type":"structure","members":{}},"BurnInDestinationSettings":{"locationName":"burnInDestinationSettings","type":"structure","members":{"Alignment":{"locationName":"alignment"},"BackgroundColor":{"locationName":"backgroundColor"},"BackgroundOpacity":{"locationName":"backgroundOpacity","type":"integer"},"Font":{"shape":"S15","locationName":"font"},"FontColor":{"locationName":"fontColor"},"FontOpacity":{"locationName":"fontOpacity","type":"integer"},"FontResolution":{"locationName":"fontResolution","type":"integer"},"FontSize":{"locationName":"fontSize"},"OutlineColor":{"locationName":"outlineColor"},"OutlineSize":{"locationName":"outlineSize","type":"integer"},"ShadowColor":{"locationName":"shadowColor"},"ShadowOpacity":{"locationName":"shadowOpacity","type":"integer"},"ShadowXOffset":{"locationName":"shadowXOffset","type":"integer"},"ShadowYOffset":{"locationName":"shadowYOffset","type":"integer"},"TeletextGridControl":{"locationName":"teletextGridControl"},"XPosition":{"locationName":"xPosition","type":"integer"},"YPosition":{"locationName":"yPosition","type":"integer"}}},"DvbSubDestinationSettings":{"locationName":"dvbSubDestinationSettings","type":"structure","members":{"Alignment":{"locationName":"alignment"},"BackgroundColor":{"locationName":"backgroundColor"},"BackgroundOpacity":{"locationName":"backgroundOpacity","type":"integer"},"Font":{"shape":"S15","locationName":"font"},"FontColor":{"locationName":"fontColor"},"FontOpacity":{"locationName":"fontOpacity","type":"integer"},"FontResolution":{"locationName":"fontResolution","type":"integer"},"FontSize":{"locationName":"fontSize"},"OutlineColor":{"locationName":"outlineColor"},"OutlineSize":{"locationName":"outlineSize","type":"integer"},"ShadowColor":{"locationName":"shadowColor"},"ShadowOpacity":{"locationName":"shadowOpacity","type":"integer"},"ShadowXOffset":{"locationName":"shadowXOffset","type":"integer"},"ShadowYOffset":{"locationName":"shadowYOffset","type":"integer"},"TeletextGridControl":{"locationName":"teletextGridControl"},"XPosition":{"locationName":"xPosition","type":"integer"},"YPosition":{"locationName":"yPosition","type":"integer"}}},"EbuTtDDestinationSettings":{"locationName":"ebuTtDDestinationSettings","type":"structure","members":{"FillLineGap":{"locationName":"fillLineGap"},"FontFamily":{"locationName":"fontFamily"},"StyleControl":{"locationName":"styleControl"}}},"EmbeddedDestinationSettings":{"locationName":"embeddedDestinationSettings","type":"structure","members":{}},"EmbeddedPlusScte20DestinationSettings":{"locationName":"embeddedPlusScte20DestinationSettings","type":"structure","members":{}},"RtmpCaptionInfoDestinationSettings":{"locationName":"rtmpCaptionInfoDestinationSettings","type":"structure","members":{}},"Scte20PlusEmbeddedDestinationSettings":{"locationName":"scte20PlusEmbeddedDestinationSettings","type":"structure","members":{}},"Scte27DestinationSettings":{"locationName":"scte27DestinationSettings","type":"structure","members":{}},"SmpteTtDestinationSettings":{"locationName":"smpteTtDestinationSettings","type":"structure","members":{}},"TeletextDestinationSettings":{"locationName":"teletextDestinationSettings","type":"structure","members":{}},"TtmlDestinationSettings":{"locationName":"ttmlDestinationSettings","type":"structure","members":{"StyleControl":{"locationName":"styleControl"}}},"WebvttDestinationSettings":{"locationName":"webvttDestinationSettings","type":"structure","members":{}}}},"LanguageCode":{"locationName":"languageCode"},"LanguageDescription":{"locationName":"languageDescription"},"Name":{"locationName":"name"}},"required":["CaptionSelectorName","Name"]}},"FeatureActivations":{"locationName":"featureActivations","type":"structure","members":{"InputPrepareScheduleActions":{"locationName":"inputPrepareScheduleActions"}}},"GlobalConfiguration":{"locationName":"globalConfiguration","type":"structure","members":{"InitialAudioGain":{"locationName":"initialAudioGain","type":"integer"},"InputEndAction":{"locationName":"inputEndAction"},"InputLossBehavior":{"locationName":"inputLossBehavior","type":"structure","members":{"BlackFrameMsec":{"locationName":"blackFrameMsec","type":"integer"},"InputLossImageColor":{"locationName":"inputLossImageColor"},"InputLossImageSlate":{"shape":"S15","locationName":"inputLossImageSlate"},"InputLossImageType":{"locationName":"inputLossImageType"},"RepeatFrameMsec":{"locationName":"repeatFrameMsec","type":"integer"}}},"OutputLockingMode":{"locationName":"outputLockingMode"},"OutputTimingSource":{"locationName":"outputTimingSource"},"SupportLowFramerateInputs":{"locationName":"supportLowFramerateInputs"}}},"NielsenConfiguration":{"locationName":"nielsenConfiguration","type":"structure","members":{"DistributorId":{"locationName":"distributorId"},"NielsenPcmToId3Tagging":{"locationName":"nielsenPcmToId3Tagging"}}},"OutputGroups":{"locationName":"outputGroups","type":"list","member":{"type":"structure","members":{"Name":{"locationName":"name"},"OutputGroupSettings":{"locationName":"outputGroupSettings","type":"structure","members":{"ArchiveGroupSettings":{"locationName":"archiveGroupSettings","type":"structure","members":{"Destination":{"shape":"S57","locationName":"destination"},"RolloverInterval":{"locationName":"rolloverInterval","type":"integer"}},"required":["Destination"]},"FrameCaptureGroupSettings":{"locationName":"frameCaptureGroupSettings","type":"structure","members":{"Destination":{"shape":"S57","locationName":"destination"}},"required":["Destination"]},"HlsGroupSettings":{"locationName":"hlsGroupSettings","type":"structure","members":{"AdMarkers":{"locationName":"adMarkers","type":"list","member":{}},"BaseUrlContent":{"locationName":"baseUrlContent"},"BaseUrlContent1":{"locationName":"baseUrlContent1"},"BaseUrlManifest":{"locationName":"baseUrlManifest"},"BaseUrlManifest1":{"locationName":"baseUrlManifest1"},"CaptionLanguageMappings":{"locationName":"captionLanguageMappings","type":"list","member":{"type":"structure","members":{"CaptionChannel":{"locationName":"captionChannel","type":"integer"},"LanguageCode":{"locationName":"languageCode"},"LanguageDescription":{"locationName":"languageDescription"}},"required":["LanguageCode","LanguageDescription","CaptionChannel"]}},"CaptionLanguageSetting":{"locationName":"captionLanguageSetting"},"ClientCache":{"locationName":"clientCache"},"CodecSpecification":{"locationName":"codecSpecification"},"ConstantIv":{"locationName":"constantIv"},"Destination":{"shape":"S57","locationName":"destination"},"DirectoryStructure":{"locationName":"directoryStructure"},"EncryptionType":{"locationName":"encryptionType"},"HlsCdnSettings":{"locationName":"hlsCdnSettings","type":"structure","members":{"HlsAkamaiSettings":{"locationName":"hlsAkamaiSettings","type":"structure","members":{"ConnectionRetryInterval":{"locationName":"connectionRetryInterval","type":"integer"},"FilecacheDuration":{"locationName":"filecacheDuration","type":"integer"},"HttpTransferMode":{"locationName":"httpTransferMode"},"NumRetries":{"locationName":"numRetries","type":"integer"},"RestartDelay":{"locationName":"restartDelay","type":"integer"},"Salt":{"locationName":"salt"},"Token":{"locationName":"token"}}},"HlsBasicPutSettings":{"locationName":"hlsBasicPutSettings","type":"structure","members":{"ConnectionRetryInterval":{"locationName":"connectionRetryInterval","type":"integer"},"FilecacheDuration":{"locationName":"filecacheDuration","type":"integer"},"NumRetries":{"locationName":"numRetries","type":"integer"},"RestartDelay":{"locationName":"restartDelay","type":"integer"}}},"HlsMediaStoreSettings":{"locationName":"hlsMediaStoreSettings","type":"structure","members":{"ConnectionRetryInterval":{"locationName":"connectionRetryInterval","type":"integer"},"FilecacheDuration":{"locationName":"filecacheDuration","type":"integer"},"MediaStoreStorageClass":{"locationName":"mediaStoreStorageClass"},"NumRetries":{"locationName":"numRetries","type":"integer"},"RestartDelay":{"locationName":"restartDelay","type":"integer"}}},"HlsWebdavSettings":{"locationName":"hlsWebdavSettings","type":"structure","members":{"ConnectionRetryInterval":{"locationName":"connectionRetryInterval","type":"integer"},"FilecacheDuration":{"locationName":"filecacheDuration","type":"integer"},"HttpTransferMode":{"locationName":"httpTransferMode"},"NumRetries":{"locationName":"numRetries","type":"integer"},"RestartDelay":{"locationName":"restartDelay","type":"integer"}}}}},"HlsId3SegmentTagging":{"locationName":"hlsId3SegmentTagging"},"IFrameOnlyPlaylists":{"locationName":"iFrameOnlyPlaylists"},"IndexNSegments":{"locationName":"indexNSegments","type":"integer"},"InputLossAction":{"locationName":"inputLossAction"},"IvInManifest":{"locationName":"ivInManifest"},"IvSource":{"locationName":"ivSource"},"KeepSegments":{"locationName":"keepSegments","type":"integer"},"KeyFormat":{"locationName":"keyFormat"},"KeyFormatVersions":{"locationName":"keyFormatVersions"},"KeyProviderSettings":{"locationName":"keyProviderSettings","type":"structure","members":{"StaticKeySettings":{"locationName":"staticKeySettings","type":"structure","members":{"KeyProviderServer":{"shape":"S15","locationName":"keyProviderServer"},"StaticKeyValue":{"locationName":"staticKeyValue"}},"required":["StaticKeyValue"]}}},"ManifestCompression":{"locationName":"manifestCompression"},"ManifestDurationFormat":{"locationName":"manifestDurationFormat"},"MinSegmentLength":{"locationName":"minSegmentLength","type":"integer"},"Mode":{"locationName":"mode"},"OutputSelection":{"locationName":"outputSelection"},"ProgramDateTime":{"locationName":"programDateTime"},"ProgramDateTimePeriod":{"locationName":"programDateTimePeriod","type":"integer"},"RedundantManifest":{"locationName":"redundantManifest"},"SegmentLength":{"locationName":"segmentLength","type":"integer"},"SegmentationMode":{"locationName":"segmentationMode"},"SegmentsPerSubdirectory":{"locationName":"segmentsPerSubdirectory","type":"integer"},"StreamInfResolution":{"locationName":"streamInfResolution"},"TimedMetadataId3Frame":{"locationName":"timedMetadataId3Frame"},"TimedMetadataId3Period":{"locationName":"timedMetadataId3Period","type":"integer"},"TimestampDeltaMilliseconds":{"locationName":"timestampDeltaMilliseconds","type":"integer"},"TsFileMode":{"locationName":"tsFileMode"}},"required":["Destination"]},"MediaPackageGroupSettings":{"locationName":"mediaPackageGroupSettings","type":"structure","members":{"Destination":{"shape":"S57","locationName":"destination"}},"required":["Destination"]},"MsSmoothGroupSettings":{"locationName":"msSmoothGroupSettings","type":"structure","members":{"AcquisitionPointId":{"locationName":"acquisitionPointId"},"AudioOnlyTimecodeControl":{"locationName":"audioOnlyTimecodeControl"},"CertificateMode":{"locationName":"certificateMode"},"ConnectionRetryInterval":{"locationName":"connectionRetryInterval","type":"integer"},"Destination":{"shape":"S57","locationName":"destination"},"EventId":{"locationName":"eventId"},"EventIdMode":{"locationName":"eventIdMode"},"EventStopBehavior":{"locationName":"eventStopBehavior"},"FilecacheDuration":{"locationName":"filecacheDuration","type":"integer"},"FragmentLength":{"locationName":"fragmentLength","type":"integer"},"InputLossAction":{"locationName":"inputLossAction"},"NumRetries":{"locationName":"numRetries","type":"integer"},"RestartDelay":{"locationName":"restartDelay","type":"integer"},"SegmentationMode":{"locationName":"segmentationMode"},"SendDelayMs":{"locationName":"sendDelayMs","type":"integer"},"SparseTrackType":{"locationName":"sparseTrackType"},"StreamManifestBehavior":{"locationName":"streamManifestBehavior"},"TimestampOffset":{"locationName":"timestampOffset"},"TimestampOffsetMode":{"locationName":"timestampOffsetMode"}},"required":["Destination"]},"MultiplexGroupSettings":{"locationName":"multiplexGroupSettings","type":"structure","members":{}},"RtmpGroupSettings":{"locationName":"rtmpGroupSettings","type":"structure","members":{"AuthenticationScheme":{"locationName":"authenticationScheme"},"CacheFullBehavior":{"locationName":"cacheFullBehavior"},"CacheLength":{"locationName":"cacheLength","type":"integer"},"CaptionData":{"locationName":"captionData"},"InputLossAction":{"locationName":"inputLossAction"},"RestartDelay":{"locationName":"restartDelay","type":"integer"}}},"UdpGroupSettings":{"locationName":"udpGroupSettings","type":"structure","members":{"InputLossAction":{"locationName":"inputLossAction"},"TimedMetadataId3Frame":{"locationName":"timedMetadataId3Frame"},"TimedMetadataId3Period":{"locationName":"timedMetadataId3Period","type":"integer"}}}}},"Outputs":{"locationName":"outputs","type":"list","member":{"type":"structure","members":{"AudioDescriptionNames":{"shape":"Sf","locationName":"audioDescriptionNames"},"CaptionDescriptionNames":{"shape":"Sf","locationName":"captionDescriptionNames"},"OutputName":{"locationName":"outputName"},"OutputSettings":{"locationName":"outputSettings","type":"structure","members":{"ArchiveOutputSettings":{"locationName":"archiveOutputSettings","type":"structure","members":{"ContainerSettings":{"locationName":"containerSettings","type":"structure","members":{"M2tsSettings":{"shape":"S76","locationName":"m2tsSettings"}}},"Extension":{"locationName":"extension"},"NameModifier":{"locationName":"nameModifier"}},"required":["ContainerSettings"]},"FrameCaptureOutputSettings":{"locationName":"frameCaptureOutputSettings","type":"structure","members":{"NameModifier":{"locationName":"nameModifier"}}},"HlsOutputSettings":{"locationName":"hlsOutputSettings","type":"structure","members":{"H265PackagingType":{"locationName":"h265PackagingType"},"HlsSettings":{"locationName":"hlsSettings","type":"structure","members":{"AudioOnlyHlsSettings":{"locationName":"audioOnlyHlsSettings","type":"structure","members":{"AudioGroupId":{"locationName":"audioGroupId"},"AudioOnlyImage":{"shape":"S15","locationName":"audioOnlyImage"},"AudioTrackType":{"locationName":"audioTrackType"},"SegmentType":{"locationName":"segmentType"}}},"Fmp4HlsSettings":{"locationName":"fmp4HlsSettings","type":"structure","members":{"AudioRenditionSets":{"locationName":"audioRenditionSets"},"NielsenId3Behavior":{"locationName":"nielsenId3Behavior"},"TimedMetadataBehavior":{"locationName":"timedMetadataBehavior"}}},"StandardHlsSettings":{"locationName":"standardHlsSettings","type":"structure","members":{"AudioRenditionSets":{"locationName":"audioRenditionSets"},"M3u8Settings":{"locationName":"m3u8Settings","type":"structure","members":{"AudioFramesPerPes":{"locationName":"audioFramesPerPes","type":"integer"},"AudioPids":{"locationName":"audioPids"},"EcmPid":{"locationName":"ecmPid"},"NielsenId3Behavior":{"locationName":"nielsenId3Behavior"},"PatInterval":{"locationName":"patInterval","type":"integer"},"PcrControl":{"locationName":"pcrControl"},"PcrPeriod":{"locationName":"pcrPeriod","type":"integer"},"PcrPid":{"locationName":"pcrPid"},"PmtInterval":{"locationName":"pmtInterval","type":"integer"},"PmtPid":{"locationName":"pmtPid"},"ProgramNum":{"locationName":"programNum","type":"integer"},"Scte35Behavior":{"locationName":"scte35Behavior"},"Scte35Pid":{"locationName":"scte35Pid"},"TimedMetadataBehavior":{"locationName":"timedMetadataBehavior"},"TimedMetadataPid":{"locationName":"timedMetadataPid"},"TransportStreamId":{"locationName":"transportStreamId","type":"integer"},"VideoPid":{"locationName":"videoPid"}}}},"required":["M3u8Settings"]}}},"NameModifier":{"locationName":"nameModifier"},"SegmentModifier":{"locationName":"segmentModifier"}},"required":["HlsSettings"]},"MediaPackageOutputSettings":{"locationName":"mediaPackageOutputSettings","type":"structure","members":{}},"MsSmoothOutputSettings":{"locationName":"msSmoothOutputSettings","type":"structure","members":{"H265PackagingType":{"locationName":"h265PackagingType"},"NameModifier":{"locationName":"nameModifier"}}},"MultiplexOutputSettings":{"locationName":"multiplexOutputSettings","type":"structure","members":{"Destination":{"shape":"S57","locationName":"destination"}},"required":["Destination"]},"RtmpOutputSettings":{"locationName":"rtmpOutputSettings","type":"structure","members":{"CertificateMode":{"locationName":"certificateMode"},"ConnectionRetryInterval":{"locationName":"connectionRetryInterval","type":"integer"},"Destination":{"shape":"S57","locationName":"destination"},"NumRetries":{"locationName":"numRetries","type":"integer"}},"required":["Destination"]},"UdpOutputSettings":{"locationName":"udpOutputSettings","type":"structure","members":{"BufferMsec":{"locationName":"bufferMsec","type":"integer"},"ContainerSettings":{"locationName":"containerSettings","type":"structure","members":{"M2tsSettings":{"shape":"S76","locationName":"m2tsSettings"}}},"Destination":{"shape":"S57","locationName":"destination"},"FecOutputSettings":{"locationName":"fecOutputSettings","type":"structure","members":{"ColumnDepth":{"locationName":"columnDepth","type":"integer"},"IncludeFec":{"locationName":"includeFec"},"RowLength":{"locationName":"rowLength","type":"integer"}}}},"required":["Destination","ContainerSettings"]}}},"VideoDescriptionName":{"locationName":"videoDescriptionName"}},"required":["OutputSettings"]}}},"required":["Outputs","OutputGroupSettings"]}},"TimecodeConfig":{"locationName":"timecodeConfig","type":"structure","members":{"Source":{"locationName":"source"},"SyncThreshold":{"locationName":"syncThreshold","type":"integer"}},"required":["Source"]},"VideoDescriptions":{"locationName":"videoDescriptions","type":"list","member":{"type":"structure","members":{"CodecSettings":{"locationName":"codecSettings","type":"structure","members":{"FrameCaptureSettings":{"locationName":"frameCaptureSettings","type":"structure","members":{"CaptureInterval":{"locationName":"captureInterval","type":"integer"},"CaptureIntervalUnits":{"locationName":"captureIntervalUnits"}},"required":["CaptureInterval"]},"H264Settings":{"locationName":"h264Settings","type":"structure","members":{"AdaptiveQuantization":{"locationName":"adaptiveQuantization"},"AfdSignaling":{"locationName":"afdSignaling"},"Bitrate":{"locationName":"bitrate","type":"integer"},"BufFillPct":{"locationName":"bufFillPct","type":"integer"},"BufSize":{"locationName":"bufSize","type":"integer"},"ColorMetadata":{"locationName":"colorMetadata"},"ColorSpaceSettings":{"locationName":"colorSpaceSettings","type":"structure","members":{"ColorSpacePassthroughSettings":{"shape":"S9b","locationName":"colorSpacePassthroughSettings"},"Rec601Settings":{"shape":"S9c","locationName":"rec601Settings"},"Rec709Settings":{"shape":"S9d","locationName":"rec709Settings"}}},"EntropyEncoding":{"locationName":"entropyEncoding"},"FilterSettings":{"locationName":"filterSettings","type":"structure","members":{"TemporalFilterSettings":{"shape":"S9g","locationName":"temporalFilterSettings"}}},"FixedAfd":{"locationName":"fixedAfd"},"FlickerAq":{"locationName":"flickerAq"},"ForceFieldPictures":{"locationName":"forceFieldPictures"},"FramerateControl":{"locationName":"framerateControl"},"FramerateDenominator":{"locationName":"framerateDenominator","type":"integer"},"FramerateNumerator":{"locationName":"framerateNumerator","type":"integer"},"GopBReference":{"locationName":"gopBReference"},"GopClosedCadence":{"locationName":"gopClosedCadence","type":"integer"},"GopNumBFrames":{"locationName":"gopNumBFrames","type":"integer"},"GopSize":{"locationName":"gopSize","type":"double"},"GopSizeUnits":{"locationName":"gopSizeUnits"},"Level":{"locationName":"level"},"LookAheadRateControl":{"locationName":"lookAheadRateControl"},"MaxBitrate":{"locationName":"maxBitrate","type":"integer"},"MinIInterval":{"locationName":"minIInterval","type":"integer"},"NumRefFrames":{"locationName":"numRefFrames","type":"integer"},"ParControl":{"locationName":"parControl"},"ParDenominator":{"locationName":"parDenominator","type":"integer"},"ParNumerator":{"locationName":"parNumerator","type":"integer"},"Profile":{"locationName":"profile"},"QualityLevel":{"locationName":"qualityLevel"},"QvbrQualityLevel":{"locationName":"qvbrQualityLevel","type":"integer"},"RateControlMode":{"locationName":"rateControlMode"},"ScanType":{"locationName":"scanType"},"SceneChangeDetect":{"locationName":"sceneChangeDetect"},"Slices":{"locationName":"slices","type":"integer"},"Softness":{"locationName":"softness","type":"integer"},"SpatialAq":{"locationName":"spatialAq"},"SubgopLength":{"locationName":"subgopLength"},"Syntax":{"locationName":"syntax"},"TemporalAq":{"locationName":"temporalAq"},"TimecodeInsertion":{"locationName":"timecodeInsertion"}}},"H265Settings":{"locationName":"h265Settings","type":"structure","members":{"AdaptiveQuantization":{"locationName":"adaptiveQuantization"},"AfdSignaling":{"locationName":"afdSignaling"},"AlternativeTransferFunction":{"locationName":"alternativeTransferFunction"},"Bitrate":{"locationName":"bitrate","type":"integer"},"BufSize":{"locationName":"bufSize","type":"integer"},"ColorMetadata":{"locationName":"colorMetadata"},"ColorSpaceSettings":{"locationName":"colorSpaceSettings","type":"structure","members":{"ColorSpacePassthroughSettings":{"shape":"S9b","locationName":"colorSpacePassthroughSettings"},"Hdr10Settings":{"locationName":"hdr10Settings","type":"structure","members":{"MaxCll":{"locationName":"maxCll","type":"integer"},"MaxFall":{"locationName":"maxFall","type":"integer"}}},"Rec601Settings":{"shape":"S9c","locationName":"rec601Settings"},"Rec709Settings":{"shape":"S9d","locationName":"rec709Settings"}}},"FilterSettings":{"locationName":"filterSettings","type":"structure","members":{"TemporalFilterSettings":{"shape":"S9g","locationName":"temporalFilterSettings"}}},"FixedAfd":{"locationName":"fixedAfd"},"FlickerAq":{"locationName":"flickerAq"},"FramerateDenominator":{"locationName":"framerateDenominator","type":"integer"},"FramerateNumerator":{"locationName":"framerateNumerator","type":"integer"},"GopClosedCadence":{"locationName":"gopClosedCadence","type":"integer"},"GopSize":{"locationName":"gopSize","type":"double"},"GopSizeUnits":{"locationName":"gopSizeUnits"},"Level":{"locationName":"level"},"LookAheadRateControl":{"locationName":"lookAheadRateControl"},"MaxBitrate":{"locationName":"maxBitrate","type":"integer"},"MinIInterval":{"locationName":"minIInterval","type":"integer"},"ParDenominator":{"locationName":"parDenominator","type":"integer"},"ParNumerator":{"locationName":"parNumerator","type":"integer"},"Profile":{"locationName":"profile"},"QvbrQualityLevel":{"locationName":"qvbrQualityLevel","type":"integer"},"RateControlMode":{"locationName":"rateControlMode"},"ScanType":{"locationName":"scanType"},"SceneChangeDetect":{"locationName":"sceneChangeDetect"},"Slices":{"locationName":"slices","type":"integer"},"Tier":{"locationName":"tier"},"TimecodeInsertion":{"locationName":"timecodeInsertion"}},"required":["FramerateNumerator","FramerateDenominator"]}}},"Height":{"locationName":"height","type":"integer"},"Name":{"locationName":"name"},"RespondToAfd":{"locationName":"respondToAfd"},"ScalingBehavior":{"locationName":"scalingBehavior"},"Sharpness":{"locationName":"sharpness","type":"integer"},"Width":{"locationName":"width","type":"integer"}},"required":["Name"]}}},"required":["VideoDescriptions","AudioDescriptions","OutputGroups","TimecodeConfig"]},"S57":{"type":"structure","members":{"DestinationRefId":{"locationName":"destinationRefId"}}},"S76":{"type":"structure","members":{"AbsentInputAudioBehavior":{"locationName":"absentInputAudioBehavior"},"Arib":{"locationName":"arib"},"AribCaptionsPid":{"locationName":"aribCaptionsPid"},"AribCaptionsPidControl":{"locationName":"aribCaptionsPidControl"},"AudioBufferModel":{"locationName":"audioBufferModel"},"AudioFramesPerPes":{"locationName":"audioFramesPerPes","type":"integer"},"AudioPids":{"locationName":"audioPids"},"AudioStreamType":{"locationName":"audioStreamType"},"Bitrate":{"locationName":"bitrate","type":"integer"},"BufferModel":{"locationName":"bufferModel"},"CcDescriptor":{"locationName":"ccDescriptor"},"DvbNitSettings":{"locationName":"dvbNitSettings","type":"structure","members":{"NetworkId":{"locationName":"networkId","type":"integer"},"NetworkName":{"locationName":"networkName"},"RepInterval":{"locationName":"repInterval","type":"integer"}},"required":["NetworkName","NetworkId"]},"DvbSdtSettings":{"locationName":"dvbSdtSettings","type":"structure","members":{"OutputSdt":{"locationName":"outputSdt"},"RepInterval":{"locationName":"repInterval","type":"integer"},"ServiceName":{"locationName":"serviceName"},"ServiceProviderName":{"locationName":"serviceProviderName"}}},"DvbSubPids":{"locationName":"dvbSubPids"},"DvbTdtSettings":{"locationName":"dvbTdtSettings","type":"structure","members":{"RepInterval":{"locationName":"repInterval","type":"integer"}}},"DvbTeletextPid":{"locationName":"dvbTeletextPid"},"Ebif":{"locationName":"ebif"},"EbpAudioInterval":{"locationName":"ebpAudioInterval"},"EbpLookaheadMs":{"locationName":"ebpLookaheadMs","type":"integer"},"EbpPlacement":{"locationName":"ebpPlacement"},"EcmPid":{"locationName":"ecmPid"},"EsRateInPes":{"locationName":"esRateInPes"},"EtvPlatformPid":{"locationName":"etvPlatformPid"},"EtvSignalPid":{"locationName":"etvSignalPid"},"FragmentTime":{"locationName":"fragmentTime","type":"double"},"Klv":{"locationName":"klv"},"KlvDataPids":{"locationName":"klvDataPids"},"NielsenId3Behavior":{"locationName":"nielsenId3Behavior"},"NullPacketBitrate":{"locationName":"nullPacketBitrate","type":"double"},"PatInterval":{"locationName":"patInterval","type":"integer"},"PcrControl":{"locationName":"pcrControl"},"PcrPeriod":{"locationName":"pcrPeriod","type":"integer"},"PcrPid":{"locationName":"pcrPid"},"PmtInterval":{"locationName":"pmtInterval","type":"integer"},"PmtPid":{"locationName":"pmtPid"},"ProgramNum":{"locationName":"programNum","type":"integer"},"RateMode":{"locationName":"rateMode"},"Scte27Pids":{"locationName":"scte27Pids"},"Scte35Control":{"locationName":"scte35Control"},"Scte35Pid":{"locationName":"scte35Pid"},"SegmentationMarkers":{"locationName":"segmentationMarkers"},"SegmentationStyle":{"locationName":"segmentationStyle"},"SegmentationTime":{"locationName":"segmentationTime","type":"double"},"TimedMetadataBehavior":{"locationName":"timedMetadataBehavior"},"TimedMetadataPid":{"locationName":"timedMetadataPid"},"TransportStreamId":{"locationName":"transportStreamId","type":"integer"},"VideoPid":{"locationName":"videoPid"}}},"S9b":{"type":"structure","members":{}},"S9c":{"type":"structure","members":{}},"S9d":{"type":"structure","members":{}},"S9g":{"type":"structure","members":{"PostFilterSharpening":{"locationName":"postFilterSharpening"},"Strength":{"locationName":"strength"}}},"Sau":{"type":"list","member":{"type":"structure","members":{"AutomaticInputFailoverSettings":{"locationName":"automaticInputFailoverSettings","type":"structure","members":{"InputPreference":{"locationName":"inputPreference"},"SecondaryInputId":{"locationName":"secondaryInputId"}},"required":["SecondaryInputId"]},"InputAttachmentName":{"locationName":"inputAttachmentName"},"InputId":{"locationName":"inputId"},"InputSettings":{"locationName":"inputSettings","type":"structure","members":{"AudioSelectors":{"locationName":"audioSelectors","type":"list","member":{"type":"structure","members":{"Name":{"locationName":"name"},"SelectorSettings":{"locationName":"selectorSettings","type":"structure","members":{"AudioLanguageSelection":{"locationName":"audioLanguageSelection","type":"structure","members":{"LanguageCode":{"locationName":"languageCode"},"LanguageSelectionPolicy":{"locationName":"languageSelectionPolicy"}},"required":["LanguageCode"]},"AudioPidSelection":{"locationName":"audioPidSelection","type":"structure","members":{"Pid":{"locationName":"pid","type":"integer"}},"required":["Pid"]},"AudioTrackSelection":{"locationName":"audioTrackSelection","type":"structure","members":{"Tracks":{"locationName":"tracks","type":"list","member":{"type":"structure","members":{"Track":{"locationName":"track","type":"integer"}},"required":["Track"]}}},"required":["Tracks"]}}}},"required":["Name"]}},"CaptionSelectors":{"locationName":"captionSelectors","type":"list","member":{"type":"structure","members":{"LanguageCode":{"locationName":"languageCode"},"Name":{"locationName":"name"},"SelectorSettings":{"locationName":"selectorSettings","type":"structure","members":{"AribSourceSettings":{"locationName":"aribSourceSettings","type":"structure","members":{}},"DvbSubSourceSettings":{"locationName":"dvbSubSourceSettings","type":"structure","members":{"Pid":{"locationName":"pid","type":"integer"}}},"EmbeddedSourceSettings":{"locationName":"embeddedSourceSettings","type":"structure","members":{"Convert608To708":{"locationName":"convert608To708"},"Scte20Detection":{"locationName":"scte20Detection"},"Source608ChannelNumber":{"locationName":"source608ChannelNumber","type":"integer"},"Source608TrackNumber":{"locationName":"source608TrackNumber","type":"integer"}}},"Scte20SourceSettings":{"locationName":"scte20SourceSettings","type":"structure","members":{"Convert608To708":{"locationName":"convert608To708"},"Source608ChannelNumber":{"locationName":"source608ChannelNumber","type":"integer"}}},"Scte27SourceSettings":{"locationName":"scte27SourceSettings","type":"structure","members":{"Pid":{"locationName":"pid","type":"integer"}}},"TeletextSourceSettings":{"locationName":"teletextSourceSettings","type":"structure","members":{"PageNumber":{"locationName":"pageNumber"}}}}}},"required":["Name"]}},"DeblockFilter":{"locationName":"deblockFilter"},"DenoiseFilter":{"locationName":"denoiseFilter"},"FilterStrength":{"locationName":"filterStrength","type":"integer"},"InputFilter":{"locationName":"inputFilter"},"NetworkInputSettings":{"locationName":"networkInputSettings","type":"structure","members":{"HlsInputSettings":{"locationName":"hlsInputSettings","type":"structure","members":{"Bandwidth":{"locationName":"bandwidth","type":"integer"},"BufferSegments":{"locationName":"bufferSegments","type":"integer"},"Retries":{"locationName":"retries","type":"integer"},"RetryInterval":{"locationName":"retryInterval","type":"integer"}}},"ServerValidation":{"locationName":"serverValidation"}}},"Smpte2038DataPreference":{"locationName":"smpte2038DataPreference"},"SourceEndBehavior":{"locationName":"sourceEndBehavior"},"VideoSelector":{"locationName":"videoSelector","type":"structure","members":{"ColorSpace":{"locationName":"colorSpace"},"ColorSpaceUsage":{"locationName":"colorSpaceUsage"},"SelectorSettings":{"locationName":"selectorSettings","type":"structure","members":{"VideoSelectorPid":{"locationName":"videoSelectorPid","type":"structure","members":{"Pid":{"locationName":"pid","type":"integer"}}},"VideoSelectorProgramId":{"locationName":"videoSelectorProgramId","type":"structure","members":{"ProgramId":{"locationName":"programId","type":"integer"}}}}}}}}}}}},"Sc0":{"type":"structure","members":{"Codec":{"locationName":"codec"},"MaximumBitrate":{"locationName":"maximumBitrate"},"Resolution":{"locationName":"resolution"}}},"Sc5":{"type":"map","key":{},"value":{}},"Sc7":{"type":"structure","members":{"Arn":{"locationName":"arn"},"ChannelClass":{"locationName":"channelClass"},"Destinations":{"shape":"S1k","locationName":"destinations"},"EgressEndpoints":{"shape":"Sc8","locationName":"egressEndpoints"},"EncoderSettings":{"shape":"S1s","locationName":"encoderSettings"},"Id":{"locationName":"id"},"InputAttachments":{"shape":"Sau","locationName":"inputAttachments"},"InputSpecification":{"shape":"Sc0","locationName":"inputSpecification"},"LogLevel":{"locationName":"logLevel"},"Name":{"locationName":"name"},"PipelineDetails":{"shape":"Sca","locationName":"pipelineDetails"},"PipelinesRunningCount":{"locationName":"pipelinesRunningCount","type":"integer"},"RoleArn":{"locationName":"roleArn"},"State":{"locationName":"state"},"Tags":{"shape":"Sc5","locationName":"tags"}}},"Sc8":{"type":"list","member":{"type":"structure","members":{"SourceIp":{"locationName":"sourceIp"}}}},"Sca":{"type":"list","member":{"type":"structure","members":{"ActiveInputAttachmentName":{"locationName":"activeInputAttachmentName"},"ActiveInputSwitchActionName":{"locationName":"activeInputSwitchActionName"},"PipelineId":{"locationName":"pipelineId"}}}},"Sce":{"type":"list","member":{"type":"structure","members":{"StreamName":{"locationName":"streamName"}}}},"Scg":{"type":"list","member":{"type":"structure","members":{"Id":{"locationName":"id"}}}},"Sci":{"type":"list","member":{"type":"structure","members":{"FlowArn":{"locationName":"flowArn"}}}},"Sck":{"type":"list","member":{"type":"structure","members":{"PasswordParam":{"locationName":"passwordParam"},"Url":{"locationName":"url"},"Username":{"locationName":"username"}}}},"Scp":{"type":"structure","members":{"Arn":{"locationName":"arn"},"AttachedChannels":{"shape":"Sf","locationName":"attachedChannels"},"Destinations":{"shape":"Scq","locationName":"destinations"},"Id":{"locationName":"id"},"InputClass":{"locationName":"inputClass"},"InputDevices":{"shape":"Scg","locationName":"inputDevices"},"InputSourceType":{"locationName":"inputSourceType"},"MediaConnectFlows":{"shape":"Scv","locationName":"mediaConnectFlows"},"Name":{"locationName":"name"},"RoleArn":{"locationName":"roleArn"},"SecurityGroups":{"shape":"Sf","locationName":"securityGroups"},"Sources":{"shape":"Scx","locationName":"sources"},"State":{"locationName":"state"},"Tags":{"shape":"Sc5","locationName":"tags"},"Type":{"locationName":"type"}}},"Scq":{"type":"list","member":{"type":"structure","members":{"Ip":{"locationName":"ip"},"Port":{"locationName":"port"},"Url":{"locationName":"url"},"Vpc":{"locationName":"vpc","type":"structure","members":{"AvailabilityZone":{"locationName":"availabilityZone"},"NetworkInterfaceId":{"locationName":"networkInterfaceId"}}}}}},"Scv":{"type":"list","member":{"type":"structure","members":{"FlowArn":{"locationName":"flowArn"}}}},"Scx":{"type":"list","member":{"type":"structure","members":{"PasswordParam":{"locationName":"passwordParam"},"Url":{"locationName":"url"},"Username":{"locationName":"username"}}}},"Sd1":{"type":"list","member":{"type":"structure","members":{"Cidr":{"locationName":"cidr"}}}},"Sd4":{"type":"structure","members":{"Arn":{"locationName":"arn"},"Id":{"locationName":"id"},"Inputs":{"shape":"Sf","locationName":"inputs"},"State":{"locationName":"state"},"Tags":{"shape":"Sc5","locationName":"tags"},"WhitelistRules":{"shape":"Sd6","locationName":"whitelistRules"}}},"Sd6":{"type":"list","member":{"type":"structure","members":{"Cidr":{"locationName":"cidr"}}}},"Sd9":{"type":"structure","members":{"MaximumVideoBufferDelayMilliseconds":{"locationName":"maximumVideoBufferDelayMilliseconds","type":"integer"},"TransportStreamBitrate":{"locationName":"transportStreamBitrate","type":"integer"},"TransportStreamId":{"locationName":"transportStreamId","type":"integer"},"TransportStreamReservedBitrate":{"locationName":"transportStreamReservedBitrate","type":"integer"}},"required":["TransportStreamBitrate","TransportStreamId"]},"Sde":{"type":"structure","members":{"Arn":{"locationName":"arn"},"AvailabilityZones":{"shape":"Sf","locationName":"availabilityZones"},"Destinations":{"shape":"Sdf","locationName":"destinations"},"Id":{"locationName":"id"},"MultiplexSettings":{"shape":"Sd9","locationName":"multiplexSettings"},"Name":{"locationName":"name"},"PipelinesRunningCount":{"locationName":"pipelinesRunningCount","type":"integer"},"ProgramCount":{"locationName":"programCount","type":"integer"},"State":{"locationName":"state"},"Tags":{"shape":"Sc5","locationName":"tags"}}},"Sdf":{"type":"list","member":{"type":"structure","members":{"MediaConnectSettings":{"locationName":"mediaConnectSettings","type":"structure","members":{"EntitlementArn":{"locationName":"entitlementArn"}}}}}},"Sdk":{"type":"structure","members":{"PreferredChannelPipeline":{"locationName":"preferredChannelPipeline"},"ProgramNumber":{"locationName":"programNumber","type":"integer"},"ServiceDescriptor":{"locationName":"serviceDescriptor","type":"structure","members":{"ProviderName":{"locationName":"providerName"},"ServiceName":{"locationName":"serviceName"}},"required":["ProviderName","ServiceName"]},"VideoSettings":{"locationName":"videoSettings","type":"structure","members":{"ConstantBitrate":{"locationName":"constantBitrate","type":"integer"},"StatmuxSettings":{"locationName":"statmuxSettings","type":"structure","members":{"MaximumBitrate":{"locationName":"maximumBitrate","type":"integer"},"MinimumBitrate":{"locationName":"minimumBitrate","type":"integer"}}}}}},"required":["ProgramNumber"]},"Sds":{"type":"structure","members":{"ChannelId":{"locationName":"channelId"},"MultiplexProgramSettings":{"shape":"Sdk","locationName":"multiplexProgramSettings"},"PacketIdentifiersMap":{"shape":"Sdt","locationName":"packetIdentifiersMap"},"ProgramName":{"locationName":"programName"}}},"Sdt":{"type":"structure","members":{"AudioPids":{"shape":"Sdu","locationName":"audioPids"},"DvbSubPids":{"shape":"Sdu","locationName":"dvbSubPids"},"DvbTeletextPid":{"locationName":"dvbTeletextPid","type":"integer"},"EtvPlatformPid":{"locationName":"etvPlatformPid","type":"integer"},"EtvSignalPid":{"locationName":"etvSignalPid","type":"integer"},"KlvDataPids":{"shape":"Sdu","locationName":"klvDataPids"},"PcrPid":{"locationName":"pcrPid","type":"integer"},"PmtPid":{"locationName":"pmtPid","type":"integer"},"PrivateMetadataPid":{"locationName":"privateMetadataPid","type":"integer"},"Scte27Pids":{"shape":"Sdu","locationName":"scte27Pids"},"Scte35Pid":{"locationName":"scte35Pid","type":"integer"},"TimedMetadataPid":{"locationName":"timedMetadataPid","type":"integer"},"VideoPid":{"locationName":"videoPid","type":"integer"}}},"Sdu":{"type":"list","member":{"type":"integer"}},"Sea":{"type":"structure","members":{"ChannelClass":{"locationName":"channelClass"},"Codec":{"locationName":"codec"},"MaximumBitrate":{"locationName":"maximumBitrate"},"MaximumFramerate":{"locationName":"maximumFramerate"},"Resolution":{"locationName":"resolution"},"ResourceType":{"locationName":"resourceType"},"SpecialFeature":{"locationName":"specialFeature"},"VideoQuality":{"locationName":"videoQuality"}}},"Seu":{"type":"structure","members":{"ActiveInput":{"locationName":"activeInput"},"ConfiguredInput":{"locationName":"configuredInput"},"DeviceState":{"locationName":"deviceState"},"Framerate":{"locationName":"framerate","type":"double"},"Height":{"locationName":"height","type":"integer"},"MaxBitrate":{"locationName":"maxBitrate","type":"integer"},"ScanType":{"locationName":"scanType"},"Width":{"locationName":"width","type":"integer"}}},"Sez":{"type":"structure","members":{"DnsAddresses":{"shape":"Sf","locationName":"dnsAddresses"},"Gateway":{"locationName":"gateway"},"IpAddress":{"locationName":"ipAddress"},"IpScheme":{"locationName":"ipScheme"},"SubnetMask":{"locationName":"subnetMask"}}},"Sgg":{"type":"structure","members":{"Arn":{"locationName":"arn"},"Count":{"locationName":"count","type":"integer"},"CurrencyCode":{"locationName":"currencyCode"},"Duration":{"locationName":"duration","type":"integer"},"DurationUnits":{"locationName":"durationUnits"},"End":{"locationName":"end"},"FixedPrice":{"locationName":"fixedPrice","type":"double"},"Name":{"locationName":"name"},"OfferingDescription":{"locationName":"offeringDescription"},"OfferingId":{"locationName":"offeringId"},"OfferingType":{"locationName":"offeringType"},"Region":{"locationName":"region"},"ReservationId":{"locationName":"reservationId"},"ResourceSpecification":{"shape":"Sea","locationName":"resourceSpecification"},"Start":{"locationName":"start"},"State":{"locationName":"state"},"Tags":{"shape":"Sc5","locationName":"tags"},"UsagePrice":{"locationName":"usagePrice","type":"double"}}}}}; + async dump (opts) { + let limit = Number.isFinite(opts?.limit) ? opts.limit : 128 * 1024 + const signal = opts?.signal -/***/ }), + if (signal != null && (typeof signal !== 'object' || !('aborted' in signal))) { + throw new InvalidArgumentError('signal must be an AbortSignal') + } -/***/ 4469: -/***/ (function(module, __unusedexports, __webpack_require__) { + signal?.throwIfAborted() -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; + if (this._readableState.closeEmitted) { + return null + } -apiLoader.services['workdocs'] = {}; -AWS.WorkDocs = Service.defineService('workdocs', ['2016-05-01']); -Object.defineProperty(apiLoader.services['workdocs'], '2016-05-01', { - get: function get() { - var model = __webpack_require__(6099); - model.paginators = __webpack_require__(8317).pagination; - return model; - }, - enumerable: true, - configurable: true -}); + return await new Promise((resolve, reject) => { + if (this[kContentLength] > limit) { + this.destroy(new AbortError()) + } -module.exports = AWS.WorkDocs; + const onAbort = () => { + this.destroy(signal.reason ?? new AbortError()) + } + signal?.addEventListener('abort', onAbort) + this + .on('close', function () { + signal?.removeEventListener('abort', onAbort) + if (signal?.aborted) { + reject(signal.reason ?? new AbortError()) + } else { + resolve(null) + } + }) + .on('error', noop) + .on('data', function (chunk) { + limit -= chunk.length + if (limit <= 0) { + this.destroy() + } + }) + .resume() + }) + } +} -/***/ }), +// https://streams.spec.whatwg.org/#readablestream-locked +function isLocked (self) { + // Consume is an implicit lock. + return (self[kBody] && self[kBody].locked === true) || self[kConsume] +} -/***/ 4480: -/***/ (function(module) { +// https://fetch.spec.whatwg.org/#body-unusable +function isUnusable (self) { + return util.isDisturbed(self) || isLocked(self) +} -module.exports = {"pagination":{"ListApplications":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListComponents":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListConfigurationHistory":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListLogPatternSets":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListLogPatterns":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"},"ListProblems":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"}}}; +async function consume (stream, type) { + assert(!stream[kConsume]) -/***/ }), + return new Promise((resolve, reject) => { + if (isUnusable(stream)) { + const rState = stream._readableState + if (rState.destroyed && rState.closeEmitted === false) { + stream + .on('error', err => { + reject(err) + }) + .on('close', () => { + reject(new TypeError('unusable')) + }) + } else { + reject(rState.errored ?? new TypeError('unusable')) + } + } else { + queueMicrotask(() => { + stream[kConsume] = { + type, + stream, + resolve, + reject, + length: 0, + body: [] + } -/***/ 4483: -/***/ (function(module) { + stream + .on('error', function (err) { + consumeFinish(this[kConsume], err) + }) + .on('close', function () { + if (this[kConsume].body !== null) { + consumeFinish(this[kConsume], new RequestAbortedError()) + } + }) -module.exports = {"pagination":{"ListItems":{"input_token":"NextToken","output_token":"NextToken","limit_key":"MaxResults"}}}; + consumeStart(stream[kConsume]) + }) + } + }) +} -/***/ }), +function consumeStart (consume) { + if (consume.body === null) { + return + } -/***/ 4487: -/***/ (function(module, __unusedexports, __webpack_require__) { + const { _readableState: state } = consume.stream -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; + if (state.bufferIndex) { + const start = state.bufferIndex + const end = state.buffer.length + for (let n = start; n < end; n++) { + consumePush(consume, state.buffer[n]) + } + } else { + for (const chunk of state.buffer) { + consumePush(consume, chunk) + } + } -apiLoader.services['kinesisvideomedia'] = {}; -AWS.KinesisVideoMedia = Service.defineService('kinesisvideomedia', ['2017-09-30']); -Object.defineProperty(apiLoader.services['kinesisvideomedia'], '2017-09-30', { - get: function get() { - var model = __webpack_require__(8258); - model.paginators = __webpack_require__(8784).pagination; - return model; - }, - enumerable: true, - configurable: true -}); + if (state.endEmitted) { + consumeEnd(this[kConsume]) + } else { + consume.stream.on('end', function () { + consumeEnd(this[kConsume]) + }) + } -module.exports = AWS.KinesisVideoMedia; + consume.stream.resume() + while (consume.stream.read() != null) { + // Loop + } +} -/***/ }), +/** + * @param {Buffer[]} chunks + * @param {number} length + */ +function chunksDecode (chunks, length) { + if (chunks.length === 0 || length === 0) { + return '' + } + const buffer = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks, length) + const bufferLength = buffer.length + + // Skip BOM. + const start = + bufferLength > 2 && + buffer[0] === 0xef && + buffer[1] === 0xbb && + buffer[2] === 0xbf + ? 3 + : 0 + return buffer.utf8Slice(start, bufferLength) +} -/***/ 4525: -/***/ (function(module) { +/** + * @param {Buffer[]} chunks + * @param {number} length + * @returns {Uint8Array} + */ +function chunksConcat (chunks, length) { + if (chunks.length === 0 || length === 0) { + return new Uint8Array(0) + } + if (chunks.length === 1) { + // fast-path + return new Uint8Array(chunks[0]) + } + const buffer = new Uint8Array(Buffer.allocUnsafeSlow(length).buffer) -module.exports = {"version":2,"waiters":{"DBInstanceAvailable":{"delay":30,"operation":"DescribeDBInstances","maxAttempts":60,"acceptors":[{"expected":"available","matcher":"pathAll","state":"success","argument":"DBInstances[].DBInstanceStatus"},{"expected":"deleted","matcher":"pathAny","state":"failure","argument":"DBInstances[].DBInstanceStatus"},{"expected":"deleting","matcher":"pathAny","state":"failure","argument":"DBInstances[].DBInstanceStatus"},{"expected":"failed","matcher":"pathAny","state":"failure","argument":"DBInstances[].DBInstanceStatus"},{"expected":"incompatible-restore","matcher":"pathAny","state":"failure","argument":"DBInstances[].DBInstanceStatus"},{"expected":"incompatible-parameters","matcher":"pathAny","state":"failure","argument":"DBInstances[].DBInstanceStatus"}]},"DBInstanceDeleted":{"delay":30,"operation":"DescribeDBInstances","maxAttempts":60,"acceptors":[{"expected":true,"matcher":"path","state":"success","argument":"length(DBInstances) == `0`"},{"expected":"DBInstanceNotFound","matcher":"error","state":"success"},{"expected":"creating","matcher":"pathAny","state":"failure","argument":"DBInstances[].DBInstanceStatus"},{"expected":"modifying","matcher":"pathAny","state":"failure","argument":"DBInstances[].DBInstanceStatus"},{"expected":"rebooting","matcher":"pathAny","state":"failure","argument":"DBInstances[].DBInstanceStatus"},{"expected":"resetting-master-credentials","matcher":"pathAny","state":"failure","argument":"DBInstances[].DBInstanceStatus"}]},"DBSnapshotAvailable":{"delay":30,"operation":"DescribeDBSnapshots","maxAttempts":60,"acceptors":[{"expected":"available","matcher":"pathAll","state":"success","argument":"DBSnapshots[].Status"},{"expected":"deleted","matcher":"pathAny","state":"failure","argument":"DBSnapshots[].Status"},{"expected":"deleting","matcher":"pathAny","state":"failure","argument":"DBSnapshots[].Status"},{"expected":"failed","matcher":"pathAny","state":"failure","argument":"DBSnapshots[].Status"},{"expected":"incompatible-restore","matcher":"pathAny","state":"failure","argument":"DBSnapshots[].Status"},{"expected":"incompatible-parameters","matcher":"pathAny","state":"failure","argument":"DBSnapshots[].Status"}]},"DBSnapshotDeleted":{"delay":30,"operation":"DescribeDBSnapshots","maxAttempts":60,"acceptors":[{"expected":true,"matcher":"path","state":"success","argument":"length(DBSnapshots) == `0`"},{"expected":"DBSnapshotNotFound","matcher":"error","state":"success"},{"expected":"creating","matcher":"pathAny","state":"failure","argument":"DBSnapshots[].Status"},{"expected":"modifying","matcher":"pathAny","state":"failure","argument":"DBSnapshots[].Status"},{"expected":"rebooting","matcher":"pathAny","state":"failure","argument":"DBSnapshots[].Status"},{"expected":"resetting-master-credentials","matcher":"pathAny","state":"failure","argument":"DBSnapshots[].Status"}]},"DBClusterSnapshotAvailable":{"delay":30,"operation":"DescribeDBClusterSnapshots","maxAttempts":60,"acceptors":[{"expected":"available","matcher":"pathAll","state":"success","argument":"DBClusterSnapshots[].Status"},{"expected":"deleted","matcher":"pathAny","state":"failure","argument":"DBClusterSnapshots[].Status"},{"expected":"deleting","matcher":"pathAny","state":"failure","argument":"DBClusterSnapshots[].Status"},{"expected":"failed","matcher":"pathAny","state":"failure","argument":"DBClusterSnapshots[].Status"},{"expected":"incompatible-restore","matcher":"pathAny","state":"failure","argument":"DBClusterSnapshots[].Status"},{"expected":"incompatible-parameters","matcher":"pathAny","state":"failure","argument":"DBClusterSnapshots[].Status"}]},"DBClusterSnapshotDeleted":{"delay":30,"operation":"DescribeDBClusterSnapshots","maxAttempts":60,"acceptors":[{"expected":true,"matcher":"path","state":"success","argument":"length(DBClusterSnapshots) == `0`"},{"expected":"DBClusterSnapshotNotFoundFault","matcher":"error","state":"success"},{"expected":"creating","matcher":"pathAny","state":"failure","argument":"DBClusterSnapshots[].Status"},{"expected":"modifying","matcher":"pathAny","state":"failure","argument":"DBClusterSnapshots[].Status"},{"expected":"rebooting","matcher":"pathAny","state":"failure","argument":"DBClusterSnapshots[].Status"},{"expected":"resetting-master-credentials","matcher":"pathAny","state":"failure","argument":"DBClusterSnapshots[].Status"}]}}}; + let offset = 0 + for (let i = 0; i < chunks.length; ++i) { + const chunk = chunks[i] + buffer.set(chunk, offset) + offset += chunk.length + } -/***/ }), + return buffer +} -/***/ 4535: -/***/ (function(module) { +function consumeEnd (consume) { + const { type, body, resolve, stream, length } = consume -module.exports = {"version":"2.0","metadata":{"apiVersion":"2019-02-03","endpointPrefix":"kendra","jsonVersion":"1.1","protocol":"json","serviceAbbreviation":"kendra","serviceFullName":"AWSKendraFrontendService","serviceId":"kendra","signatureVersion":"v4","signingName":"kendra","targetPrefix":"AWSKendraFrontendService","uid":"kendra-2019-02-03"},"operations":{"BatchDeleteDocument":{"input":{"type":"structure","required":["IndexId","DocumentIdList"],"members":{"IndexId":{},"DocumentIdList":{"type":"list","member":{}},"DataSourceSyncJobMetricTarget":{"type":"structure","required":["DataSourceId","DataSourceSyncJobId"],"members":{"DataSourceId":{},"DataSourceSyncJobId":{}}}}},"output":{"type":"structure","members":{"FailedDocuments":{"type":"list","member":{"type":"structure","members":{"Id":{},"ErrorCode":{},"ErrorMessage":{}}}}}}},"BatchPutDocument":{"input":{"type":"structure","required":["IndexId","Documents"],"members":{"IndexId":{},"RoleArn":{},"Documents":{"type":"list","member":{"type":"structure","required":["Id"],"members":{"Id":{},"Title":{},"Blob":{"type":"blob"},"S3Path":{"shape":"Sj"},"Attributes":{"shape":"Sm"},"AccessControlList":{"type":"list","member":{"type":"structure","required":["Name","Type","Access"],"members":{"Name":{},"Type":{},"Access":{}}}},"ContentType":{}}}}}},"output":{"type":"structure","members":{"FailedDocuments":{"type":"list","member":{"type":"structure","members":{"Id":{},"ErrorCode":{},"ErrorMessage":{}}}}}}},"CreateDataSource":{"input":{"type":"structure","required":["Name","IndexId","Type","Configuration","RoleArn"],"members":{"Name":{},"IndexId":{},"Type":{},"Configuration":{"shape":"S17"},"Description":{},"Schedule":{},"RoleArn":{},"Tags":{"shape":"S2x"}}},"output":{"type":"structure","required":["Id"],"members":{"Id":{}}}},"CreateFaq":{"input":{"type":"structure","required":["IndexId","Name","S3Path","RoleArn"],"members":{"IndexId":{},"Name":{},"Description":{},"S3Path":{"shape":"Sj"},"RoleArn":{},"Tags":{"shape":"S2x"}}},"output":{"type":"structure","members":{"Id":{}}}},"CreateIndex":{"input":{"type":"structure","required":["Name","RoleArn"],"members":{"Name":{},"Edition":{},"RoleArn":{},"ServerSideEncryptionConfiguration":{"shape":"S39"},"Description":{},"ClientToken":{"idempotencyToken":true},"Tags":{"shape":"S2x"}}},"output":{"type":"structure","members":{"Id":{}}}},"DeleteDataSource":{"input":{"type":"structure","required":["Id","IndexId"],"members":{"Id":{},"IndexId":{}}}},"DeleteFaq":{"input":{"type":"structure","required":["Id","IndexId"],"members":{"Id":{},"IndexId":{}}}},"DeleteIndex":{"input":{"type":"structure","required":["Id"],"members":{"Id":{}}}},"DescribeDataSource":{"input":{"type":"structure","required":["Id","IndexId"],"members":{"Id":{},"IndexId":{}}},"output":{"type":"structure","members":{"Id":{},"IndexId":{},"Name":{},"Type":{},"Configuration":{"shape":"S17"},"CreatedAt":{"type":"timestamp"},"UpdatedAt":{"type":"timestamp"},"Description":{},"Status":{},"Schedule":{},"RoleArn":{},"ErrorMessage":{}}}},"DescribeFaq":{"input":{"type":"structure","required":["Id","IndexId"],"members":{"Id":{},"IndexId":{}}},"output":{"type":"structure","members":{"Id":{},"IndexId":{},"Name":{},"Description":{},"CreatedAt":{"type":"timestamp"},"UpdatedAt":{"type":"timestamp"},"S3Path":{"shape":"Sj"},"Status":{},"RoleArn":{},"ErrorMessage":{}}}},"DescribeIndex":{"input":{"type":"structure","required":["Id"],"members":{"Id":{}}},"output":{"type":"structure","members":{"Name":{},"Id":{},"Edition":{},"RoleArn":{},"ServerSideEncryptionConfiguration":{"shape":"S39"},"Status":{},"Description":{},"CreatedAt":{"type":"timestamp"},"UpdatedAt":{"type":"timestamp"},"DocumentMetadataConfigurations":{"shape":"S3p"},"IndexStatistics":{"type":"structure","required":["FaqStatistics","TextDocumentStatistics"],"members":{"FaqStatistics":{"type":"structure","required":["IndexedQuestionAnswersCount"],"members":{"IndexedQuestionAnswersCount":{"type":"integer"}}},"TextDocumentStatistics":{"type":"structure","required":["IndexedTextDocumentsCount","IndexedTextBytes"],"members":{"IndexedTextDocumentsCount":{"type":"integer"},"IndexedTextBytes":{"type":"long"}}}}},"ErrorMessage":{},"CapacityUnits":{"shape":"S47"}}}},"ListDataSourceSyncJobs":{"input":{"type":"structure","required":["Id","IndexId"],"members":{"Id":{},"IndexId":{},"NextToken":{},"MaxResults":{"type":"integer"},"StartTimeFilter":{"type":"structure","members":{"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"}}},"StatusFilter":{}}},"output":{"type":"structure","members":{"History":{"type":"list","member":{"type":"structure","members":{"ExecutionId":{},"StartTime":{"type":"timestamp"},"EndTime":{"type":"timestamp"},"Status":{},"ErrorMessage":{},"ErrorCode":{},"DataSourceErrorCode":{},"Metrics":{"type":"structure","members":{"DocumentsAdded":{},"DocumentsModified":{},"DocumentsDeleted":{},"DocumentsFailed":{},"DocumentsScanned":{}}}}}},"NextToken":{}}}},"ListDataSources":{"input":{"type":"structure","required":["IndexId"],"members":{"IndexId":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"SummaryItems":{"type":"list","member":{"type":"structure","members":{"Name":{},"Id":{},"Type":{},"CreatedAt":{"type":"timestamp"},"UpdatedAt":{"type":"timestamp"},"Status":{}}}},"NextToken":{}}}},"ListFaqs":{"input":{"type":"structure","required":["IndexId"],"members":{"IndexId":{},"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"NextToken":{},"FaqSummaryItems":{"type":"list","member":{"type":"structure","members":{"Id":{},"Name":{},"Status":{},"CreatedAt":{"type":"timestamp"},"UpdatedAt":{"type":"timestamp"}}}}}}},"ListIndices":{"input":{"type":"structure","members":{"NextToken":{},"MaxResults":{"type":"integer"}}},"output":{"type":"structure","members":{"IndexConfigurationSummaryItems":{"type":"list","member":{"type":"structure","required":["CreatedAt","UpdatedAt","Status"],"members":{"Name":{},"Id":{},"Edition":{},"CreatedAt":{"type":"timestamp"},"UpdatedAt":{"type":"timestamp"},"Status":{}}}},"NextToken":{}}}},"ListTagsForResource":{"input":{"type":"structure","required":["ResourceARN"],"members":{"ResourceARN":{}}},"output":{"type":"structure","members":{"Tags":{"shape":"S2x"}}}},"Query":{"input":{"type":"structure","required":["IndexId","QueryText"],"members":{"IndexId":{},"QueryText":{},"AttributeFilter":{"shape":"S54"},"Facets":{"type":"list","member":{"type":"structure","members":{"DocumentAttributeKey":{}}}},"RequestedDocumentAttributes":{"type":"list","member":{}},"QueryResultTypeFilter":{},"PageNumber":{"type":"integer"},"PageSize":{"type":"integer"},"SortingConfiguration":{"type":"structure","required":["DocumentAttributeKey","SortOrder"],"members":{"DocumentAttributeKey":{},"SortOrder":{}}}}},"output":{"type":"structure","members":{"QueryId":{},"ResultItems":{"type":"list","member":{"type":"structure","members":{"Id":{},"Type":{},"AdditionalAttributes":{"type":"list","member":{"type":"structure","required":["Key","ValueType","Value"],"members":{"Key":{},"ValueType":{},"Value":{"type":"structure","members":{"TextWithHighlightsValue":{"shape":"S5m"}}}}}},"DocumentId":{},"DocumentTitle":{"shape":"S5m"},"DocumentExcerpt":{"shape":"S5m"},"DocumentURI":{},"DocumentAttributes":{"shape":"Sm"}}}},"FacetResults":{"type":"list","member":{"type":"structure","members":{"DocumentAttributeKey":{},"DocumentAttributeValueCountPairs":{"type":"list","member":{"type":"structure","members":{"DocumentAttributeValue":{"shape":"Sp"},"Count":{"type":"integer"}}}}}}},"TotalNumberOfResults":{"type":"integer"}}}},"StartDataSourceSyncJob":{"input":{"type":"structure","required":["Id","IndexId"],"members":{"Id":{},"IndexId":{}}},"output":{"type":"structure","members":{"ExecutionId":{}}}},"StopDataSourceSyncJob":{"input":{"type":"structure","required":["Id","IndexId"],"members":{"Id":{},"IndexId":{}}}},"SubmitFeedback":{"input":{"type":"structure","required":["IndexId","QueryId"],"members":{"IndexId":{},"QueryId":{},"ClickFeedbackItems":{"type":"list","member":{"type":"structure","required":["ResultId","ClickTime"],"members":{"ResultId":{},"ClickTime":{"type":"timestamp"}}}},"RelevanceFeedbackItems":{"type":"list","member":{"type":"structure","required":["ResultId","RelevanceValue"],"members":{"ResultId":{},"RelevanceValue":{}}}}}}},"TagResource":{"input":{"type":"structure","required":["ResourceARN","Tags"],"members":{"ResourceARN":{},"Tags":{"shape":"S2x"}}},"output":{"type":"structure","members":{}}},"UntagResource":{"input":{"type":"structure","required":["ResourceARN","TagKeys"],"members":{"ResourceARN":{},"TagKeys":{"type":"list","member":{}}}},"output":{"type":"structure","members":{}}},"UpdateDataSource":{"input":{"type":"structure","required":["Id","IndexId"],"members":{"Id":{},"Name":{},"IndexId":{},"Configuration":{"shape":"S17"},"Description":{},"Schedule":{},"RoleArn":{}}}},"UpdateIndex":{"input":{"type":"structure","required":["Id"],"members":{"Id":{},"Name":{},"RoleArn":{},"Description":{},"DocumentMetadataConfigurationUpdates":{"shape":"S3p"},"CapacityUnits":{"shape":"S47"}}}}},"shapes":{"Sj":{"type":"structure","required":["Bucket","Key"],"members":{"Bucket":{},"Key":{}}},"Sm":{"type":"list","member":{"shape":"Sn"}},"Sn":{"type":"structure","required":["Key","Value"],"members":{"Key":{},"Value":{"shape":"Sp"}}},"Sp":{"type":"structure","members":{"StringValue":{},"StringListValue":{"type":"list","member":{}},"LongValue":{"type":"long"},"DateValue":{"type":"timestamp"}}},"S17":{"type":"structure","members":{"S3Configuration":{"type":"structure","required":["BucketName"],"members":{"BucketName":{},"InclusionPrefixes":{"shape":"S19"},"ExclusionPatterns":{"shape":"S19"},"DocumentsMetadataConfiguration":{"type":"structure","members":{"S3Prefix":{}}},"AccessControlListConfiguration":{"type":"structure","members":{"KeyPath":{}}}}},"SharePointConfiguration":{"type":"structure","required":["SharePointVersion","Urls","SecretArn"],"members":{"SharePointVersion":{},"Urls":{"type":"list","member":{}},"SecretArn":{},"CrawlAttachments":{"type":"boolean"},"UseChangeLog":{"type":"boolean"},"InclusionPatterns":{"shape":"S19"},"ExclusionPatterns":{"shape":"S19"},"VpcConfiguration":{"shape":"S1j"},"FieldMappings":{"shape":"S1o"},"DocumentTitleFieldName":{}}},"DatabaseConfiguration":{"type":"structure","required":["DatabaseEngineType","ConnectionConfiguration","ColumnConfiguration"],"members":{"DatabaseEngineType":{},"ConnectionConfiguration":{"type":"structure","required":["DatabaseHost","DatabasePort","DatabaseName","TableName","SecretArn"],"members":{"DatabaseHost":{},"DatabasePort":{"type":"integer"},"DatabaseName":{},"TableName":{},"SecretArn":{}}},"VpcConfiguration":{"shape":"S1j"},"ColumnConfiguration":{"type":"structure","required":["DocumentIdColumnName","DocumentDataColumnName","ChangeDetectingColumns"],"members":{"DocumentIdColumnName":{},"DocumentDataColumnName":{},"DocumentTitleColumnName":{},"FieldMappings":{"shape":"S1o"},"ChangeDetectingColumns":{"type":"list","member":{}}}},"AclConfiguration":{"type":"structure","required":["AllowedGroupsColumnName"],"members":{"AllowedGroupsColumnName":{}}},"SqlConfiguration":{"type":"structure","members":{"QueryIdentifiersEnclosingOption":{}}}}},"SalesforceConfiguration":{"type":"structure","required":["ServerUrl","SecretArn"],"members":{"ServerUrl":{},"SecretArn":{},"StandardObjectConfigurations":{"type":"list","member":{"type":"structure","required":["Name","DocumentDataFieldName"],"members":{"Name":{},"DocumentDataFieldName":{},"DocumentTitleFieldName":{},"FieldMappings":{"shape":"S1o"}}}},"KnowledgeArticleConfiguration":{"type":"structure","required":["IncludedStates"],"members":{"IncludedStates":{"type":"list","member":{}},"StandardKnowledgeArticleTypeConfiguration":{"type":"structure","required":["DocumentDataFieldName"],"members":{"DocumentDataFieldName":{},"DocumentTitleFieldName":{},"FieldMappings":{"shape":"S1o"}}},"CustomKnowledgeArticleTypeConfigurations":{"type":"list","member":{"type":"structure","required":["Name","DocumentDataFieldName"],"members":{"Name":{},"DocumentDataFieldName":{},"DocumentTitleFieldName":{},"FieldMappings":{"shape":"S1o"}}}}}},"ChatterFeedConfiguration":{"type":"structure","required":["DocumentDataFieldName"],"members":{"DocumentDataFieldName":{},"DocumentTitleFieldName":{},"FieldMappings":{"shape":"S1o"},"IncludeFilterTypes":{"type":"list","member":{}}}},"CrawlAttachments":{"type":"boolean"},"StandardObjectAttachmentConfiguration":{"type":"structure","members":{"DocumentTitleFieldName":{},"FieldMappings":{"shape":"S1o"}}},"IncludeAttachmentFilePatterns":{"shape":"S19"},"ExcludeAttachmentFilePatterns":{"shape":"S19"}}},"OneDriveConfiguration":{"type":"structure","required":["TenantDomain","SecretArn","OneDriveUsers"],"members":{"TenantDomain":{},"SecretArn":{},"OneDriveUsers":{"type":"structure","members":{"OneDriveUserList":{"type":"list","member":{}},"OneDriveUserS3Path":{"shape":"Sj"}}},"InclusionPatterns":{"shape":"S19"},"ExclusionPatterns":{"shape":"S19"},"FieldMappings":{"shape":"S1o"}}},"ServiceNowConfiguration":{"type":"structure","required":["HostUrl","SecretArn","ServiceNowBuildVersion"],"members":{"HostUrl":{},"SecretArn":{},"ServiceNowBuildVersion":{},"KnowledgeArticleConfiguration":{"type":"structure","required":["DocumentDataFieldName"],"members":{"CrawlAttachments":{"type":"boolean"},"IncludeAttachmentFilePatterns":{"shape":"S19"},"ExcludeAttachmentFilePatterns":{"shape":"S19"},"DocumentDataFieldName":{},"DocumentTitleFieldName":{},"FieldMappings":{"shape":"S1o"}}},"ServiceCatalogConfiguration":{"type":"structure","required":["DocumentDataFieldName"],"members":{"CrawlAttachments":{"type":"boolean"},"IncludeAttachmentFilePatterns":{"shape":"S19"},"ExcludeAttachmentFilePatterns":{"shape":"S19"},"DocumentDataFieldName":{},"DocumentTitleFieldName":{},"FieldMappings":{"shape":"S1o"}}}}}}},"S19":{"type":"list","member":{}},"S1j":{"type":"structure","required":["SubnetIds","SecurityGroupIds"],"members":{"SubnetIds":{"type":"list","member":{}},"SecurityGroupIds":{"type":"list","member":{}}}},"S1o":{"type":"list","member":{"type":"structure","required":["DataSourceFieldName","IndexFieldName"],"members":{"DataSourceFieldName":{},"DateFieldFormat":{},"IndexFieldName":{}}}},"S2x":{"type":"list","member":{"type":"structure","required":["Key","Value"],"members":{"Key":{},"Value":{}}}},"S39":{"type":"structure","members":{"KmsKeyId":{"type":"string","sensitive":true}}},"S3p":{"type":"list","member":{"type":"structure","required":["Name","Type"],"members":{"Name":{},"Type":{},"Relevance":{"type":"structure","members":{"Freshness":{"type":"boolean"},"Importance":{"type":"integer"},"Duration":{},"RankOrder":{},"ValueImportanceMap":{"type":"map","key":{},"value":{"type":"integer"}}}},"Search":{"type":"structure","members":{"Facetable":{"type":"boolean"},"Searchable":{"type":"boolean"},"Displayable":{"type":"boolean"},"Sortable":{"type":"boolean"}}}}}},"S47":{"type":"structure","required":["StorageCapacityUnits","QueryCapacityUnits"],"members":{"StorageCapacityUnits":{"type":"integer"},"QueryCapacityUnits":{"type":"integer"}}},"S54":{"type":"structure","members":{"AndAllFilters":{"shape":"S55"},"OrAllFilters":{"shape":"S55"},"NotFilter":{"shape":"S54"},"EqualsTo":{"shape":"Sn"},"ContainsAll":{"shape":"Sn"},"ContainsAny":{"shape":"Sn"},"GreaterThan":{"shape":"Sn"},"GreaterThanOrEquals":{"shape":"Sn"},"LessThan":{"shape":"Sn"},"LessThanOrEquals":{"shape":"Sn"}}},"S55":{"type":"list","member":{"shape":"S54"}},"S5m":{"type":"structure","members":{"Text":{},"Highlights":{"type":"list","member":{"type":"structure","required":["BeginOffset","EndOffset"],"members":{"BeginOffset":{"type":"integer"},"EndOffset":{"type":"integer"},"TopAnswer":{"type":"boolean"}}}}}}}}; + try { + if (type === 'text') { + resolve(chunksDecode(body, length)) + } else if (type === 'json') { + resolve(JSON.parse(chunksDecode(body, length))) + } else if (type === 'arrayBuffer') { + resolve(chunksConcat(body, length).buffer) + } else if (type === 'blob') { + resolve(new Blob(body, { type: stream[kContentType] })) + } else if (type === 'bytes') { + resolve(chunksConcat(body, length)) + } + + consumeFinish(consume) + } catch (err) { + stream.destroy(err) + } +} -/***/ }), +function consumePush (consume, chunk) { + consume.length += chunk.length + consume.body.push(chunk) +} -/***/ 4540: -/***/ (function(module) { +function consumeFinish (consume, err) { + if (consume.body === null) { + return + } -module.exports = {"version":"2.0","metadata":{"apiVersion":"2013-06-30","endpointPrefix":"storagegateway","jsonVersion":"1.1","protocol":"json","serviceFullName":"AWS Storage Gateway","serviceId":"Storage Gateway","signatureVersion":"v4","targetPrefix":"StorageGateway_20130630","uid":"storagegateway-2013-06-30"},"operations":{"ActivateGateway":{"input":{"type":"structure","required":["ActivationKey","GatewayName","GatewayTimezone","GatewayRegion"],"members":{"ActivationKey":{},"GatewayName":{},"GatewayTimezone":{},"GatewayRegion":{},"GatewayType":{},"TapeDriveType":{},"MediumChangerType":{},"Tags":{"shape":"S9"}}},"output":{"type":"structure","members":{"GatewayARN":{}}}},"AddCache":{"input":{"type":"structure","required":["GatewayARN","DiskIds"],"members":{"GatewayARN":{},"DiskIds":{"shape":"Sg"}}},"output":{"type":"structure","members":{"GatewayARN":{}}}},"AddTagsToResource":{"input":{"type":"structure","required":["ResourceARN","Tags"],"members":{"ResourceARN":{},"Tags":{"shape":"S9"}}},"output":{"type":"structure","members":{"ResourceARN":{}}}},"AddUploadBuffer":{"input":{"type":"structure","required":["GatewayARN","DiskIds"],"members":{"GatewayARN":{},"DiskIds":{"shape":"Sg"}}},"output":{"type":"structure","members":{"GatewayARN":{}}}},"AddWorkingStorage":{"input":{"type":"structure","required":["GatewayARN","DiskIds"],"members":{"GatewayARN":{},"DiskIds":{"shape":"Sg"}}},"output":{"type":"structure","members":{"GatewayARN":{}}}},"AssignTapePool":{"input":{"type":"structure","required":["TapeARN","PoolId"],"members":{"TapeARN":{},"PoolId":{}}},"output":{"type":"structure","members":{"TapeARN":{}}}},"AttachVolume":{"input":{"type":"structure","required":["GatewayARN","VolumeARN","NetworkInterfaceId"],"members":{"GatewayARN":{},"TargetName":{},"VolumeARN":{},"NetworkInterfaceId":{},"DiskId":{}}},"output":{"type":"structure","members":{"VolumeARN":{},"TargetARN":{}}}},"CancelArchival":{"input":{"type":"structure","required":["GatewayARN","TapeARN"],"members":{"GatewayARN":{},"TapeARN":{}}},"output":{"type":"structure","members":{"TapeARN":{}}}},"CancelRetrieval":{"input":{"type":"structure","required":["GatewayARN","TapeARN"],"members":{"GatewayARN":{},"TapeARN":{}}},"output":{"type":"structure","members":{"TapeARN":{}}}},"CreateCachediSCSIVolume":{"input":{"type":"structure","required":["GatewayARN","VolumeSizeInBytes","TargetName","NetworkInterfaceId","ClientToken"],"members":{"GatewayARN":{},"VolumeSizeInBytes":{"type":"long"},"SnapshotId":{},"TargetName":{},"SourceVolumeARN":{},"NetworkInterfaceId":{},"ClientToken":{},"KMSEncrypted":{"type":"boolean"},"KMSKey":{},"Tags":{"shape":"S9"}}},"output":{"type":"structure","members":{"VolumeARN":{},"TargetARN":{}}}},"CreateNFSFileShare":{"input":{"type":"structure","required":["ClientToken","GatewayARN","Role","LocationARN"],"members":{"ClientToken":{},"NFSFileShareDefaults":{"shape":"S1c"},"GatewayARN":{},"KMSEncrypted":{"type":"boolean"},"KMSKey":{},"Role":{},"LocationARN":{},"DefaultStorageClass":{},"ObjectACL":{},"ClientList":{"shape":"S1j"},"Squash":{},"ReadOnly":{"type":"boolean"},"GuessMIMETypeEnabled":{"type":"boolean"},"RequesterPays":{"type":"boolean"},"Tags":{"shape":"S9"},"FileShareName":{},"CacheAttributes":{"shape":"S1n"}}},"output":{"type":"structure","members":{"FileShareARN":{}}}},"CreateSMBFileShare":{"input":{"type":"structure","required":["ClientToken","GatewayARN","Role","LocationARN"],"members":{"ClientToken":{},"GatewayARN":{},"KMSEncrypted":{"type":"boolean"},"KMSKey":{},"Role":{},"LocationARN":{},"DefaultStorageClass":{},"ObjectACL":{},"ReadOnly":{"type":"boolean"},"GuessMIMETypeEnabled":{"type":"boolean"},"RequesterPays":{"type":"boolean"},"SMBACLEnabled":{"type":"boolean"},"AdminUserList":{"shape":"S1s"},"ValidUserList":{"shape":"S1s"},"InvalidUserList":{"shape":"S1s"},"AuditDestinationARN":{},"Authentication":{},"CaseSensitivity":{},"Tags":{"shape":"S9"},"FileShareName":{},"CacheAttributes":{"shape":"S1n"}}},"output":{"type":"structure","members":{"FileShareARN":{}}}},"CreateSnapshot":{"input":{"type":"structure","required":["VolumeARN","SnapshotDescription"],"members":{"VolumeARN":{},"SnapshotDescription":{},"Tags":{"shape":"S9"}}},"output":{"type":"structure","members":{"VolumeARN":{},"SnapshotId":{}}}},"CreateSnapshotFromVolumeRecoveryPoint":{"input":{"type":"structure","required":["VolumeARN","SnapshotDescription"],"members":{"VolumeARN":{},"SnapshotDescription":{},"Tags":{"shape":"S9"}}},"output":{"type":"structure","members":{"SnapshotId":{},"VolumeARN":{},"VolumeRecoveryPointTime":{}}}},"CreateStorediSCSIVolume":{"input":{"type":"structure","required":["GatewayARN","DiskId","PreserveExistingData","TargetName","NetworkInterfaceId"],"members":{"GatewayARN":{},"DiskId":{},"SnapshotId":{},"PreserveExistingData":{"type":"boolean"},"TargetName":{},"NetworkInterfaceId":{},"KMSEncrypted":{"type":"boolean"},"KMSKey":{},"Tags":{"shape":"S9"}}},"output":{"type":"structure","members":{"VolumeARN":{},"VolumeSizeInBytes":{"type":"long"},"TargetARN":{}}}},"CreateTapeWithBarcode":{"input":{"type":"structure","required":["GatewayARN","TapeSizeInBytes","TapeBarcode"],"members":{"GatewayARN":{},"TapeSizeInBytes":{"type":"long"},"TapeBarcode":{},"KMSEncrypted":{"type":"boolean"},"KMSKey":{},"PoolId":{},"Tags":{"shape":"S9"}}},"output":{"type":"structure","members":{"TapeARN":{}}}},"CreateTapes":{"input":{"type":"structure","required":["GatewayARN","TapeSizeInBytes","ClientToken","NumTapesToCreate","TapeBarcodePrefix"],"members":{"GatewayARN":{},"TapeSizeInBytes":{"type":"long"},"ClientToken":{},"NumTapesToCreate":{"type":"integer"},"TapeBarcodePrefix":{},"KMSEncrypted":{"type":"boolean"},"KMSKey":{},"PoolId":{},"Tags":{"shape":"S9"}}},"output":{"type":"structure","members":{"TapeARNs":{"shape":"S2f"}}}},"DeleteAutomaticTapeCreationPolicy":{"input":{"type":"structure","required":["GatewayARN"],"members":{"GatewayARN":{}}},"output":{"type":"structure","members":{"GatewayARN":{}}}},"DeleteBandwidthRateLimit":{"input":{"type":"structure","required":["GatewayARN","BandwidthType"],"members":{"GatewayARN":{},"BandwidthType":{}}},"output":{"type":"structure","members":{"GatewayARN":{}}}},"DeleteChapCredentials":{"input":{"type":"structure","required":["TargetARN","InitiatorName"],"members":{"TargetARN":{},"InitiatorName":{}}},"output":{"type":"structure","members":{"TargetARN":{},"InitiatorName":{}}}},"DeleteFileShare":{"input":{"type":"structure","required":["FileShareARN"],"members":{"FileShareARN":{},"ForceDelete":{"type":"boolean"}}},"output":{"type":"structure","members":{"FileShareARN":{}}}},"DeleteGateway":{"input":{"type":"structure","required":["GatewayARN"],"members":{"GatewayARN":{}}},"output":{"type":"structure","members":{"GatewayARN":{}}}},"DeleteSnapshotSchedule":{"input":{"type":"structure","required":["VolumeARN"],"members":{"VolumeARN":{}}},"output":{"type":"structure","members":{"VolumeARN":{}}}},"DeleteTape":{"input":{"type":"structure","required":["GatewayARN","TapeARN"],"members":{"GatewayARN":{},"TapeARN":{}}},"output":{"type":"structure","members":{"TapeARN":{}}}},"DeleteTapeArchive":{"input":{"type":"structure","required":["TapeARN"],"members":{"TapeARN":{}}},"output":{"type":"structure","members":{"TapeARN":{}}}},"DeleteVolume":{"input":{"type":"structure","required":["VolumeARN"],"members":{"VolumeARN":{}}},"output":{"type":"structure","members":{"VolumeARN":{}}}},"DescribeAvailabilityMonitorTest":{"input":{"type":"structure","required":["GatewayARN"],"members":{"GatewayARN":{}}},"output":{"type":"structure","members":{"GatewayARN":{},"Status":{},"StartTime":{"type":"timestamp"}}}},"DescribeBandwidthRateLimit":{"input":{"type":"structure","required":["GatewayARN"],"members":{"GatewayARN":{}}},"output":{"type":"structure","members":{"GatewayARN":{},"AverageUploadRateLimitInBitsPerSec":{"type":"long"},"AverageDownloadRateLimitInBitsPerSec":{"type":"long"}}}},"DescribeCache":{"input":{"type":"structure","required":["GatewayARN"],"members":{"GatewayARN":{}}},"output":{"type":"structure","members":{"GatewayARN":{},"DiskIds":{"shape":"Sg"},"CacheAllocatedInBytes":{"type":"long"},"CacheUsedPercentage":{"type":"double"},"CacheDirtyPercentage":{"type":"double"},"CacheHitPercentage":{"type":"double"},"CacheMissPercentage":{"type":"double"}}}},"DescribeCachediSCSIVolumes":{"input":{"type":"structure","required":["VolumeARNs"],"members":{"VolumeARNs":{"shape":"S3c"}}},"output":{"type":"structure","members":{"CachediSCSIVolumes":{"type":"list","member":{"type":"structure","members":{"VolumeARN":{},"VolumeId":{},"VolumeType":{},"VolumeStatus":{},"VolumeAttachmentStatus":{},"VolumeSizeInBytes":{"type":"long"},"VolumeProgress":{"type":"double"},"SourceSnapshotId":{},"VolumeiSCSIAttributes":{"shape":"S3l"},"CreatedDate":{"type":"timestamp"},"VolumeUsedInBytes":{"type":"long"},"KMSKey":{},"TargetName":{}}}}}}},"DescribeChapCredentials":{"input":{"type":"structure","required":["TargetARN"],"members":{"TargetARN":{}}},"output":{"type":"structure","members":{"ChapCredentials":{"type":"list","member":{"type":"structure","members":{"TargetARN":{},"SecretToAuthenticateInitiator":{"shape":"S3u"},"InitiatorName":{},"SecretToAuthenticateTarget":{"shape":"S3u"}}}}}}},"DescribeGatewayInformation":{"input":{"type":"structure","required":["GatewayARN"],"members":{"GatewayARN":{}}},"output":{"type":"structure","members":{"GatewayARN":{},"GatewayId":{},"GatewayName":{},"GatewayTimezone":{},"GatewayState":{},"GatewayNetworkInterfaces":{"type":"list","member":{"type":"structure","members":{"Ipv4Address":{},"MacAddress":{},"Ipv6Address":{}}}},"GatewayType":{},"NextUpdateAvailabilityDate":{},"LastSoftwareUpdate":{},"Ec2InstanceId":{},"Ec2InstanceRegion":{},"Tags":{"shape":"S9"},"VPCEndpoint":{},"CloudWatchLogGroupARN":{},"HostEnvironment":{},"EndpointType":{},"SoftwareUpdatesEndDate":{},"DeprecationDate":{}}}},"DescribeMaintenanceStartTime":{"input":{"type":"structure","required":["GatewayARN"],"members":{"GatewayARN":{}}},"output":{"type":"structure","members":{"GatewayARN":{},"HourOfDay":{"type":"integer"},"MinuteOfHour":{"type":"integer"},"DayOfWeek":{"type":"integer"},"DayOfMonth":{"type":"integer"},"Timezone":{}}}},"DescribeNFSFileShares":{"input":{"type":"structure","required":["FileShareARNList"],"members":{"FileShareARNList":{"shape":"S4h"}}},"output":{"type":"structure","members":{"NFSFileShareInfoList":{"type":"list","member":{"type":"structure","members":{"NFSFileShareDefaults":{"shape":"S1c"},"FileShareARN":{},"FileShareId":{},"FileShareStatus":{},"GatewayARN":{},"KMSEncrypted":{"type":"boolean"},"KMSKey":{},"Path":{},"Role":{},"LocationARN":{},"DefaultStorageClass":{},"ObjectACL":{},"ClientList":{"shape":"S1j"},"Squash":{},"ReadOnly":{"type":"boolean"},"GuessMIMETypeEnabled":{"type":"boolean"},"RequesterPays":{"type":"boolean"},"Tags":{"shape":"S9"},"FileShareName":{},"CacheAttributes":{"shape":"S1n"}}}}}}},"DescribeSMBFileShares":{"input":{"type":"structure","required":["FileShareARNList"],"members":{"FileShareARNList":{"shape":"S4h"}}},"output":{"type":"structure","members":{"SMBFileShareInfoList":{"type":"list","member":{"type":"structure","members":{"FileShareARN":{},"FileShareId":{},"FileShareStatus":{},"GatewayARN":{},"KMSEncrypted":{"type":"boolean"},"KMSKey":{},"Path":{},"Role":{},"LocationARN":{},"DefaultStorageClass":{},"ObjectACL":{},"ReadOnly":{"type":"boolean"},"GuessMIMETypeEnabled":{"type":"boolean"},"RequesterPays":{"type":"boolean"},"SMBACLEnabled":{"type":"boolean"},"AdminUserList":{"shape":"S1s"},"ValidUserList":{"shape":"S1s"},"InvalidUserList":{"shape":"S1s"},"AuditDestinationARN":{},"Authentication":{},"CaseSensitivity":{},"Tags":{"shape":"S9"},"FileShareName":{},"CacheAttributes":{"shape":"S1n"}}}}}}},"DescribeSMBSettings":{"input":{"type":"structure","required":["GatewayARN"],"members":{"GatewayARN":{}}},"output":{"type":"structure","members":{"GatewayARN":{},"DomainName":{},"ActiveDirectoryStatus":{},"SMBGuestPasswordSet":{"type":"boolean"},"SMBSecurityStrategy":{}}}},"DescribeSnapshotSchedule":{"input":{"type":"structure","required":["VolumeARN"],"members":{"VolumeARN":{}}},"output":{"type":"structure","members":{"VolumeARN":{},"StartAt":{"type":"integer"},"RecurrenceInHours":{"type":"integer"},"Description":{},"Timezone":{},"Tags":{"shape":"S9"}}}},"DescribeStorediSCSIVolumes":{"input":{"type":"structure","required":["VolumeARNs"],"members":{"VolumeARNs":{"shape":"S3c"}}},"output":{"type":"structure","members":{"StorediSCSIVolumes":{"type":"list","member":{"type":"structure","members":{"VolumeARN":{},"VolumeId":{},"VolumeType":{},"VolumeStatus":{},"VolumeAttachmentStatus":{},"VolumeSizeInBytes":{"type":"long"},"VolumeProgress":{"type":"double"},"VolumeDiskId":{},"SourceSnapshotId":{},"PreservedExistingData":{"type":"boolean"},"VolumeiSCSIAttributes":{"shape":"S3l"},"CreatedDate":{"type":"timestamp"},"VolumeUsedInBytes":{"type":"long"},"KMSKey":{},"TargetName":{}}}}}}},"DescribeTapeArchives":{"input":{"type":"structure","members":{"TapeARNs":{"shape":"S2f"},"Marker":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"TapeArchives":{"type":"list","member":{"type":"structure","members":{"TapeARN":{},"TapeBarcode":{},"TapeCreatedDate":{"type":"timestamp"},"TapeSizeInBytes":{"type":"long"},"CompletionTime":{"type":"timestamp"},"RetrievedTo":{},"TapeStatus":{},"TapeUsedInBytes":{"type":"long"},"KMSKey":{},"PoolId":{}}}},"Marker":{}}}},"DescribeTapeRecoveryPoints":{"input":{"type":"structure","required":["GatewayARN"],"members":{"GatewayARN":{},"Marker":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"GatewayARN":{},"TapeRecoveryPointInfos":{"type":"list","member":{"type":"structure","members":{"TapeARN":{},"TapeRecoveryPointTime":{"type":"timestamp"},"TapeSizeInBytes":{"type":"long"},"TapeStatus":{}}}},"Marker":{}}}},"DescribeTapes":{"input":{"type":"structure","required":["GatewayARN"],"members":{"GatewayARN":{},"TapeARNs":{"shape":"S2f"},"Marker":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"Tapes":{"type":"list","member":{"type":"structure","members":{"TapeARN":{},"TapeBarcode":{},"TapeCreatedDate":{"type":"timestamp"},"TapeSizeInBytes":{"type":"long"},"TapeStatus":{},"VTLDevice":{},"Progress":{"type":"double"},"TapeUsedInBytes":{"type":"long"},"KMSKey":{},"PoolId":{}}}},"Marker":{}}}},"DescribeUploadBuffer":{"input":{"type":"structure","required":["GatewayARN"],"members":{"GatewayARN":{}}},"output":{"type":"structure","members":{"GatewayARN":{},"DiskIds":{"shape":"Sg"},"UploadBufferUsedInBytes":{"type":"long"},"UploadBufferAllocatedInBytes":{"type":"long"}}}},"DescribeVTLDevices":{"input":{"type":"structure","required":["GatewayARN"],"members":{"GatewayARN":{},"VTLDeviceARNs":{"type":"list","member":{}},"Marker":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"GatewayARN":{},"VTLDevices":{"type":"list","member":{"type":"structure","members":{"VTLDeviceARN":{},"VTLDeviceType":{},"VTLDeviceVendor":{},"VTLDeviceProductIdentifier":{},"DeviceiSCSIAttributes":{"type":"structure","members":{"TargetARN":{},"NetworkInterfaceId":{},"NetworkInterfacePort":{"type":"integer"},"ChapEnabled":{"type":"boolean"}}}}}},"Marker":{}}}},"DescribeWorkingStorage":{"input":{"type":"structure","required":["GatewayARN"],"members":{"GatewayARN":{}}},"output":{"type":"structure","members":{"GatewayARN":{},"DiskIds":{"shape":"Sg"},"WorkingStorageUsedInBytes":{"type":"long"},"WorkingStorageAllocatedInBytes":{"type":"long"}}}},"DetachVolume":{"input":{"type":"structure","required":["VolumeARN"],"members":{"VolumeARN":{},"ForceDetach":{"type":"boolean"}}},"output":{"type":"structure","members":{"VolumeARN":{}}}},"DisableGateway":{"input":{"type":"structure","required":["GatewayARN"],"members":{"GatewayARN":{}}},"output":{"type":"structure","members":{"GatewayARN":{}}}},"JoinDomain":{"input":{"type":"structure","required":["GatewayARN","DomainName","UserName","Password"],"members":{"GatewayARN":{},"DomainName":{},"OrganizationalUnit":{},"DomainControllers":{"type":"list","member":{}},"TimeoutInSeconds":{"type":"integer"},"UserName":{},"Password":{"type":"string","sensitive":true}}},"output":{"type":"structure","members":{"GatewayARN":{},"ActiveDirectoryStatus":{}}}},"ListAutomaticTapeCreationPolicies":{"input":{"type":"structure","members":{"GatewayARN":{}}},"output":{"type":"structure","members":{"AutomaticTapeCreationPolicyInfos":{"type":"list","member":{"type":"structure","members":{"AutomaticTapeCreationRules":{"shape":"S6g"},"GatewayARN":{}}}}}}},"ListFileShares":{"input":{"type":"structure","members":{"GatewayARN":{},"Limit":{"type":"integer"},"Marker":{}}},"output":{"type":"structure","members":{"Marker":{},"NextMarker":{},"FileShareInfoList":{"type":"list","member":{"type":"structure","members":{"FileShareType":{},"FileShareARN":{},"FileShareId":{},"FileShareStatus":{},"GatewayARN":{}}}}}}},"ListGateways":{"input":{"type":"structure","members":{"Marker":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"Gateways":{"type":"list","member":{"type":"structure","members":{"GatewayId":{},"GatewayARN":{},"GatewayType":{},"GatewayOperationalState":{},"GatewayName":{},"Ec2InstanceId":{},"Ec2InstanceRegion":{}}}},"Marker":{}}}},"ListLocalDisks":{"input":{"type":"structure","required":["GatewayARN"],"members":{"GatewayARN":{}}},"output":{"type":"structure","members":{"GatewayARN":{},"Disks":{"type":"list","member":{"type":"structure","members":{"DiskId":{},"DiskPath":{},"DiskNode":{},"DiskStatus":{},"DiskSizeInBytes":{"type":"long"},"DiskAllocationType":{},"DiskAllocationResource":{},"DiskAttributeList":{"type":"list","member":{}}}}}}}},"ListTagsForResource":{"input":{"type":"structure","required":["ResourceARN"],"members":{"ResourceARN":{},"Marker":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"ResourceARN":{},"Marker":{},"Tags":{"shape":"S9"}}}},"ListTapes":{"input":{"type":"structure","members":{"TapeARNs":{"shape":"S2f"},"Marker":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"TapeInfos":{"type":"list","member":{"type":"structure","members":{"TapeARN":{},"TapeBarcode":{},"TapeSizeInBytes":{"type":"long"},"TapeStatus":{},"GatewayARN":{},"PoolId":{}}}},"Marker":{}}}},"ListVolumeInitiators":{"input":{"type":"structure","required":["VolumeARN"],"members":{"VolumeARN":{}}},"output":{"type":"structure","members":{"Initiators":{"type":"list","member":{}}}}},"ListVolumeRecoveryPoints":{"input":{"type":"structure","required":["GatewayARN"],"members":{"GatewayARN":{}}},"output":{"type":"structure","members":{"GatewayARN":{},"VolumeRecoveryPointInfos":{"type":"list","member":{"type":"structure","members":{"VolumeARN":{},"VolumeSizeInBytes":{"type":"long"},"VolumeUsageInBytes":{"type":"long"},"VolumeRecoveryPointTime":{}}}}}}},"ListVolumes":{"input":{"type":"structure","members":{"GatewayARN":{},"Marker":{},"Limit":{"type":"integer"}}},"output":{"type":"structure","members":{"GatewayARN":{},"Marker":{},"VolumeInfos":{"type":"list","member":{"type":"structure","members":{"VolumeARN":{},"VolumeId":{},"GatewayARN":{},"GatewayId":{},"VolumeType":{},"VolumeSizeInBytes":{"type":"long"},"VolumeAttachmentStatus":{}}}}}}},"NotifyWhenUploaded":{"input":{"type":"structure","required":["FileShareARN"],"members":{"FileShareARN":{}}},"output":{"type":"structure","members":{"FileShareARN":{},"NotificationId":{}}}},"RefreshCache":{"input":{"type":"structure","required":["FileShareARN"],"members":{"FileShareARN":{},"FolderList":{"type":"list","member":{}},"Recursive":{"type":"boolean"}}},"output":{"type":"structure","members":{"FileShareARN":{},"NotificationId":{}}}},"RemoveTagsFromResource":{"input":{"type":"structure","required":["ResourceARN","TagKeys"],"members":{"ResourceARN":{},"TagKeys":{"type":"list","member":{}}}},"output":{"type":"structure","members":{"ResourceARN":{}}}},"ResetCache":{"input":{"type":"structure","required":["GatewayARN"],"members":{"GatewayARN":{}}},"output":{"type":"structure","members":{"GatewayARN":{}}}},"RetrieveTapeArchive":{"input":{"type":"structure","required":["TapeARN","GatewayARN"],"members":{"TapeARN":{},"GatewayARN":{}}},"output":{"type":"structure","members":{"TapeARN":{}}}},"RetrieveTapeRecoveryPoint":{"input":{"type":"structure","required":["TapeARN","GatewayARN"],"members":{"TapeARN":{},"GatewayARN":{}}},"output":{"type":"structure","members":{"TapeARN":{}}}},"SetLocalConsolePassword":{"input":{"type":"structure","required":["GatewayARN","LocalConsolePassword"],"members":{"GatewayARN":{},"LocalConsolePassword":{"type":"string","sensitive":true}}},"output":{"type":"structure","members":{"GatewayARN":{}}}},"SetSMBGuestPassword":{"input":{"type":"structure","required":["GatewayARN","Password"],"members":{"GatewayARN":{},"Password":{"type":"string","sensitive":true}}},"output":{"type":"structure","members":{"GatewayARN":{}}}},"ShutdownGateway":{"input":{"type":"structure","required":["GatewayARN"],"members":{"GatewayARN":{}}},"output":{"type":"structure","members":{"GatewayARN":{}}}},"StartAvailabilityMonitorTest":{"input":{"type":"structure","required":["GatewayARN"],"members":{"GatewayARN":{}}},"output":{"type":"structure","members":{"GatewayARN":{}}}},"StartGateway":{"input":{"type":"structure","required":["GatewayARN"],"members":{"GatewayARN":{}}},"output":{"type":"structure","members":{"GatewayARN":{}}}},"UpdateAutomaticTapeCreationPolicy":{"input":{"type":"structure","required":["AutomaticTapeCreationRules","GatewayARN"],"members":{"AutomaticTapeCreationRules":{"shape":"S6g"},"GatewayARN":{}}},"output":{"type":"structure","members":{"GatewayARN":{}}}},"UpdateBandwidthRateLimit":{"input":{"type":"structure","required":["GatewayARN"],"members":{"GatewayARN":{},"AverageUploadRateLimitInBitsPerSec":{"type":"long"},"AverageDownloadRateLimitInBitsPerSec":{"type":"long"}}},"output":{"type":"structure","members":{"GatewayARN":{}}}},"UpdateChapCredentials":{"input":{"type":"structure","required":["TargetARN","SecretToAuthenticateInitiator","InitiatorName"],"members":{"TargetARN":{},"SecretToAuthenticateInitiator":{"shape":"S3u"},"InitiatorName":{},"SecretToAuthenticateTarget":{"shape":"S3u"}}},"output":{"type":"structure","members":{"TargetARN":{},"InitiatorName":{}}}},"UpdateGatewayInformation":{"input":{"type":"structure","required":["GatewayARN"],"members":{"GatewayARN":{},"GatewayName":{},"GatewayTimezone":{},"CloudWatchLogGroupARN":{}}},"output":{"type":"structure","members":{"GatewayARN":{},"GatewayName":{}}}},"UpdateGatewaySoftwareNow":{"input":{"type":"structure","required":["GatewayARN"],"members":{"GatewayARN":{}}},"output":{"type":"structure","members":{"GatewayARN":{}}}},"UpdateMaintenanceStartTime":{"input":{"type":"structure","required":["GatewayARN","HourOfDay","MinuteOfHour"],"members":{"GatewayARN":{},"HourOfDay":{"type":"integer"},"MinuteOfHour":{"type":"integer"},"DayOfWeek":{"type":"integer"},"DayOfMonth":{"type":"integer"}}},"output":{"type":"structure","members":{"GatewayARN":{}}}},"UpdateNFSFileShare":{"input":{"type":"structure","required":["FileShareARN"],"members":{"FileShareARN":{},"KMSEncrypted":{"type":"boolean"},"KMSKey":{},"NFSFileShareDefaults":{"shape":"S1c"},"DefaultStorageClass":{},"ObjectACL":{},"ClientList":{"shape":"S1j"},"Squash":{},"ReadOnly":{"type":"boolean"},"GuessMIMETypeEnabled":{"type":"boolean"},"RequesterPays":{"type":"boolean"},"FileShareName":{},"CacheAttributes":{"shape":"S1n"}}},"output":{"type":"structure","members":{"FileShareARN":{}}}},"UpdateSMBFileShare":{"input":{"type":"structure","required":["FileShareARN"],"members":{"FileShareARN":{},"KMSEncrypted":{"type":"boolean"},"KMSKey":{},"DefaultStorageClass":{},"ObjectACL":{},"ReadOnly":{"type":"boolean"},"GuessMIMETypeEnabled":{"type":"boolean"},"RequesterPays":{"type":"boolean"},"SMBACLEnabled":{"type":"boolean"},"AdminUserList":{"shape":"S1s"},"ValidUserList":{"shape":"S1s"},"InvalidUserList":{"shape":"S1s"},"AuditDestinationARN":{},"CaseSensitivity":{},"FileShareName":{},"CacheAttributes":{"shape":"S1n"}}},"output":{"type":"structure","members":{"FileShareARN":{}}}},"UpdateSMBSecurityStrategy":{"input":{"type":"structure","required":["GatewayARN","SMBSecurityStrategy"],"members":{"GatewayARN":{},"SMBSecurityStrategy":{}}},"output":{"type":"structure","members":{"GatewayARN":{}}}},"UpdateSnapshotSchedule":{"input":{"type":"structure","required":["VolumeARN","StartAt","RecurrenceInHours"],"members":{"VolumeARN":{},"StartAt":{"type":"integer"},"RecurrenceInHours":{"type":"integer"},"Description":{},"Tags":{"shape":"S9"}}},"output":{"type":"structure","members":{"VolumeARN":{}}}},"UpdateVTLDeviceType":{"input":{"type":"structure","required":["VTLDeviceARN","DeviceType"],"members":{"VTLDeviceARN":{},"DeviceType":{}}},"output":{"type":"structure","members":{"VTLDeviceARN":{}}}}},"shapes":{"S9":{"type":"list","member":{"type":"structure","required":["Key","Value"],"members":{"Key":{},"Value":{}}}},"Sg":{"type":"list","member":{}},"S1c":{"type":"structure","members":{"FileMode":{},"DirectoryMode":{},"GroupId":{"type":"long"},"OwnerId":{"type":"long"}}},"S1j":{"type":"list","member":{}},"S1n":{"type":"structure","members":{"CacheStaleTimeoutInSeconds":{"type":"integer"}}},"S1s":{"type":"list","member":{}},"S2f":{"type":"list","member":{}},"S3c":{"type":"list","member":{}},"S3l":{"type":"structure","members":{"TargetARN":{},"NetworkInterfaceId":{},"NetworkInterfacePort":{"type":"integer"},"LunNumber":{"type":"integer"},"ChapEnabled":{"type":"boolean"}}},"S3u":{"type":"string","sensitive":true},"S4h":{"type":"list","member":{}},"S6g":{"type":"list","member":{"type":"structure","required":["TapeBarcodePrefix","PoolId","TapeSizeInBytes","MinimumNumTapes"],"members":{"TapeBarcodePrefix":{},"PoolId":{},"TapeSizeInBytes":{"type":"long"},"MinimumNumTapes":{"type":"integer"}}}}}}; + if (err) { + consume.reject(err) + } else { + consume.resolve() + } -/***/ }), + consume.type = null + consume.stream = null + consume.resolve = null + consume.reject = null + consume.length = 0 + consume.body = null +} -/***/ 4571: -/***/ (function(module) { +module.exports = { Readable: BodyReadable, chunksDecode } -module.exports = {"pagination":{"GetFindingsReportAccountSummary":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"ListFindingsReports":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"},"ListProfileTimes":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults","result_key":"profileTimes"},"ListProfilingGroups":{"input_token":"nextToken","output_token":"nextToken","limit_key":"maxResults"}}}; /***/ }), -/***/ 4572: -/***/ (function(module) { +/***/ 7655: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -module.exports = {"version":2,"waiters":{"NotebookInstanceInService":{"delay":30,"maxAttempts":60,"operation":"DescribeNotebookInstance","acceptors":[{"expected":"InService","matcher":"path","state":"success","argument":"NotebookInstanceStatus"},{"expected":"Failed","matcher":"path","state":"failure","argument":"NotebookInstanceStatus"}]},"NotebookInstanceStopped":{"delay":30,"operation":"DescribeNotebookInstance","maxAttempts":60,"acceptors":[{"expected":"Stopped","matcher":"path","state":"success","argument":"NotebookInstanceStatus"},{"expected":"Failed","matcher":"path","state":"failure","argument":"NotebookInstanceStatus"}]},"NotebookInstanceDeleted":{"delay":30,"maxAttempts":60,"operation":"DescribeNotebookInstance","acceptors":[{"expected":"ValidationException","matcher":"error","state":"success"},{"expected":"Failed","matcher":"path","state":"failure","argument":"NotebookInstanceStatus"}]},"TrainingJobCompletedOrStopped":{"delay":120,"maxAttempts":180,"operation":"DescribeTrainingJob","acceptors":[{"expected":"Completed","matcher":"path","state":"success","argument":"TrainingJobStatus"},{"expected":"Stopped","matcher":"path","state":"success","argument":"TrainingJobStatus"},{"expected":"Failed","matcher":"path","state":"failure","argument":"TrainingJobStatus"},{"expected":"ValidationException","matcher":"error","state":"failure"}]},"EndpointInService":{"delay":30,"maxAttempts":120,"operation":"DescribeEndpoint","acceptors":[{"expected":"InService","matcher":"path","state":"success","argument":"EndpointStatus"},{"expected":"Failed","matcher":"path","state":"failure","argument":"EndpointStatus"},{"expected":"ValidationException","matcher":"error","state":"failure"}]},"EndpointDeleted":{"delay":30,"maxAttempts":60,"operation":"DescribeEndpoint","acceptors":[{"expected":"ValidationException","matcher":"error","state":"success"},{"expected":"Failed","matcher":"path","state":"failure","argument":"EndpointStatus"}]},"TransformJobCompletedOrStopped":{"delay":60,"maxAttempts":60,"operation":"DescribeTransformJob","acceptors":[{"expected":"Completed","matcher":"path","state":"success","argument":"TransformJobStatus"},{"expected":"Stopped","matcher":"path","state":"success","argument":"TransformJobStatus"},{"expected":"Failed","matcher":"path","state":"failure","argument":"TransformJobStatus"},{"expected":"ValidationException","matcher":"error","state":"failure"}]},"ProcessingJobCompletedOrStopped":{"delay":60,"maxAttempts":60,"operation":"DescribeProcessingJob","acceptors":[{"expected":"Completed","matcher":"path","state":"success","argument":"ProcessingJobStatus"},{"expected":"Stopped","matcher":"path","state":"success","argument":"ProcessingJobStatus"},{"expected":"Failed","matcher":"path","state":"failure","argument":"ProcessingJobStatus"},{"expected":"ValidationException","matcher":"error","state":"failure"}]}}}; +const assert = __nccwpck_require__(4589) +const { + ResponseStatusCodeError +} = __nccwpck_require__(8707) -/***/ }), +const { chunksDecode } = __nccwpck_require__(9927) +const CHUNK_LIMIT = 128 * 1024 -/***/ 4575: -/***/ (function(module) { +async function getResolveErrorBodyCallback ({ callback, body, contentType, statusCode, statusMessage, headers }) { + assert(body) -module.exports = {"version":"2.0","metadata":{"apiVersion":"2019-11-01","endpointPrefix":"access-analyzer","jsonVersion":"1.1","protocol":"rest-json","serviceFullName":"Access Analyzer","serviceId":"AccessAnalyzer","signatureVersion":"v4","signingName":"access-analyzer","uid":"accessanalyzer-2019-11-01"},"operations":{"CreateAnalyzer":{"http":{"method":"PUT","requestUri":"/analyzer","responseCode":200},"input":{"type":"structure","required":["analyzerName","type"],"members":{"analyzerName":{},"archiveRules":{"type":"list","member":{"type":"structure","required":["filter","ruleName"],"members":{"filter":{"shape":"S5"},"ruleName":{}}}},"clientToken":{"idempotencyToken":true},"tags":{"shape":"Sa"},"type":{}}},"output":{"type":"structure","members":{"arn":{}}},"idempotent":true},"CreateArchiveRule":{"http":{"method":"PUT","requestUri":"/analyzer/{analyzerName}/archive-rule","responseCode":200},"input":{"type":"structure","required":["analyzerName","filter","ruleName"],"members":{"analyzerName":{"location":"uri","locationName":"analyzerName"},"clientToken":{"idempotencyToken":true},"filter":{"shape":"S5"},"ruleName":{}}},"idempotent":true},"DeleteAnalyzer":{"http":{"method":"DELETE","requestUri":"/analyzer/{analyzerName}","responseCode":200},"input":{"type":"structure","required":["analyzerName"],"members":{"analyzerName":{"location":"uri","locationName":"analyzerName"},"clientToken":{"idempotencyToken":true,"location":"querystring","locationName":"clientToken"}}},"idempotent":true},"DeleteArchiveRule":{"http":{"method":"DELETE","requestUri":"/analyzer/{analyzerName}/archive-rule/{ruleName}","responseCode":200},"input":{"type":"structure","required":["analyzerName","ruleName"],"members":{"analyzerName":{"location":"uri","locationName":"analyzerName"},"clientToken":{"idempotencyToken":true,"location":"querystring","locationName":"clientToken"},"ruleName":{"location":"uri","locationName":"ruleName"}}},"idempotent":true},"GetAnalyzedResource":{"http":{"method":"GET","requestUri":"/analyzed-resource","responseCode":200},"input":{"type":"structure","required":["analyzerArn","resourceArn"],"members":{"analyzerArn":{"location":"querystring","locationName":"analyzerArn"},"resourceArn":{"location":"querystring","locationName":"resourceArn"}}},"output":{"type":"structure","members":{"resource":{"type":"structure","required":["analyzedAt","createdAt","isPublic","resourceArn","resourceOwnerAccount","resourceType","updatedAt"],"members":{"actions":{"shape":"Sl"},"analyzedAt":{"shape":"Sm"},"createdAt":{"shape":"Sm"},"error":{},"isPublic":{"type":"boolean"},"resourceArn":{},"resourceOwnerAccount":{},"resourceType":{},"sharedVia":{"type":"list","member":{}},"status":{},"updatedAt":{"shape":"Sm"}}}}}},"GetAnalyzer":{"http":{"method":"GET","requestUri":"/analyzer/{analyzerName}","responseCode":200},"input":{"type":"structure","required":["analyzerName"],"members":{"analyzerName":{"location":"uri","locationName":"analyzerName"}}},"output":{"type":"structure","required":["analyzer"],"members":{"analyzer":{"shape":"Ss"}}}},"GetArchiveRule":{"http":{"method":"GET","requestUri":"/analyzer/{analyzerName}/archive-rule/{ruleName}","responseCode":200},"input":{"type":"structure","required":["analyzerName","ruleName"],"members":{"analyzerName":{"location":"uri","locationName":"analyzerName"},"ruleName":{"location":"uri","locationName":"ruleName"}}},"output":{"type":"structure","required":["archiveRule"],"members":{"archiveRule":{"shape":"Sy"}}}},"GetFinding":{"http":{"method":"GET","requestUri":"/finding/{id}","responseCode":200},"input":{"type":"structure","required":["analyzerArn","id"],"members":{"analyzerArn":{"location":"querystring","locationName":"analyzerArn"},"id":{"location":"uri","locationName":"id"}}},"output":{"type":"structure","members":{"finding":{"type":"structure","required":["analyzedAt","condition","createdAt","id","resourceOwnerAccount","resourceType","status","updatedAt"],"members":{"action":{"shape":"Sl"},"analyzedAt":{"shape":"Sm"},"condition":{"shape":"S13"},"createdAt":{"shape":"Sm"},"error":{},"id":{},"isPublic":{"type":"boolean"},"principal":{"shape":"S14"},"resource":{},"resourceOwnerAccount":{},"resourceType":{},"sources":{"shape":"S15"},"status":{},"updatedAt":{"shape":"Sm"}}}}}},"ListAnalyzedResources":{"http":{"requestUri":"/analyzed-resource","responseCode":200},"input":{"type":"structure","required":["analyzerArn"],"members":{"analyzerArn":{},"maxResults":{"type":"integer"},"nextToken":{},"resourceType":{}}},"output":{"type":"structure","required":["analyzedResources"],"members":{"analyzedResources":{"type":"list","member":{"type":"structure","required":["resourceArn","resourceOwnerAccount","resourceType"],"members":{"resourceArn":{},"resourceOwnerAccount":{},"resourceType":{}}}},"nextToken":{}}}},"ListAnalyzers":{"http":{"method":"GET","requestUri":"/analyzer","responseCode":200},"input":{"type":"structure","members":{"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"nextToken":{"location":"querystring","locationName":"nextToken"},"type":{"location":"querystring","locationName":"type"}}},"output":{"type":"structure","required":["analyzers"],"members":{"analyzers":{"type":"list","member":{"shape":"Ss"}},"nextToken":{}}}},"ListArchiveRules":{"http":{"method":"GET","requestUri":"/analyzer/{analyzerName}/archive-rule","responseCode":200},"input":{"type":"structure","required":["analyzerName"],"members":{"analyzerName":{"location":"uri","locationName":"analyzerName"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"nextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","required":["archiveRules"],"members":{"archiveRules":{"type":"list","member":{"shape":"Sy"}},"nextToken":{}}}},"ListFindings":{"http":{"requestUri":"/finding","responseCode":200},"input":{"type":"structure","required":["analyzerArn"],"members":{"analyzerArn":{},"filter":{"shape":"S5"},"maxResults":{"type":"integer"},"nextToken":{},"sort":{"type":"structure","members":{"attributeName":{},"orderBy":{}}}}},"output":{"type":"structure","required":["findings"],"members":{"findings":{"type":"list","member":{"type":"structure","required":["analyzedAt","condition","createdAt","id","resourceOwnerAccount","resourceType","status","updatedAt"],"members":{"action":{"shape":"Sl"},"analyzedAt":{"shape":"Sm"},"condition":{"shape":"S13"},"createdAt":{"shape":"Sm"},"error":{},"id":{},"isPublic":{"type":"boolean"},"principal":{"shape":"S14"},"resource":{},"resourceOwnerAccount":{},"resourceType":{},"sources":{"shape":"S15"},"status":{},"updatedAt":{"shape":"Sm"}}}},"nextToken":{}}}},"ListTagsForResource":{"http":{"method":"GET","requestUri":"/tags/{resourceArn}","responseCode":200},"input":{"type":"structure","required":["resourceArn"],"members":{"resourceArn":{"location":"uri","locationName":"resourceArn"}}},"output":{"type":"structure","members":{"tags":{"shape":"Sa"}}}},"StartResourceScan":{"http":{"requestUri":"/resource/scan","responseCode":200},"input":{"type":"structure","required":["analyzerArn","resourceArn"],"members":{"analyzerArn":{},"resourceArn":{}}}},"TagResource":{"http":{"requestUri":"/tags/{resourceArn}","responseCode":200},"input":{"type":"structure","required":["resourceArn","tags"],"members":{"resourceArn":{"location":"uri","locationName":"resourceArn"},"tags":{"shape":"Sa"}}},"output":{"type":"structure","members":{}},"idempotent":true},"UntagResource":{"http":{"method":"DELETE","requestUri":"/tags/{resourceArn}","responseCode":200},"input":{"type":"structure","required":["resourceArn","tagKeys"],"members":{"resourceArn":{"location":"uri","locationName":"resourceArn"},"tagKeys":{"location":"querystring","locationName":"tagKeys","type":"list","member":{}}}},"output":{"type":"structure","members":{}},"idempotent":true},"UpdateArchiveRule":{"http":{"method":"PUT","requestUri":"/analyzer/{analyzerName}/archive-rule/{ruleName}","responseCode":200},"input":{"type":"structure","required":["analyzerName","filter","ruleName"],"members":{"analyzerName":{"location":"uri","locationName":"analyzerName"},"clientToken":{"idempotencyToken":true},"filter":{"shape":"S5"},"ruleName":{"location":"uri","locationName":"ruleName"}}},"idempotent":true},"UpdateFindings":{"http":{"method":"PUT","requestUri":"/finding","responseCode":200},"input":{"type":"structure","required":["analyzerArn","status"],"members":{"analyzerArn":{},"clientToken":{"idempotencyToken":true},"ids":{"type":"list","member":{}},"resourceArn":{},"status":{}}},"idempotent":true}},"shapes":{"S5":{"type":"map","key":{},"value":{"type":"structure","members":{"contains":{"shape":"S8"},"eq":{"shape":"S8"},"exists":{"type":"boolean"},"neq":{"shape":"S8"}}}},"S8":{"type":"list","member":{}},"Sa":{"type":"map","key":{},"value":{}},"Sl":{"type":"list","member":{}},"Sm":{"type":"timestamp","timestampFormat":"iso8601"},"Ss":{"type":"structure","required":["arn","createdAt","name","status","type"],"members":{"arn":{},"createdAt":{"shape":"Sm"},"lastResourceAnalyzed":{},"lastResourceAnalyzedAt":{"shape":"Sm"},"name":{},"status":{},"statusReason":{"type":"structure","required":["code"],"members":{"code":{}}},"tags":{"shape":"Sa"},"type":{}}},"Sy":{"type":"structure","required":["createdAt","filter","ruleName","updatedAt"],"members":{"createdAt":{"shape":"Sm"},"filter":{"shape":"S5"},"ruleName":{},"updatedAt":{"shape":"Sm"}}},"S13":{"type":"map","key":{},"value":{}},"S14":{"type":"map","key":{},"value":{}},"S15":{"type":"list","member":{"type":"structure","required":["type"],"members":{"detail":{"type":"structure","members":{"accessPointArn":{}}},"type":{}}}}}}; + let chunks = [] + let length = 0 -/***/ }), + try { + for await (const chunk of body) { + chunks.push(chunk) + length += chunk.length + if (length > CHUNK_LIMIT) { + chunks = [] + length = 0 + break + } + } + } catch { + chunks = [] + length = 0 + // Do nothing.... + } -/***/ 4599: -/***/ (function(module) { + const message = `Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ''}` -module.exports = {"version":"2.0","metadata":{"apiVersion":"2015-05-28","endpointPrefix":"iot","protocol":"rest-json","serviceFullName":"AWS IoT","serviceId":"IoT","signatureVersion":"v4","signingName":"execute-api","uid":"iot-2015-05-28"},"operations":{"AcceptCertificateTransfer":{"http":{"method":"PATCH","requestUri":"/accept-certificate-transfer/{certificateId}"},"input":{"type":"structure","required":["certificateId"],"members":{"certificateId":{"location":"uri","locationName":"certificateId"},"setAsActive":{"location":"querystring","locationName":"setAsActive","type":"boolean"}}}},"AddThingToBillingGroup":{"http":{"method":"PUT","requestUri":"/billing-groups/addThingToBillingGroup"},"input":{"type":"structure","members":{"billingGroupName":{},"billingGroupArn":{},"thingName":{},"thingArn":{}}},"output":{"type":"structure","members":{}}},"AddThingToThingGroup":{"http":{"method":"PUT","requestUri":"/thing-groups/addThingToThingGroup"},"input":{"type":"structure","members":{"thingGroupName":{},"thingGroupArn":{},"thingName":{},"thingArn":{},"overrideDynamicGroups":{"type":"boolean"}}},"output":{"type":"structure","members":{}}},"AssociateTargetsWithJob":{"http":{"requestUri":"/jobs/{jobId}/targets"},"input":{"type":"structure","required":["targets","jobId"],"members":{"targets":{"shape":"Sg"},"jobId":{"location":"uri","locationName":"jobId"},"comment":{}}},"output":{"type":"structure","members":{"jobArn":{},"jobId":{},"description":{}}}},"AttachPolicy":{"http":{"method":"PUT","requestUri":"/target-policies/{policyName}"},"input":{"type":"structure","required":["policyName","target"],"members":{"policyName":{"location":"uri","locationName":"policyName"},"target":{}}}},"AttachPrincipalPolicy":{"http":{"method":"PUT","requestUri":"/principal-policies/{policyName}"},"input":{"type":"structure","required":["policyName","principal"],"members":{"policyName":{"location":"uri","locationName":"policyName"},"principal":{"location":"header","locationName":"x-amzn-iot-principal"}}},"deprecated":true},"AttachSecurityProfile":{"http":{"method":"PUT","requestUri":"/security-profiles/{securityProfileName}/targets"},"input":{"type":"structure","required":["securityProfileName","securityProfileTargetArn"],"members":{"securityProfileName":{"location":"uri","locationName":"securityProfileName"},"securityProfileTargetArn":{"location":"querystring","locationName":"securityProfileTargetArn"}}},"output":{"type":"structure","members":{}}},"AttachThingPrincipal":{"http":{"method":"PUT","requestUri":"/things/{thingName}/principals"},"input":{"type":"structure","required":["thingName","principal"],"members":{"thingName":{"location":"uri","locationName":"thingName"},"principal":{"location":"header","locationName":"x-amzn-principal"}}},"output":{"type":"structure","members":{}}},"CancelAuditMitigationActionsTask":{"http":{"method":"PUT","requestUri":"/audit/mitigationactions/tasks/{taskId}/cancel"},"input":{"type":"structure","required":["taskId"],"members":{"taskId":{"location":"uri","locationName":"taskId"}}},"output":{"type":"structure","members":{}}},"CancelAuditTask":{"http":{"method":"PUT","requestUri":"/audit/tasks/{taskId}/cancel"},"input":{"type":"structure","required":["taskId"],"members":{"taskId":{"location":"uri","locationName":"taskId"}}},"output":{"type":"structure","members":{}}},"CancelCertificateTransfer":{"http":{"method":"PATCH","requestUri":"/cancel-certificate-transfer/{certificateId}"},"input":{"type":"structure","required":["certificateId"],"members":{"certificateId":{"location":"uri","locationName":"certificateId"}}}},"CancelJob":{"http":{"method":"PUT","requestUri":"/jobs/{jobId}/cancel"},"input":{"type":"structure","required":["jobId"],"members":{"jobId":{"location":"uri","locationName":"jobId"},"reasonCode":{},"comment":{},"force":{"location":"querystring","locationName":"force","type":"boolean"}}},"output":{"type":"structure","members":{"jobArn":{},"jobId":{},"description":{}}}},"CancelJobExecution":{"http":{"method":"PUT","requestUri":"/things/{thingName}/jobs/{jobId}/cancel"},"input":{"type":"structure","required":["jobId","thingName"],"members":{"jobId":{"location":"uri","locationName":"jobId"},"thingName":{"location":"uri","locationName":"thingName"},"force":{"location":"querystring","locationName":"force","type":"boolean"},"expectedVersion":{"type":"long"},"statusDetails":{"shape":"S1b"}}}},"ClearDefaultAuthorizer":{"http":{"method":"DELETE","requestUri":"/default-authorizer"},"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{}}},"ConfirmTopicRuleDestination":{"http":{"method":"GET","requestUri":"/confirmdestination/{confirmationToken+}"},"input":{"type":"structure","required":["confirmationToken"],"members":{"confirmationToken":{"location":"uri","locationName":"confirmationToken"}}},"output":{"type":"structure","members":{}}},"CreateAuthorizer":{"http":{"requestUri":"/authorizer/{authorizerName}"},"input":{"type":"structure","required":["authorizerName","authorizerFunctionArn"],"members":{"authorizerName":{"location":"uri","locationName":"authorizerName"},"authorizerFunctionArn":{},"tokenKeyName":{},"tokenSigningPublicKeys":{"shape":"S1n"},"status":{},"tags":{"shape":"S1r"},"signingDisabled":{"type":"boolean"}}},"output":{"type":"structure","members":{"authorizerName":{},"authorizerArn":{}}}},"CreateBillingGroup":{"http":{"requestUri":"/billing-groups/{billingGroupName}"},"input":{"type":"structure","required":["billingGroupName"],"members":{"billingGroupName":{"location":"uri","locationName":"billingGroupName"},"billingGroupProperties":{"shape":"S1z"},"tags":{"shape":"S1r"}}},"output":{"type":"structure","members":{"billingGroupName":{},"billingGroupArn":{},"billingGroupId":{}}}},"CreateCertificateFromCsr":{"http":{"requestUri":"/certificates"},"input":{"type":"structure","required":["certificateSigningRequest"],"members":{"certificateSigningRequest":{},"setAsActive":{"location":"querystring","locationName":"setAsActive","type":"boolean"}}},"output":{"type":"structure","members":{"certificateArn":{},"certificateId":{},"certificatePem":{}}}},"CreateDimension":{"http":{"requestUri":"/dimensions/{name}"},"input":{"type":"structure","required":["name","type","stringValues","clientRequestToken"],"members":{"name":{"location":"uri","locationName":"name"},"type":{},"stringValues":{"shape":"S2b"},"tags":{"shape":"S1r"},"clientRequestToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"name":{},"arn":{}}}},"CreateDomainConfiguration":{"http":{"requestUri":"/domainConfigurations/{domainConfigurationName}"},"input":{"type":"structure","required":["domainConfigurationName"],"members":{"domainConfigurationName":{"location":"uri","locationName":"domainConfigurationName"},"domainName":{},"serverCertificateArns":{"type":"list","member":{}},"validationCertificateArn":{},"authorizerConfig":{"shape":"S2l"},"serviceType":{},"tags":{"shape":"S1r"}}},"output":{"type":"structure","members":{"domainConfigurationName":{},"domainConfigurationArn":{}}}},"CreateDynamicThingGroup":{"http":{"requestUri":"/dynamic-thing-groups/{thingGroupName}"},"input":{"type":"structure","required":["thingGroupName","queryString"],"members":{"thingGroupName":{"location":"uri","locationName":"thingGroupName"},"thingGroupProperties":{"shape":"S2r"},"indexName":{},"queryString":{},"queryVersion":{},"tags":{"shape":"S1r"}}},"output":{"type":"structure","members":{"thingGroupName":{},"thingGroupArn":{},"thingGroupId":{},"indexName":{},"queryString":{},"queryVersion":{}}}},"CreateJob":{"http":{"method":"PUT","requestUri":"/jobs/{jobId}"},"input":{"type":"structure","required":["jobId","targets"],"members":{"jobId":{"location":"uri","locationName":"jobId"},"targets":{"shape":"Sg"},"documentSource":{},"document":{},"description":{},"presignedUrlConfig":{"shape":"S36"},"targetSelection":{},"jobExecutionsRolloutConfig":{"shape":"S3a"},"abortConfig":{"shape":"S3h"},"timeoutConfig":{"shape":"S3o"},"tags":{"shape":"S1r"}}},"output":{"type":"structure","members":{"jobArn":{},"jobId":{},"description":{}}}},"CreateKeysAndCertificate":{"http":{"requestUri":"/keys-and-certificate"},"input":{"type":"structure","members":{"setAsActive":{"location":"querystring","locationName":"setAsActive","type":"boolean"}}},"output":{"type":"structure","members":{"certificateArn":{},"certificateId":{},"certificatePem":{},"keyPair":{"shape":"S3t"}}}},"CreateMitigationAction":{"http":{"requestUri":"/mitigationactions/actions/{actionName}"},"input":{"type":"structure","required":["actionName","roleArn","actionParams"],"members":{"actionName":{"location":"uri","locationName":"actionName"},"roleArn":{},"actionParams":{"shape":"S3y"},"tags":{"shape":"S1r"}}},"output":{"type":"structure","members":{"actionArn":{},"actionId":{}}}},"CreateOTAUpdate":{"http":{"requestUri":"/otaUpdates/{otaUpdateId}"},"input":{"type":"structure","required":["otaUpdateId","targets","files","roleArn"],"members":{"otaUpdateId":{"location":"uri","locationName":"otaUpdateId"},"description":{},"targets":{"shape":"S4h"},"protocols":{"shape":"S4j"},"targetSelection":{},"awsJobExecutionsRolloutConfig":{"shape":"S4l"},"awsJobPresignedUrlConfig":{"shape":"S4s"},"awsJobAbortConfig":{"type":"structure","required":["abortCriteriaList"],"members":{"abortCriteriaList":{"type":"list","member":{"type":"structure","required":["failureType","action","thresholdPercentage","minNumberOfExecutedThings"],"members":{"failureType":{},"action":{},"thresholdPercentage":{"type":"double"},"minNumberOfExecutedThings":{"type":"integer"}}}}}},"awsJobTimeoutConfig":{"type":"structure","members":{"inProgressTimeoutInMinutes":{"type":"long"}}},"files":{"shape":"S53"},"roleArn":{},"additionalParameters":{"shape":"S60"},"tags":{"shape":"S1r"}}},"output":{"type":"structure","members":{"otaUpdateId":{},"awsIotJobId":{},"otaUpdateArn":{},"awsIotJobArn":{},"otaUpdateStatus":{}}}},"CreatePolicy":{"http":{"requestUri":"/policies/{policyName}"},"input":{"type":"structure","required":["policyName","policyDocument"],"members":{"policyName":{"location":"uri","locationName":"policyName"},"policyDocument":{},"tags":{"shape":"S1r"}}},"output":{"type":"structure","members":{"policyName":{},"policyArn":{},"policyDocument":{},"policyVersionId":{}}}},"CreatePolicyVersion":{"http":{"requestUri":"/policies/{policyName}/version"},"input":{"type":"structure","required":["policyName","policyDocument"],"members":{"policyName":{"location":"uri","locationName":"policyName"},"policyDocument":{},"setAsDefault":{"location":"querystring","locationName":"setAsDefault","type":"boolean"}}},"output":{"type":"structure","members":{"policyArn":{},"policyDocument":{},"policyVersionId":{},"isDefaultVersion":{"type":"boolean"}}}},"CreateProvisioningClaim":{"http":{"requestUri":"/provisioning-templates/{templateName}/provisioning-claim"},"input":{"type":"structure","required":["templateName"],"members":{"templateName":{"location":"uri","locationName":"templateName"}}},"output":{"type":"structure","members":{"certificateId":{},"certificatePem":{},"keyPair":{"shape":"S3t"},"expiration":{"type":"timestamp"}}}},"CreateProvisioningTemplate":{"http":{"requestUri":"/provisioning-templates"},"input":{"type":"structure","required":["templateName","templateBody","provisioningRoleArn"],"members":{"templateName":{},"description":{},"templateBody":{},"enabled":{"type":"boolean"},"provisioningRoleArn":{},"preProvisioningHook":{"shape":"S6n"},"tags":{"shape":"S1r"}}},"output":{"type":"structure","members":{"templateArn":{},"templateName":{},"defaultVersionId":{"type":"integer"}}}},"CreateProvisioningTemplateVersion":{"http":{"requestUri":"/provisioning-templates/{templateName}/versions"},"input":{"type":"structure","required":["templateName","templateBody"],"members":{"templateName":{"location":"uri","locationName":"templateName"},"templateBody":{},"setAsDefault":{"location":"querystring","locationName":"setAsDefault","type":"boolean"}}},"output":{"type":"structure","members":{"templateArn":{},"templateName":{},"versionId":{"type":"integer"},"isDefaultVersion":{"type":"boolean"}}}},"CreateRoleAlias":{"http":{"requestUri":"/role-aliases/{roleAlias}"},"input":{"type":"structure","required":["roleAlias","roleArn"],"members":{"roleAlias":{"location":"uri","locationName":"roleAlias"},"roleArn":{},"credentialDurationSeconds":{"type":"integer"},"tags":{"shape":"S1r"}}},"output":{"type":"structure","members":{"roleAlias":{},"roleAliasArn":{}}}},"CreateScheduledAudit":{"http":{"requestUri":"/audit/scheduledaudits/{scheduledAuditName}"},"input":{"type":"structure","required":["frequency","targetCheckNames","scheduledAuditName"],"members":{"frequency":{},"dayOfMonth":{},"dayOfWeek":{},"targetCheckNames":{"shape":"S73"},"scheduledAuditName":{"location":"uri","locationName":"scheduledAuditName"},"tags":{"shape":"S1r"}}},"output":{"type":"structure","members":{"scheduledAuditArn":{}}}},"CreateSecurityProfile":{"http":{"requestUri":"/security-profiles/{securityProfileName}"},"input":{"type":"structure","required":["securityProfileName"],"members":{"securityProfileName":{"location":"uri","locationName":"securityProfileName"},"securityProfileDescription":{},"behaviors":{"shape":"S7a"},"alertTargets":{"shape":"S7t"},"additionalMetricsToRetain":{"shape":"S7x","deprecated":true,"deprecatedMessage":"Use additionalMetricsToRetainV2."},"additionalMetricsToRetainV2":{"shape":"S7y"},"tags":{"shape":"S1r"}}},"output":{"type":"structure","members":{"securityProfileName":{},"securityProfileArn":{}}}},"CreateStream":{"http":{"requestUri":"/streams/{streamId}"},"input":{"type":"structure","required":["streamId","files","roleArn"],"members":{"streamId":{"location":"uri","locationName":"streamId"},"description":{},"files":{"shape":"S84"},"roleArn":{},"tags":{"shape":"S1r"}}},"output":{"type":"structure","members":{"streamId":{},"streamArn":{},"description":{},"streamVersion":{"type":"integer"}}}},"CreateThing":{"http":{"requestUri":"/things/{thingName}"},"input":{"type":"structure","required":["thingName"],"members":{"thingName":{"location":"uri","locationName":"thingName"},"thingTypeName":{},"attributePayload":{"shape":"S2t"},"billingGroupName":{}}},"output":{"type":"structure","members":{"thingName":{},"thingArn":{},"thingId":{}}}},"CreateThingGroup":{"http":{"requestUri":"/thing-groups/{thingGroupName}"},"input":{"type":"structure","required":["thingGroupName"],"members":{"thingGroupName":{"location":"uri","locationName":"thingGroupName"},"parentGroupName":{},"thingGroupProperties":{"shape":"S2r"},"tags":{"shape":"S1r"}}},"output":{"type":"structure","members":{"thingGroupName":{},"thingGroupArn":{},"thingGroupId":{}}}},"CreateThingType":{"http":{"requestUri":"/thing-types/{thingTypeName}"},"input":{"type":"structure","required":["thingTypeName"],"members":{"thingTypeName":{"location":"uri","locationName":"thingTypeName"},"thingTypeProperties":{"shape":"S8g"},"tags":{"shape":"S1r"}}},"output":{"type":"structure","members":{"thingTypeName":{},"thingTypeArn":{},"thingTypeId":{}}}},"CreateTopicRule":{"http":{"requestUri":"/rules/{ruleName}"},"input":{"type":"structure","required":["ruleName","topicRulePayload"],"members":{"ruleName":{"location":"uri","locationName":"ruleName"},"topicRulePayload":{"shape":"S8o"},"tags":{"location":"header","locationName":"x-amz-tagging"}},"payload":"topicRulePayload"}},"CreateTopicRuleDestination":{"http":{"requestUri":"/destinations"},"input":{"type":"structure","required":["destinationConfiguration"],"members":{"destinationConfiguration":{"type":"structure","members":{"httpUrlConfiguration":{"type":"structure","required":["confirmationUrl"],"members":{"confirmationUrl":{}}}}}}},"output":{"type":"structure","members":{"topicRuleDestination":{"shape":"Sbb"}}}},"DeleteAccountAuditConfiguration":{"http":{"method":"DELETE","requestUri":"/audit/configuration"},"input":{"type":"structure","members":{"deleteScheduledAudits":{"location":"querystring","locationName":"deleteScheduledAudits","type":"boolean"}}},"output":{"type":"structure","members":{}}},"DeleteAuthorizer":{"http":{"method":"DELETE","requestUri":"/authorizer/{authorizerName}"},"input":{"type":"structure","required":["authorizerName"],"members":{"authorizerName":{"location":"uri","locationName":"authorizerName"}}},"output":{"type":"structure","members":{}}},"DeleteBillingGroup":{"http":{"method":"DELETE","requestUri":"/billing-groups/{billingGroupName}"},"input":{"type":"structure","required":["billingGroupName"],"members":{"billingGroupName":{"location":"uri","locationName":"billingGroupName"},"expectedVersion":{"location":"querystring","locationName":"expectedVersion","type":"long"}}},"output":{"type":"structure","members":{}}},"DeleteCACertificate":{"http":{"method":"DELETE","requestUri":"/cacertificate/{caCertificateId}"},"input":{"type":"structure","required":["certificateId"],"members":{"certificateId":{"location":"uri","locationName":"caCertificateId"}}},"output":{"type":"structure","members":{}}},"DeleteCertificate":{"http":{"method":"DELETE","requestUri":"/certificates/{certificateId}"},"input":{"type":"structure","required":["certificateId"],"members":{"certificateId":{"location":"uri","locationName":"certificateId"},"forceDelete":{"location":"querystring","locationName":"forceDelete","type":"boolean"}}}},"DeleteDimension":{"http":{"method":"DELETE","requestUri":"/dimensions/{name}"},"input":{"type":"structure","required":["name"],"members":{"name":{"location":"uri","locationName":"name"}}},"output":{"type":"structure","members":{}}},"DeleteDomainConfiguration":{"http":{"method":"DELETE","requestUri":"/domainConfigurations/{domainConfigurationName}"},"input":{"type":"structure","required":["domainConfigurationName"],"members":{"domainConfigurationName":{"location":"uri","locationName":"domainConfigurationName"}}},"output":{"type":"structure","members":{}}},"DeleteDynamicThingGroup":{"http":{"method":"DELETE","requestUri":"/dynamic-thing-groups/{thingGroupName}"},"input":{"type":"structure","required":["thingGroupName"],"members":{"thingGroupName":{"location":"uri","locationName":"thingGroupName"},"expectedVersion":{"location":"querystring","locationName":"expectedVersion","type":"long"}}},"output":{"type":"structure","members":{}}},"DeleteJob":{"http":{"method":"DELETE","requestUri":"/jobs/{jobId}"},"input":{"type":"structure","required":["jobId"],"members":{"jobId":{"location":"uri","locationName":"jobId"},"force":{"location":"querystring","locationName":"force","type":"boolean"}}}},"DeleteJobExecution":{"http":{"method":"DELETE","requestUri":"/things/{thingName}/jobs/{jobId}/executionNumber/{executionNumber}"},"input":{"type":"structure","required":["jobId","thingName","executionNumber"],"members":{"jobId":{"location":"uri","locationName":"jobId"},"thingName":{"location":"uri","locationName":"thingName"},"executionNumber":{"location":"uri","locationName":"executionNumber","type":"long"},"force":{"location":"querystring","locationName":"force","type":"boolean"}}}},"DeleteMitigationAction":{"http":{"method":"DELETE","requestUri":"/mitigationactions/actions/{actionName}"},"input":{"type":"structure","required":["actionName"],"members":{"actionName":{"location":"uri","locationName":"actionName"}}},"output":{"type":"structure","members":{}}},"DeleteOTAUpdate":{"http":{"method":"DELETE","requestUri":"/otaUpdates/{otaUpdateId}"},"input":{"type":"structure","required":["otaUpdateId"],"members":{"otaUpdateId":{"location":"uri","locationName":"otaUpdateId"},"deleteStream":{"location":"querystring","locationName":"deleteStream","type":"boolean"},"forceDeleteAWSJob":{"location":"querystring","locationName":"forceDeleteAWSJob","type":"boolean"}}},"output":{"type":"structure","members":{}}},"DeletePolicy":{"http":{"method":"DELETE","requestUri":"/policies/{policyName}"},"input":{"type":"structure","required":["policyName"],"members":{"policyName":{"location":"uri","locationName":"policyName"}}}},"DeletePolicyVersion":{"http":{"method":"DELETE","requestUri":"/policies/{policyName}/version/{policyVersionId}"},"input":{"type":"structure","required":["policyName","policyVersionId"],"members":{"policyName":{"location":"uri","locationName":"policyName"},"policyVersionId":{"location":"uri","locationName":"policyVersionId"}}}},"DeleteProvisioningTemplate":{"http":{"method":"DELETE","requestUri":"/provisioning-templates/{templateName}"},"input":{"type":"structure","required":["templateName"],"members":{"templateName":{"location":"uri","locationName":"templateName"}}},"output":{"type":"structure","members":{}}},"DeleteProvisioningTemplateVersion":{"http":{"method":"DELETE","requestUri":"/provisioning-templates/{templateName}/versions/{versionId}"},"input":{"type":"structure","required":["templateName","versionId"],"members":{"templateName":{"location":"uri","locationName":"templateName"},"versionId":{"location":"uri","locationName":"versionId","type":"integer"}}},"output":{"type":"structure","members":{}}},"DeleteRegistrationCode":{"http":{"method":"DELETE","requestUri":"/registrationcode"},"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{}}},"DeleteRoleAlias":{"http":{"method":"DELETE","requestUri":"/role-aliases/{roleAlias}"},"input":{"type":"structure","required":["roleAlias"],"members":{"roleAlias":{"location":"uri","locationName":"roleAlias"}}},"output":{"type":"structure","members":{}}},"DeleteScheduledAudit":{"http":{"method":"DELETE","requestUri":"/audit/scheduledaudits/{scheduledAuditName}"},"input":{"type":"structure","required":["scheduledAuditName"],"members":{"scheduledAuditName":{"location":"uri","locationName":"scheduledAuditName"}}},"output":{"type":"structure","members":{}}},"DeleteSecurityProfile":{"http":{"method":"DELETE","requestUri":"/security-profiles/{securityProfileName}"},"input":{"type":"structure","required":["securityProfileName"],"members":{"securityProfileName":{"location":"uri","locationName":"securityProfileName"},"expectedVersion":{"location":"querystring","locationName":"expectedVersion","type":"long"}}},"output":{"type":"structure","members":{}}},"DeleteStream":{"http":{"method":"DELETE","requestUri":"/streams/{streamId}"},"input":{"type":"structure","required":["streamId"],"members":{"streamId":{"location":"uri","locationName":"streamId"}}},"output":{"type":"structure","members":{}}},"DeleteThing":{"http":{"method":"DELETE","requestUri":"/things/{thingName}"},"input":{"type":"structure","required":["thingName"],"members":{"thingName":{"location":"uri","locationName":"thingName"},"expectedVersion":{"location":"querystring","locationName":"expectedVersion","type":"long"}}},"output":{"type":"structure","members":{}}},"DeleteThingGroup":{"http":{"method":"DELETE","requestUri":"/thing-groups/{thingGroupName}"},"input":{"type":"structure","required":["thingGroupName"],"members":{"thingGroupName":{"location":"uri","locationName":"thingGroupName"},"expectedVersion":{"location":"querystring","locationName":"expectedVersion","type":"long"}}},"output":{"type":"structure","members":{}}},"DeleteThingType":{"http":{"method":"DELETE","requestUri":"/thing-types/{thingTypeName}"},"input":{"type":"structure","required":["thingTypeName"],"members":{"thingTypeName":{"location":"uri","locationName":"thingTypeName"}}},"output":{"type":"structure","members":{}}},"DeleteTopicRule":{"http":{"method":"DELETE","requestUri":"/rules/{ruleName}"},"input":{"type":"structure","required":["ruleName"],"members":{"ruleName":{"location":"uri","locationName":"ruleName"}}}},"DeleteTopicRuleDestination":{"http":{"method":"DELETE","requestUri":"/destinations/{arn+}"},"input":{"type":"structure","required":["arn"],"members":{"arn":{"location":"uri","locationName":"arn"}}},"output":{"type":"structure","members":{}}},"DeleteV2LoggingLevel":{"http":{"method":"DELETE","requestUri":"/v2LoggingLevel"},"input":{"type":"structure","required":["targetType","targetName"],"members":{"targetType":{"location":"querystring","locationName":"targetType"},"targetName":{"location":"querystring","locationName":"targetName"}}}},"DeprecateThingType":{"http":{"requestUri":"/thing-types/{thingTypeName}/deprecate"},"input":{"type":"structure","required":["thingTypeName"],"members":{"thingTypeName":{"location":"uri","locationName":"thingTypeName"},"undoDeprecate":{"type":"boolean"}}},"output":{"type":"structure","members":{}}},"DescribeAccountAuditConfiguration":{"http":{"method":"GET","requestUri":"/audit/configuration"},"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"roleArn":{},"auditNotificationTargetConfigurations":{"shape":"Sd2"},"auditCheckConfigurations":{"shape":"Sd5"}}}},"DescribeAuditFinding":{"http":{"method":"GET","requestUri":"/audit/findings/{findingId}"},"input":{"type":"structure","required":["findingId"],"members":{"findingId":{"location":"uri","locationName":"findingId"}}},"output":{"type":"structure","members":{"finding":{"shape":"Sda"}}}},"DescribeAuditMitigationActionsTask":{"http":{"method":"GET","requestUri":"/audit/mitigationactions/tasks/{taskId}"},"input":{"type":"structure","required":["taskId"],"members":{"taskId":{"location":"uri","locationName":"taskId"}}},"output":{"type":"structure","members":{"taskStatus":{},"startTime":{"type":"timestamp"},"endTime":{"type":"timestamp"},"taskStatistics":{"type":"map","key":{},"value":{"type":"structure","members":{"totalFindingsCount":{"type":"long"},"failedFindingsCount":{"type":"long"},"succeededFindingsCount":{"type":"long"},"skippedFindingsCount":{"type":"long"},"canceledFindingsCount":{"type":"long"}}}},"target":{"shape":"Sdz"},"auditCheckToActionsMapping":{"shape":"Se3"},"actionsDefinition":{"type":"list","member":{"type":"structure","members":{"name":{},"id":{},"roleArn":{},"actionParams":{"shape":"S3y"}}}}}}},"DescribeAuditTask":{"http":{"method":"GET","requestUri":"/audit/tasks/{taskId}"},"input":{"type":"structure","required":["taskId"],"members":{"taskId":{"location":"uri","locationName":"taskId"}}},"output":{"type":"structure","members":{"taskStatus":{},"taskType":{},"taskStartTime":{"type":"timestamp"},"taskStatistics":{"type":"structure","members":{"totalChecks":{"type":"integer"},"inProgressChecks":{"type":"integer"},"waitingForDataCollectionChecks":{"type":"integer"},"compliantChecks":{"type":"integer"},"nonCompliantChecks":{"type":"integer"},"failedChecks":{"type":"integer"},"canceledChecks":{"type":"integer"}}},"scheduledAuditName":{},"auditDetails":{"type":"map","key":{},"value":{"type":"structure","members":{"checkRunStatus":{},"checkCompliant":{"type":"boolean"},"totalResourcesCount":{"type":"long"},"nonCompliantResourcesCount":{"type":"long"},"errorCode":{},"message":{}}}}}}},"DescribeAuthorizer":{"http":{"method":"GET","requestUri":"/authorizer/{authorizerName}"},"input":{"type":"structure","required":["authorizerName"],"members":{"authorizerName":{"location":"uri","locationName":"authorizerName"}}},"output":{"type":"structure","members":{"authorizerDescription":{"shape":"Set"}}}},"DescribeBillingGroup":{"http":{"method":"GET","requestUri":"/billing-groups/{billingGroupName}"},"input":{"type":"structure","required":["billingGroupName"],"members":{"billingGroupName":{"location":"uri","locationName":"billingGroupName"}}},"output":{"type":"structure","members":{"billingGroupName":{},"billingGroupId":{},"billingGroupArn":{},"version":{"type":"long"},"billingGroupProperties":{"shape":"S1z"},"billingGroupMetadata":{"type":"structure","members":{"creationDate":{"type":"timestamp"}}}}}},"DescribeCACertificate":{"http":{"method":"GET","requestUri":"/cacertificate/{caCertificateId}"},"input":{"type":"structure","required":["certificateId"],"members":{"certificateId":{"location":"uri","locationName":"caCertificateId"}}},"output":{"type":"structure","members":{"certificateDescription":{"type":"structure","members":{"certificateArn":{},"certificateId":{},"status":{},"certificatePem":{},"ownedBy":{},"creationDate":{"type":"timestamp"},"autoRegistrationStatus":{},"lastModifiedDate":{"type":"timestamp"},"customerVersion":{"type":"integer"},"generationId":{},"validity":{"shape":"Sf6"}}},"registrationConfig":{"shape":"Sf7"}}}},"DescribeCertificate":{"http":{"method":"GET","requestUri":"/certificates/{certificateId}"},"input":{"type":"structure","required":["certificateId"],"members":{"certificateId":{"location":"uri","locationName":"certificateId"}}},"output":{"type":"structure","members":{"certificateDescription":{"type":"structure","members":{"certificateArn":{},"certificateId":{},"caCertificateId":{},"status":{},"certificatePem":{},"ownedBy":{},"previousOwnedBy":{},"creationDate":{"type":"timestamp"},"lastModifiedDate":{"type":"timestamp"},"customerVersion":{"type":"integer"},"transferData":{"type":"structure","members":{"transferMessage":{},"rejectReason":{},"transferDate":{"type":"timestamp"},"acceptDate":{"type":"timestamp"},"rejectDate":{"type":"timestamp"}}},"generationId":{},"validity":{"shape":"Sf6"},"certificateMode":{}}}}}},"DescribeDefaultAuthorizer":{"http":{"method":"GET","requestUri":"/default-authorizer"},"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"authorizerDescription":{"shape":"Set"}}}},"DescribeDimension":{"http":{"method":"GET","requestUri":"/dimensions/{name}"},"input":{"type":"structure","required":["name"],"members":{"name":{"location":"uri","locationName":"name"}}},"output":{"type":"structure","members":{"name":{},"arn":{},"type":{},"stringValues":{"shape":"S2b"},"creationDate":{"type":"timestamp"},"lastModifiedDate":{"type":"timestamp"}}}},"DescribeDomainConfiguration":{"http":{"method":"GET","requestUri":"/domainConfigurations/{domainConfigurationName}"},"input":{"type":"structure","required":["domainConfigurationName"],"members":{"domainConfigurationName":{"location":"uri","locationName":"domainConfigurationName"}}},"output":{"type":"structure","members":{"domainConfigurationName":{},"domainConfigurationArn":{},"domainName":{},"serverCertificates":{"type":"list","member":{"type":"structure","members":{"serverCertificateArn":{},"serverCertificateStatus":{},"serverCertificateStatusDetail":{}}}},"authorizerConfig":{"shape":"S2l"},"domainConfigurationStatus":{},"serviceType":{},"domainType":{}}}},"DescribeEndpoint":{"http":{"method":"GET","requestUri":"/endpoint"},"input":{"type":"structure","members":{"endpointType":{"location":"querystring","locationName":"endpointType"}}},"output":{"type":"structure","members":{"endpointAddress":{}}}},"DescribeEventConfigurations":{"http":{"method":"GET","requestUri":"/event-configurations"},"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"eventConfigurations":{"shape":"Sfy"},"creationDate":{"type":"timestamp"},"lastModifiedDate":{"type":"timestamp"}}}},"DescribeIndex":{"http":{"method":"GET","requestUri":"/indices/{indexName}"},"input":{"type":"structure","required":["indexName"],"members":{"indexName":{"location":"uri","locationName":"indexName"}}},"output":{"type":"structure","members":{"indexName":{},"indexStatus":{},"schema":{}}}},"DescribeJob":{"http":{"method":"GET","requestUri":"/jobs/{jobId}"},"input":{"type":"structure","required":["jobId"],"members":{"jobId":{"location":"uri","locationName":"jobId"}}},"output":{"type":"structure","members":{"documentSource":{},"job":{"type":"structure","members":{"jobArn":{},"jobId":{},"targetSelection":{},"status":{},"forceCanceled":{"type":"boolean"},"reasonCode":{},"comment":{},"targets":{"shape":"Sg"},"description":{},"presignedUrlConfig":{"shape":"S36"},"jobExecutionsRolloutConfig":{"shape":"S3a"},"abortConfig":{"shape":"S3h"},"createdAt":{"type":"timestamp"},"lastUpdatedAt":{"type":"timestamp"},"completedAt":{"type":"timestamp"},"jobProcessDetails":{"type":"structure","members":{"processingTargets":{"type":"list","member":{}},"numberOfCanceledThings":{"type":"integer"},"numberOfSucceededThings":{"type":"integer"},"numberOfFailedThings":{"type":"integer"},"numberOfRejectedThings":{"type":"integer"},"numberOfQueuedThings":{"type":"integer"},"numberOfInProgressThings":{"type":"integer"},"numberOfRemovedThings":{"type":"integer"},"numberOfTimedOutThings":{"type":"integer"}}},"timeoutConfig":{"shape":"S3o"}}}}}},"DescribeJobExecution":{"http":{"method":"GET","requestUri":"/things/{thingName}/jobs/{jobId}"},"input":{"type":"structure","required":["jobId","thingName"],"members":{"jobId":{"location":"uri","locationName":"jobId"},"thingName":{"location":"uri","locationName":"thingName"},"executionNumber":{"location":"querystring","locationName":"executionNumber","type":"long"}}},"output":{"type":"structure","members":{"execution":{"type":"structure","members":{"jobId":{},"status":{},"forceCanceled":{"type":"boolean"},"statusDetails":{"type":"structure","members":{"detailsMap":{"shape":"S1b"}}},"thingArn":{},"queuedAt":{"type":"timestamp"},"startedAt":{"type":"timestamp"},"lastUpdatedAt":{"type":"timestamp"},"executionNumber":{"type":"long"},"versionNumber":{"type":"long"},"approximateSecondsBeforeTimedOut":{"type":"long"}}}}}},"DescribeMitigationAction":{"http":{"method":"GET","requestUri":"/mitigationactions/actions/{actionName}"},"input":{"type":"structure","required":["actionName"],"members":{"actionName":{"location":"uri","locationName":"actionName"}}},"output":{"type":"structure","members":{"actionName":{},"actionType":{},"actionArn":{},"actionId":{},"roleArn":{},"actionParams":{"shape":"S3y"},"creationDate":{"type":"timestamp"},"lastModifiedDate":{"type":"timestamp"}}}},"DescribeProvisioningTemplate":{"http":{"method":"GET","requestUri":"/provisioning-templates/{templateName}"},"input":{"type":"structure","required":["templateName"],"members":{"templateName":{"location":"uri","locationName":"templateName"}}},"output":{"type":"structure","members":{"templateArn":{},"templateName":{},"description":{},"creationDate":{"type":"timestamp"},"lastModifiedDate":{"type":"timestamp"},"defaultVersionId":{"type":"integer"},"templateBody":{},"enabled":{"type":"boolean"},"provisioningRoleArn":{},"preProvisioningHook":{"shape":"S6n"}}}},"DescribeProvisioningTemplateVersion":{"http":{"method":"GET","requestUri":"/provisioning-templates/{templateName}/versions/{versionId}"},"input":{"type":"structure","required":["templateName","versionId"],"members":{"templateName":{"location":"uri","locationName":"templateName"},"versionId":{"location":"uri","locationName":"versionId","type":"integer"}}},"output":{"type":"structure","members":{"versionId":{"type":"integer"},"creationDate":{"type":"timestamp"},"templateBody":{},"isDefaultVersion":{"type":"boolean"}}}},"DescribeRoleAlias":{"http":{"method":"GET","requestUri":"/role-aliases/{roleAlias}"},"input":{"type":"structure","required":["roleAlias"],"members":{"roleAlias":{"location":"uri","locationName":"roleAlias"}}},"output":{"type":"structure","members":{"roleAliasDescription":{"type":"structure","members":{"roleAlias":{},"roleAliasArn":{},"roleArn":{},"owner":{},"credentialDurationSeconds":{"type":"integer"},"creationDate":{"type":"timestamp"},"lastModifiedDate":{"type":"timestamp"}}}}}},"DescribeScheduledAudit":{"http":{"method":"GET","requestUri":"/audit/scheduledaudits/{scheduledAuditName}"},"input":{"type":"structure","required":["scheduledAuditName"],"members":{"scheduledAuditName":{"location":"uri","locationName":"scheduledAuditName"}}},"output":{"type":"structure","members":{"frequency":{},"dayOfMonth":{},"dayOfWeek":{},"targetCheckNames":{"shape":"S73"},"scheduledAuditName":{},"scheduledAuditArn":{}}}},"DescribeSecurityProfile":{"http":{"method":"GET","requestUri":"/security-profiles/{securityProfileName}"},"input":{"type":"structure","required":["securityProfileName"],"members":{"securityProfileName":{"location":"uri","locationName":"securityProfileName"}}},"output":{"type":"structure","members":{"securityProfileName":{},"securityProfileArn":{},"securityProfileDescription":{},"behaviors":{"shape":"S7a"},"alertTargets":{"shape":"S7t"},"additionalMetricsToRetain":{"shape":"S7x","deprecated":true,"deprecatedMessage":"Use additionalMetricsToRetainV2."},"additionalMetricsToRetainV2":{"shape":"S7y"},"version":{"type":"long"},"creationDate":{"type":"timestamp"},"lastModifiedDate":{"type":"timestamp"}}}},"DescribeStream":{"http":{"method":"GET","requestUri":"/streams/{streamId}"},"input":{"type":"structure","required":["streamId"],"members":{"streamId":{"location":"uri","locationName":"streamId"}}},"output":{"type":"structure","members":{"streamInfo":{"type":"structure","members":{"streamId":{},"streamArn":{},"streamVersion":{"type":"integer"},"description":{},"files":{"shape":"S84"},"createdAt":{"type":"timestamp"},"lastUpdatedAt":{"type":"timestamp"},"roleArn":{}}}}}},"DescribeThing":{"http":{"method":"GET","requestUri":"/things/{thingName}"},"input":{"type":"structure","required":["thingName"],"members":{"thingName":{"location":"uri","locationName":"thingName"}}},"output":{"type":"structure","members":{"defaultClientId":{},"thingName":{},"thingId":{},"thingArn":{},"thingTypeName":{},"attributes":{"shape":"S2u"},"version":{"type":"long"},"billingGroupName":{}}}},"DescribeThingGroup":{"http":{"method":"GET","requestUri":"/thing-groups/{thingGroupName}"},"input":{"type":"structure","required":["thingGroupName"],"members":{"thingGroupName":{"location":"uri","locationName":"thingGroupName"}}},"output":{"type":"structure","members":{"thingGroupName":{},"thingGroupId":{},"thingGroupArn":{},"version":{"type":"long"},"thingGroupProperties":{"shape":"S2r"},"thingGroupMetadata":{"type":"structure","members":{"parentGroupName":{},"rootToParentThingGroups":{"shape":"Shf"},"creationDate":{"type":"timestamp"}}},"indexName":{},"queryString":{},"queryVersion":{},"status":{}}}},"DescribeThingRegistrationTask":{"http":{"method":"GET","requestUri":"/thing-registration-tasks/{taskId}"},"input":{"type":"structure","required":["taskId"],"members":{"taskId":{"location":"uri","locationName":"taskId"}}},"output":{"type":"structure","members":{"taskId":{},"creationDate":{"type":"timestamp"},"lastModifiedDate":{"type":"timestamp"},"templateBody":{},"inputFileBucket":{},"inputFileKey":{},"roleArn":{},"status":{},"message":{},"successCount":{"type":"integer"},"failureCount":{"type":"integer"},"percentageProgress":{"type":"integer"}}}},"DescribeThingType":{"http":{"method":"GET","requestUri":"/thing-types/{thingTypeName}"},"input":{"type":"structure","required":["thingTypeName"],"members":{"thingTypeName":{"location":"uri","locationName":"thingTypeName"}}},"output":{"type":"structure","members":{"thingTypeName":{},"thingTypeId":{},"thingTypeArn":{},"thingTypeProperties":{"shape":"S8g"},"thingTypeMetadata":{"shape":"Shs"}}}},"DetachPolicy":{"http":{"requestUri":"/target-policies/{policyName}"},"input":{"type":"structure","required":["policyName","target"],"members":{"policyName":{"location":"uri","locationName":"policyName"},"target":{}}}},"DetachPrincipalPolicy":{"http":{"method":"DELETE","requestUri":"/principal-policies/{policyName}"},"input":{"type":"structure","required":["policyName","principal"],"members":{"policyName":{"location":"uri","locationName":"policyName"},"principal":{"location":"header","locationName":"x-amzn-iot-principal"}}},"deprecated":true},"DetachSecurityProfile":{"http":{"method":"DELETE","requestUri":"/security-profiles/{securityProfileName}/targets"},"input":{"type":"structure","required":["securityProfileName","securityProfileTargetArn"],"members":{"securityProfileName":{"location":"uri","locationName":"securityProfileName"},"securityProfileTargetArn":{"location":"querystring","locationName":"securityProfileTargetArn"}}},"output":{"type":"structure","members":{}}},"DetachThingPrincipal":{"http":{"method":"DELETE","requestUri":"/things/{thingName}/principals"},"input":{"type":"structure","required":["thingName","principal"],"members":{"thingName":{"location":"uri","locationName":"thingName"},"principal":{"location":"header","locationName":"x-amzn-principal"}}},"output":{"type":"structure","members":{}}},"DisableTopicRule":{"http":{"requestUri":"/rules/{ruleName}/disable"},"input":{"type":"structure","required":["ruleName"],"members":{"ruleName":{"location":"uri","locationName":"ruleName"}}}},"EnableTopicRule":{"http":{"requestUri":"/rules/{ruleName}/enable"},"input":{"type":"structure","required":["ruleName"],"members":{"ruleName":{"location":"uri","locationName":"ruleName"}}}},"GetCardinality":{"http":{"requestUri":"/indices/cardinality"},"input":{"type":"structure","required":["queryString"],"members":{"indexName":{},"queryString":{},"aggregationField":{},"queryVersion":{}}},"output":{"type":"structure","members":{"cardinality":{"type":"integer"}}}},"GetEffectivePolicies":{"http":{"requestUri":"/effective-policies"},"input":{"type":"structure","members":{"principal":{},"cognitoIdentityPoolId":{},"thingName":{"location":"querystring","locationName":"thingName"}}},"output":{"type":"structure","members":{"effectivePolicies":{"type":"list","member":{"type":"structure","members":{"policyName":{},"policyArn":{},"policyDocument":{}}}}}}},"GetIndexingConfiguration":{"http":{"method":"GET","requestUri":"/indexing/config"},"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"thingIndexingConfiguration":{"shape":"Sic"},"thingGroupIndexingConfiguration":{"shape":"Sij"}}}},"GetJobDocument":{"http":{"method":"GET","requestUri":"/jobs/{jobId}/job-document"},"input":{"type":"structure","required":["jobId"],"members":{"jobId":{"location":"uri","locationName":"jobId"}}},"output":{"type":"structure","members":{"document":{}}}},"GetLoggingOptions":{"http":{"method":"GET","requestUri":"/loggingOptions"},"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"roleArn":{},"logLevel":{}}}},"GetOTAUpdate":{"http":{"method":"GET","requestUri":"/otaUpdates/{otaUpdateId}"},"input":{"type":"structure","required":["otaUpdateId"],"members":{"otaUpdateId":{"location":"uri","locationName":"otaUpdateId"}}},"output":{"type":"structure","members":{"otaUpdateInfo":{"type":"structure","members":{"otaUpdateId":{},"otaUpdateArn":{},"creationDate":{"type":"timestamp"},"lastModifiedDate":{"type":"timestamp"},"description":{},"targets":{"shape":"S4h"},"protocols":{"shape":"S4j"},"awsJobExecutionsRolloutConfig":{"shape":"S4l"},"awsJobPresignedUrlConfig":{"shape":"S4s"},"targetSelection":{},"otaUpdateFiles":{"shape":"S53"},"otaUpdateStatus":{},"awsIotJobId":{},"awsIotJobArn":{},"errorInfo":{"type":"structure","members":{"code":{},"message":{}}},"additionalParameters":{"shape":"S60"}}}}}},"GetPercentiles":{"http":{"requestUri":"/indices/percentiles"},"input":{"type":"structure","required":["queryString"],"members":{"indexName":{},"queryString":{},"aggregationField":{},"queryVersion":{},"percents":{"type":"list","member":{"type":"double"}}}},"output":{"type":"structure","members":{"percentiles":{"type":"list","member":{"type":"structure","members":{"percent":{"type":"double"},"value":{"type":"double"}}}}}}},"GetPolicy":{"http":{"method":"GET","requestUri":"/policies/{policyName}"},"input":{"type":"structure","required":["policyName"],"members":{"policyName":{"location":"uri","locationName":"policyName"}}},"output":{"type":"structure","members":{"policyName":{},"policyArn":{},"policyDocument":{},"defaultVersionId":{},"creationDate":{"type":"timestamp"},"lastModifiedDate":{"type":"timestamp"},"generationId":{}}}},"GetPolicyVersion":{"http":{"method":"GET","requestUri":"/policies/{policyName}/version/{policyVersionId}"},"input":{"type":"structure","required":["policyName","policyVersionId"],"members":{"policyName":{"location":"uri","locationName":"policyName"},"policyVersionId":{"location":"uri","locationName":"policyVersionId"}}},"output":{"type":"structure","members":{"policyArn":{},"policyName":{},"policyDocument":{},"policyVersionId":{},"isDefaultVersion":{"type":"boolean"},"creationDate":{"type":"timestamp"},"lastModifiedDate":{"type":"timestamp"},"generationId":{}}}},"GetRegistrationCode":{"http":{"method":"GET","requestUri":"/registrationcode"},"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"registrationCode":{}}}},"GetStatistics":{"http":{"requestUri":"/indices/statistics"},"input":{"type":"structure","required":["queryString"],"members":{"indexName":{},"queryString":{},"aggregationField":{},"queryVersion":{}}},"output":{"type":"structure","members":{"statistics":{"type":"structure","members":{"count":{"type":"integer"},"average":{"type":"double"},"sum":{"type":"double"},"minimum":{"type":"double"},"maximum":{"type":"double"},"sumOfSquares":{"type":"double"},"variance":{"type":"double"},"stdDeviation":{"type":"double"}}}}}},"GetTopicRule":{"http":{"method":"GET","requestUri":"/rules/{ruleName}"},"input":{"type":"structure","required":["ruleName"],"members":{"ruleName":{"location":"uri","locationName":"ruleName"}}},"output":{"type":"structure","members":{"ruleArn":{},"rule":{"type":"structure","members":{"ruleName":{},"sql":{},"description":{},"createdAt":{"type":"timestamp"},"actions":{"shape":"S8r"},"ruleDisabled":{"type":"boolean"},"awsIotSqlVersion":{},"errorAction":{"shape":"S8s"}}}}}},"GetTopicRuleDestination":{"http":{"method":"GET","requestUri":"/destinations/{arn+}"},"input":{"type":"structure","required":["arn"],"members":{"arn":{"location":"uri","locationName":"arn"}}},"output":{"type":"structure","members":{"topicRuleDestination":{"shape":"Sbb"}}}},"GetV2LoggingOptions":{"http":{"method":"GET","requestUri":"/v2LoggingOptions"},"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"roleArn":{},"defaultLogLevel":{},"disableAllLogs":{"type":"boolean"}}}},"ListActiveViolations":{"http":{"method":"GET","requestUri":"/active-violations"},"input":{"type":"structure","members":{"thingName":{"location":"querystring","locationName":"thingName"},"securityProfileName":{"location":"querystring","locationName":"securityProfileName"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"activeViolations":{"type":"list","member":{"type":"structure","members":{"violationId":{},"thingName":{},"securityProfileName":{},"behavior":{"shape":"S7b"},"lastViolationValue":{"shape":"S7i"},"lastViolationTime":{"type":"timestamp"},"violationStartTime":{"type":"timestamp"}}}},"nextToken":{}}}},"ListAttachedPolicies":{"http":{"requestUri":"/attached-policies/{target}"},"input":{"type":"structure","required":["target"],"members":{"target":{"location":"uri","locationName":"target"},"recursive":{"location":"querystring","locationName":"recursive","type":"boolean"},"marker":{"location":"querystring","locationName":"marker"},"pageSize":{"location":"querystring","locationName":"pageSize","type":"integer"}}},"output":{"type":"structure","members":{"policies":{"shape":"Sk6"},"nextMarker":{}}}},"ListAuditFindings":{"http":{"requestUri":"/audit/findings"},"input":{"type":"structure","members":{"taskId":{},"checkName":{},"resourceIdentifier":{"shape":"Sdf"},"maxResults":{"type":"integer"},"nextToken":{},"startTime":{"type":"timestamp"},"endTime":{"type":"timestamp"}}},"output":{"type":"structure","members":{"findings":{"type":"list","member":{"shape":"Sda"}},"nextToken":{}}}},"ListAuditMitigationActionsExecutions":{"http":{"method":"GET","requestUri":"/audit/mitigationactions/executions"},"input":{"type":"structure","required":["taskId","findingId"],"members":{"taskId":{"location":"querystring","locationName":"taskId"},"actionStatus":{"location":"querystring","locationName":"actionStatus"},"findingId":{"location":"querystring","locationName":"findingId"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"nextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"actionsExecutions":{"type":"list","member":{"type":"structure","members":{"taskId":{},"findingId":{},"actionName":{},"actionId":{},"status":{},"startTime":{"type":"timestamp"},"endTime":{"type":"timestamp"},"errorCode":{},"message":{}}}},"nextToken":{}}}},"ListAuditMitigationActionsTasks":{"http":{"method":"GET","requestUri":"/audit/mitigationactions/tasks"},"input":{"type":"structure","required":["startTime","endTime"],"members":{"auditTaskId":{"location":"querystring","locationName":"auditTaskId"},"findingId":{"location":"querystring","locationName":"findingId"},"taskStatus":{"location":"querystring","locationName":"taskStatus"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"nextToken":{"location":"querystring","locationName":"nextToken"},"startTime":{"location":"querystring","locationName":"startTime","type":"timestamp"},"endTime":{"location":"querystring","locationName":"endTime","type":"timestamp"}}},"output":{"type":"structure","members":{"tasks":{"type":"list","member":{"type":"structure","members":{"taskId":{},"startTime":{"type":"timestamp"},"taskStatus":{}}}},"nextToken":{}}}},"ListAuditTasks":{"http":{"method":"GET","requestUri":"/audit/tasks"},"input":{"type":"structure","required":["startTime","endTime"],"members":{"startTime":{"location":"querystring","locationName":"startTime","type":"timestamp"},"endTime":{"location":"querystring","locationName":"endTime","type":"timestamp"},"taskType":{"location":"querystring","locationName":"taskType"},"taskStatus":{"location":"querystring","locationName":"taskStatus"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"tasks":{"type":"list","member":{"type":"structure","members":{"taskId":{},"taskStatus":{},"taskType":{}}}},"nextToken":{}}}},"ListAuthorizers":{"http":{"method":"GET","requestUri":"/authorizers/"},"input":{"type":"structure","members":{"pageSize":{"location":"querystring","locationName":"pageSize","type":"integer"},"marker":{"location":"querystring","locationName":"marker"},"ascendingOrder":{"location":"querystring","locationName":"isAscendingOrder","type":"boolean"},"status":{"location":"querystring","locationName":"status"}}},"output":{"type":"structure","members":{"authorizers":{"type":"list","member":{"type":"structure","members":{"authorizerName":{},"authorizerArn":{}}}},"nextMarker":{}}}},"ListBillingGroups":{"http":{"method":"GET","requestUri":"/billing-groups"},"input":{"type":"structure","members":{"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"namePrefixFilter":{"location":"querystring","locationName":"namePrefixFilter"}}},"output":{"type":"structure","members":{"billingGroups":{"type":"list","member":{"shape":"Shg"}},"nextToken":{}}}},"ListCACertificates":{"http":{"method":"GET","requestUri":"/cacertificates"},"input":{"type":"structure","members":{"pageSize":{"location":"querystring","locationName":"pageSize","type":"integer"},"marker":{"location":"querystring","locationName":"marker"},"ascendingOrder":{"location":"querystring","locationName":"isAscendingOrder","type":"boolean"}}},"output":{"type":"structure","members":{"certificates":{"type":"list","member":{"type":"structure","members":{"certificateArn":{},"certificateId":{},"status":{},"creationDate":{"type":"timestamp"}}}},"nextMarker":{}}}},"ListCertificates":{"http":{"method":"GET","requestUri":"/certificates"},"input":{"type":"structure","members":{"pageSize":{"location":"querystring","locationName":"pageSize","type":"integer"},"marker":{"location":"querystring","locationName":"marker"},"ascendingOrder":{"location":"querystring","locationName":"isAscendingOrder","type":"boolean"}}},"output":{"type":"structure","members":{"certificates":{"shape":"Sl3"},"nextMarker":{}}}},"ListCertificatesByCA":{"http":{"method":"GET","requestUri":"/certificates-by-ca/{caCertificateId}"},"input":{"type":"structure","required":["caCertificateId"],"members":{"caCertificateId":{"location":"uri","locationName":"caCertificateId"},"pageSize":{"location":"querystring","locationName":"pageSize","type":"integer"},"marker":{"location":"querystring","locationName":"marker"},"ascendingOrder":{"location":"querystring","locationName":"isAscendingOrder","type":"boolean"}}},"output":{"type":"structure","members":{"certificates":{"shape":"Sl3"},"nextMarker":{}}}},"ListDimensions":{"http":{"method":"GET","requestUri":"/dimensions"},"input":{"type":"structure","members":{"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"dimensionNames":{"type":"list","member":{}},"nextToken":{}}}},"ListDomainConfigurations":{"http":{"method":"GET","requestUri":"/domainConfigurations"},"input":{"type":"structure","members":{"marker":{"location":"querystring","locationName":"marker"},"pageSize":{"location":"querystring","locationName":"pageSize","type":"integer"},"serviceType":{"location":"querystring","locationName":"serviceType"}}},"output":{"type":"structure","members":{"domainConfigurations":{"type":"list","member":{"type":"structure","members":{"domainConfigurationName":{},"domainConfigurationArn":{},"serviceType":{}}}},"nextMarker":{}}}},"ListIndices":{"http":{"method":"GET","requestUri":"/indices"},"input":{"type":"structure","members":{"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"indexNames":{"type":"list","member":{}},"nextToken":{}}}},"ListJobExecutionsForJob":{"http":{"method":"GET","requestUri":"/jobs/{jobId}/things"},"input":{"type":"structure","required":["jobId"],"members":{"jobId":{"location":"uri","locationName":"jobId"},"status":{"location":"querystring","locationName":"status"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"nextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"executionSummaries":{"type":"list","member":{"type":"structure","members":{"thingArn":{},"jobExecutionSummary":{"shape":"Sln"}}}},"nextToken":{}}}},"ListJobExecutionsForThing":{"http":{"method":"GET","requestUri":"/things/{thingName}/jobs"},"input":{"type":"structure","required":["thingName"],"members":{"thingName":{"location":"uri","locationName":"thingName"},"status":{"location":"querystring","locationName":"status"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"nextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"executionSummaries":{"type":"list","member":{"type":"structure","members":{"jobId":{},"jobExecutionSummary":{"shape":"Sln"}}}},"nextToken":{}}}},"ListJobs":{"http":{"method":"GET","requestUri":"/jobs"},"input":{"type":"structure","members":{"status":{"location":"querystring","locationName":"status"},"targetSelection":{"location":"querystring","locationName":"targetSelection"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"nextToken":{"location":"querystring","locationName":"nextToken"},"thingGroupName":{"location":"querystring","locationName":"thingGroupName"},"thingGroupId":{"location":"querystring","locationName":"thingGroupId"}}},"output":{"type":"structure","members":{"jobs":{"type":"list","member":{"type":"structure","members":{"jobArn":{},"jobId":{},"thingGroupId":{},"targetSelection":{},"status":{},"createdAt":{"type":"timestamp"},"lastUpdatedAt":{"type":"timestamp"},"completedAt":{"type":"timestamp"}}}},"nextToken":{}}}},"ListMitigationActions":{"http":{"method":"GET","requestUri":"/mitigationactions/actions"},"input":{"type":"structure","members":{"actionType":{"location":"querystring","locationName":"actionType"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"nextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"actionIdentifiers":{"type":"list","member":{"type":"structure","members":{"actionName":{},"actionArn":{},"creationDate":{"type":"timestamp"}}}},"nextToken":{}}}},"ListOTAUpdates":{"http":{"method":"GET","requestUri":"/otaUpdates"},"input":{"type":"structure","members":{"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"nextToken":{"location":"querystring","locationName":"nextToken"},"otaUpdateStatus":{"location":"querystring","locationName":"otaUpdateStatus"}}},"output":{"type":"structure","members":{"otaUpdates":{"type":"list","member":{"type":"structure","members":{"otaUpdateId":{},"otaUpdateArn":{},"creationDate":{"type":"timestamp"}}}},"nextToken":{}}}},"ListOutgoingCertificates":{"http":{"method":"GET","requestUri":"/certificates-out-going"},"input":{"type":"structure","members":{"pageSize":{"location":"querystring","locationName":"pageSize","type":"integer"},"marker":{"location":"querystring","locationName":"marker"},"ascendingOrder":{"location":"querystring","locationName":"isAscendingOrder","type":"boolean"}}},"output":{"type":"structure","members":{"outgoingCertificates":{"type":"list","member":{"type":"structure","members":{"certificateArn":{},"certificateId":{},"transferredTo":{},"transferDate":{"type":"timestamp"},"transferMessage":{},"creationDate":{"type":"timestamp"}}}},"nextMarker":{}}}},"ListPolicies":{"http":{"method":"GET","requestUri":"/policies"},"input":{"type":"structure","members":{"marker":{"location":"querystring","locationName":"marker"},"pageSize":{"location":"querystring","locationName":"pageSize","type":"integer"},"ascendingOrder":{"location":"querystring","locationName":"isAscendingOrder","type":"boolean"}}},"output":{"type":"structure","members":{"policies":{"shape":"Sk6"},"nextMarker":{}}}},"ListPolicyPrincipals":{"http":{"method":"GET","requestUri":"/policy-principals"},"input":{"type":"structure","required":["policyName"],"members":{"policyName":{"location":"header","locationName":"x-amzn-iot-policy"},"marker":{"location":"querystring","locationName":"marker"},"pageSize":{"location":"querystring","locationName":"pageSize","type":"integer"},"ascendingOrder":{"location":"querystring","locationName":"isAscendingOrder","type":"boolean"}}},"output":{"type":"structure","members":{"principals":{"shape":"Smc"},"nextMarker":{}}},"deprecated":true},"ListPolicyVersions":{"http":{"method":"GET","requestUri":"/policies/{policyName}/version"},"input":{"type":"structure","required":["policyName"],"members":{"policyName":{"location":"uri","locationName":"policyName"}}},"output":{"type":"structure","members":{"policyVersions":{"type":"list","member":{"type":"structure","members":{"versionId":{},"isDefaultVersion":{"type":"boolean"},"createDate":{"type":"timestamp"}}}}}}},"ListPrincipalPolicies":{"http":{"method":"GET","requestUri":"/principal-policies"},"input":{"type":"structure","required":["principal"],"members":{"principal":{"location":"header","locationName":"x-amzn-iot-principal"},"marker":{"location":"querystring","locationName":"marker"},"pageSize":{"location":"querystring","locationName":"pageSize","type":"integer"},"ascendingOrder":{"location":"querystring","locationName":"isAscendingOrder","type":"boolean"}}},"output":{"type":"structure","members":{"policies":{"shape":"Sk6"},"nextMarker":{}}},"deprecated":true},"ListPrincipalThings":{"http":{"method":"GET","requestUri":"/principals/things"},"input":{"type":"structure","required":["principal"],"members":{"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"principal":{"location":"header","locationName":"x-amzn-principal"}}},"output":{"type":"structure","members":{"things":{"shape":"Smm"},"nextToken":{}}}},"ListProvisioningTemplateVersions":{"http":{"method":"GET","requestUri":"/provisioning-templates/{templateName}/versions"},"input":{"type":"structure","required":["templateName"],"members":{"templateName":{"location":"uri","locationName":"templateName"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"nextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"versions":{"type":"list","member":{"type":"structure","members":{"versionId":{"type":"integer"},"creationDate":{"type":"timestamp"},"isDefaultVersion":{"type":"boolean"}}}},"nextToken":{}}}},"ListProvisioningTemplates":{"http":{"method":"GET","requestUri":"/provisioning-templates"},"input":{"type":"structure","members":{"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"nextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"templates":{"type":"list","member":{"type":"structure","members":{"templateArn":{},"templateName":{},"description":{},"creationDate":{"type":"timestamp"},"lastModifiedDate":{"type":"timestamp"},"enabled":{"type":"boolean"}}}},"nextToken":{}}}},"ListRoleAliases":{"http":{"method":"GET","requestUri":"/role-aliases"},"input":{"type":"structure","members":{"pageSize":{"location":"querystring","locationName":"pageSize","type":"integer"},"marker":{"location":"querystring","locationName":"marker"},"ascendingOrder":{"location":"querystring","locationName":"isAscendingOrder","type":"boolean"}}},"output":{"type":"structure","members":{"roleAliases":{"type":"list","member":{}},"nextMarker":{}}}},"ListScheduledAudits":{"http":{"method":"GET","requestUri":"/audit/scheduledaudits"},"input":{"type":"structure","members":{"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"scheduledAudits":{"type":"list","member":{"type":"structure","members":{"scheduledAuditName":{},"scheduledAuditArn":{},"frequency":{},"dayOfMonth":{},"dayOfWeek":{}}}},"nextToken":{}}}},"ListSecurityProfiles":{"http":{"method":"GET","requestUri":"/security-profiles"},"input":{"type":"structure","members":{"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"dimensionName":{"location":"querystring","locationName":"dimensionName"}}},"output":{"type":"structure","members":{"securityProfileIdentifiers":{"type":"list","member":{"shape":"Sn5"}},"nextToken":{}}}},"ListSecurityProfilesForTarget":{"http":{"method":"GET","requestUri":"/security-profiles-for-target"},"input":{"type":"structure","required":["securityProfileTargetArn"],"members":{"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"recursive":{"location":"querystring","locationName":"recursive","type":"boolean"},"securityProfileTargetArn":{"location":"querystring","locationName":"securityProfileTargetArn"}}},"output":{"type":"structure","members":{"securityProfileTargetMappings":{"type":"list","member":{"type":"structure","members":{"securityProfileIdentifier":{"shape":"Sn5"},"target":{"shape":"Sna"}}}},"nextToken":{}}}},"ListStreams":{"http":{"method":"GET","requestUri":"/streams"},"input":{"type":"structure","members":{"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"nextToken":{"location":"querystring","locationName":"nextToken"},"ascendingOrder":{"location":"querystring","locationName":"isAscendingOrder","type":"boolean"}}},"output":{"type":"structure","members":{"streams":{"type":"list","member":{"type":"structure","members":{"streamId":{},"streamArn":{},"streamVersion":{"type":"integer"},"description":{}}}},"nextToken":{}}}},"ListTagsForResource":{"http":{"method":"GET","requestUri":"/tags"},"input":{"type":"structure","required":["resourceArn"],"members":{"resourceArn":{"location":"querystring","locationName":"resourceArn"},"nextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"tags":{"shape":"S1r"},"nextToken":{}}}},"ListTargetsForPolicy":{"http":{"requestUri":"/policy-targets/{policyName}"},"input":{"type":"structure","required":["policyName"],"members":{"policyName":{"location":"uri","locationName":"policyName"},"marker":{"location":"querystring","locationName":"marker"},"pageSize":{"location":"querystring","locationName":"pageSize","type":"integer"}}},"output":{"type":"structure","members":{"targets":{"type":"list","member":{}},"nextMarker":{}}}},"ListTargetsForSecurityProfile":{"http":{"method":"GET","requestUri":"/security-profiles/{securityProfileName}/targets"},"input":{"type":"structure","required":["securityProfileName"],"members":{"securityProfileName":{"location":"uri","locationName":"securityProfileName"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"securityProfileTargets":{"type":"list","member":{"shape":"Sna"}},"nextToken":{}}}},"ListThingGroups":{"http":{"method":"GET","requestUri":"/thing-groups"},"input":{"type":"structure","members":{"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"parentGroup":{"location":"querystring","locationName":"parentGroup"},"namePrefixFilter":{"location":"querystring","locationName":"namePrefixFilter"},"recursive":{"location":"querystring","locationName":"recursive","type":"boolean"}}},"output":{"type":"structure","members":{"thingGroups":{"shape":"Shf"},"nextToken":{}}}},"ListThingGroupsForThing":{"http":{"method":"GET","requestUri":"/things/{thingName}/thing-groups"},"input":{"type":"structure","required":["thingName"],"members":{"thingName":{"location":"uri","locationName":"thingName"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"thingGroups":{"shape":"Shf"},"nextToken":{}}}},"ListThingPrincipals":{"http":{"method":"GET","requestUri":"/things/{thingName}/principals"},"input":{"type":"structure","required":["thingName"],"members":{"thingName":{"location":"uri","locationName":"thingName"}}},"output":{"type":"structure","members":{"principals":{"shape":"Smc"}}}},"ListThingRegistrationTaskReports":{"http":{"method":"GET","requestUri":"/thing-registration-tasks/{taskId}/reports"},"input":{"type":"structure","required":["taskId","reportType"],"members":{"taskId":{"location":"uri","locationName":"taskId"},"reportType":{"location":"querystring","locationName":"reportType"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"resourceLinks":{"type":"list","member":{}},"reportType":{},"nextToken":{}}}},"ListThingRegistrationTasks":{"http":{"method":"GET","requestUri":"/thing-registration-tasks"},"input":{"type":"structure","members":{"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"status":{"location":"querystring","locationName":"status"}}},"output":{"type":"structure","members":{"taskIds":{"type":"list","member":{}},"nextToken":{}}}},"ListThingTypes":{"http":{"method":"GET","requestUri":"/thing-types"},"input":{"type":"structure","members":{"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"thingTypeName":{"location":"querystring","locationName":"thingTypeName"}}},"output":{"type":"structure","members":{"thingTypes":{"type":"list","member":{"type":"structure","members":{"thingTypeName":{},"thingTypeArn":{},"thingTypeProperties":{"shape":"S8g"},"thingTypeMetadata":{"shape":"Shs"}}}},"nextToken":{}}}},"ListThings":{"http":{"method":"GET","requestUri":"/things"},"input":{"type":"structure","members":{"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"attributeName":{"location":"querystring","locationName":"attributeName"},"attributeValue":{"location":"querystring","locationName":"attributeValue"},"thingTypeName":{"location":"querystring","locationName":"thingTypeName"}}},"output":{"type":"structure","members":{"things":{"type":"list","member":{"type":"structure","members":{"thingName":{},"thingTypeName":{},"thingArn":{},"attributes":{"shape":"S2u"},"version":{"type":"long"}}}},"nextToken":{}}}},"ListThingsInBillingGroup":{"http":{"method":"GET","requestUri":"/billing-groups/{billingGroupName}/things"},"input":{"type":"structure","required":["billingGroupName"],"members":{"billingGroupName":{"location":"uri","locationName":"billingGroupName"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"things":{"shape":"Smm"},"nextToken":{}}}},"ListThingsInThingGroup":{"http":{"method":"GET","requestUri":"/thing-groups/{thingGroupName}/things"},"input":{"type":"structure","required":["thingGroupName"],"members":{"thingGroupName":{"location":"uri","locationName":"thingGroupName"},"recursive":{"location":"querystring","locationName":"recursive","type":"boolean"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"things":{"shape":"Smm"},"nextToken":{}}}},"ListTopicRuleDestinations":{"http":{"method":"GET","requestUri":"/destinations"},"input":{"type":"structure","members":{"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"nextToken":{"location":"querystring","locationName":"nextToken"}}},"output":{"type":"structure","members":{"destinationSummaries":{"type":"list","member":{"type":"structure","members":{"arn":{},"status":{},"statusReason":{},"httpUrlSummary":{"type":"structure","members":{"confirmationUrl":{}}}}}},"nextToken":{}}}},"ListTopicRules":{"http":{"method":"GET","requestUri":"/rules"},"input":{"type":"structure","members":{"topic":{"location":"querystring","locationName":"topic"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"},"nextToken":{"location":"querystring","locationName":"nextToken"},"ruleDisabled":{"location":"querystring","locationName":"ruleDisabled","type":"boolean"}}},"output":{"type":"structure","members":{"rules":{"type":"list","member":{"type":"structure","members":{"ruleArn":{},"ruleName":{},"topicPattern":{},"createdAt":{"type":"timestamp"},"ruleDisabled":{"type":"boolean"}}}},"nextToken":{}}}},"ListV2LoggingLevels":{"http":{"method":"GET","requestUri":"/v2LoggingLevel"},"input":{"type":"structure","members":{"targetType":{"location":"querystring","locationName":"targetType"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"logTargetConfigurations":{"type":"list","member":{"type":"structure","members":{"logTarget":{"shape":"Sow"},"logLevel":{}}}},"nextToken":{}}}},"ListViolationEvents":{"http":{"method":"GET","requestUri":"/violation-events"},"input":{"type":"structure","required":["startTime","endTime"],"members":{"startTime":{"location":"querystring","locationName":"startTime","type":"timestamp"},"endTime":{"location":"querystring","locationName":"endTime","type":"timestamp"},"thingName":{"location":"querystring","locationName":"thingName"},"securityProfileName":{"location":"querystring","locationName":"securityProfileName"},"nextToken":{"location":"querystring","locationName":"nextToken"},"maxResults":{"location":"querystring","locationName":"maxResults","type":"integer"}}},"output":{"type":"structure","members":{"violationEvents":{"type":"list","member":{"type":"structure","members":{"violationId":{},"thingName":{},"securityProfileName":{},"behavior":{"shape":"S7b"},"metricValue":{"shape":"S7i"},"violationEventType":{},"violationEventTime":{"type":"timestamp"}}}},"nextToken":{}}}},"RegisterCACertificate":{"http":{"requestUri":"/cacertificate"},"input":{"type":"structure","required":["caCertificate","verificationCertificate"],"members":{"caCertificate":{},"verificationCertificate":{},"setAsActive":{"location":"querystring","locationName":"setAsActive","type":"boolean"},"allowAutoRegistration":{"location":"querystring","locationName":"allowAutoRegistration","type":"boolean"},"registrationConfig":{"shape":"Sf7"},"tags":{"shape":"S1r"}}},"output":{"type":"structure","members":{"certificateArn":{},"certificateId":{}}}},"RegisterCertificate":{"http":{"requestUri":"/certificate/register"},"input":{"type":"structure","required":["certificatePem"],"members":{"certificatePem":{},"caCertificatePem":{},"setAsActive":{"deprecated":true,"location":"querystring","locationName":"setAsActive","type":"boolean"},"status":{}}},"output":{"type":"structure","members":{"certificateArn":{},"certificateId":{}}}},"RegisterCertificateWithoutCA":{"http":{"requestUri":"/certificate/register-no-ca"},"input":{"type":"structure","required":["certificatePem"],"members":{"certificatePem":{},"status":{}}},"output":{"type":"structure","members":{"certificateArn":{},"certificateId":{}}}},"RegisterThing":{"http":{"requestUri":"/things"},"input":{"type":"structure","required":["templateBody"],"members":{"templateBody":{},"parameters":{"type":"map","key":{},"value":{}}}},"output":{"type":"structure","members":{"certificatePem":{},"resourceArns":{"type":"map","key":{},"value":{}}}}},"RejectCertificateTransfer":{"http":{"method":"PATCH","requestUri":"/reject-certificate-transfer/{certificateId}"},"input":{"type":"structure","required":["certificateId"],"members":{"certificateId":{"location":"uri","locationName":"certificateId"},"rejectReason":{}}}},"RemoveThingFromBillingGroup":{"http":{"method":"PUT","requestUri":"/billing-groups/removeThingFromBillingGroup"},"input":{"type":"structure","members":{"billingGroupName":{},"billingGroupArn":{},"thingName":{},"thingArn":{}}},"output":{"type":"structure","members":{}}},"RemoveThingFromThingGroup":{"http":{"method":"PUT","requestUri":"/thing-groups/removeThingFromThingGroup"},"input":{"type":"structure","members":{"thingGroupName":{},"thingGroupArn":{},"thingName":{},"thingArn":{}}},"output":{"type":"structure","members":{}}},"ReplaceTopicRule":{"http":{"method":"PATCH","requestUri":"/rules/{ruleName}"},"input":{"type":"structure","required":["ruleName","topicRulePayload"],"members":{"ruleName":{"location":"uri","locationName":"ruleName"},"topicRulePayload":{"shape":"S8o"}},"payload":"topicRulePayload"}},"SearchIndex":{"http":{"requestUri":"/indices/search"},"input":{"type":"structure","required":["queryString"],"members":{"indexName":{},"queryString":{},"nextToken":{},"maxResults":{"type":"integer"},"queryVersion":{}}},"output":{"type":"structure","members":{"nextToken":{},"things":{"type":"list","member":{"type":"structure","members":{"thingName":{},"thingId":{},"thingTypeName":{},"thingGroupNames":{"shape":"Spq"},"attributes":{"shape":"S2u"},"shadow":{},"connectivity":{"type":"structure","members":{"connected":{"type":"boolean"},"timestamp":{"type":"long"}}}}}},"thingGroups":{"type":"list","member":{"type":"structure","members":{"thingGroupName":{},"thingGroupId":{},"thingGroupDescription":{},"attributes":{"shape":"S2u"},"parentGroupNames":{"shape":"Spq"}}}}}}},"SetDefaultAuthorizer":{"http":{"requestUri":"/default-authorizer"},"input":{"type":"structure","required":["authorizerName"],"members":{"authorizerName":{}}},"output":{"type":"structure","members":{"authorizerName":{},"authorizerArn":{}}}},"SetDefaultPolicyVersion":{"http":{"method":"PATCH","requestUri":"/policies/{policyName}/version/{policyVersionId}"},"input":{"type":"structure","required":["policyName","policyVersionId"],"members":{"policyName":{"location":"uri","locationName":"policyName"},"policyVersionId":{"location":"uri","locationName":"policyVersionId"}}}},"SetLoggingOptions":{"http":{"requestUri":"/loggingOptions"},"input":{"type":"structure","required":["loggingOptionsPayload"],"members":{"loggingOptionsPayload":{"type":"structure","required":["roleArn"],"members":{"roleArn":{},"logLevel":{}}}},"payload":"loggingOptionsPayload"}},"SetV2LoggingLevel":{"http":{"requestUri":"/v2LoggingLevel"},"input":{"type":"structure","required":["logTarget","logLevel"],"members":{"logTarget":{"shape":"Sow"},"logLevel":{}}}},"SetV2LoggingOptions":{"http":{"requestUri":"/v2LoggingOptions"},"input":{"type":"structure","members":{"roleArn":{},"defaultLogLevel":{},"disableAllLogs":{"type":"boolean"}}}},"StartAuditMitigationActionsTask":{"http":{"requestUri":"/audit/mitigationactions/tasks/{taskId}"},"input":{"type":"structure","required":["taskId","target","auditCheckToActionsMapping","clientRequestToken"],"members":{"taskId":{"location":"uri","locationName":"taskId"},"target":{"shape":"Sdz"},"auditCheckToActionsMapping":{"shape":"Se3"},"clientRequestToken":{"idempotencyToken":true}}},"output":{"type":"structure","members":{"taskId":{}}}},"StartOnDemandAuditTask":{"http":{"requestUri":"/audit/tasks"},"input":{"type":"structure","required":["targetCheckNames"],"members":{"targetCheckNames":{"shape":"S73"}}},"output":{"type":"structure","members":{"taskId":{}}}},"StartThingRegistrationTask":{"http":{"requestUri":"/thing-registration-tasks"},"input":{"type":"structure","required":["templateBody","inputFileBucket","inputFileKey","roleArn"],"members":{"templateBody":{},"inputFileBucket":{},"inputFileKey":{},"roleArn":{}}},"output":{"type":"structure","members":{"taskId":{}}}},"StopThingRegistrationTask":{"http":{"method":"PUT","requestUri":"/thing-registration-tasks/{taskId}/cancel"},"input":{"type":"structure","required":["taskId"],"members":{"taskId":{"location":"uri","locationName":"taskId"}}},"output":{"type":"structure","members":{}}},"TagResource":{"http":{"requestUri":"/tags"},"input":{"type":"structure","required":["resourceArn","tags"],"members":{"resourceArn":{},"tags":{"shape":"S1r"}}},"output":{"type":"structure","members":{}}},"TestAuthorization":{"http":{"requestUri":"/test-authorization"},"input":{"type":"structure","required":["authInfos"],"members":{"principal":{},"cognitoIdentityPoolId":{},"authInfos":{"type":"list","member":{"shape":"Sqf"}},"clientId":{"location":"querystring","locationName":"clientId"},"policyNamesToAdd":{"shape":"Sqj"},"policyNamesToSkip":{"shape":"Sqj"}}},"output":{"type":"structure","members":{"authResults":{"type":"list","member":{"type":"structure","members":{"authInfo":{"shape":"Sqf"},"allowed":{"type":"structure","members":{"policies":{"shape":"Sk6"}}},"denied":{"type":"structure","members":{"implicitDeny":{"type":"structure","members":{"policies":{"shape":"Sk6"}}},"explicitDeny":{"type":"structure","members":{"policies":{"shape":"Sk6"}}}}},"authDecision":{},"missingContextValues":{"type":"list","member":{}}}}}}}},"TestInvokeAuthorizer":{"http":{"requestUri":"/authorizer/{authorizerName}/test"},"input":{"type":"structure","required":["authorizerName"],"members":{"authorizerName":{"location":"uri","locationName":"authorizerName"},"token":{},"tokenSignature":{},"httpContext":{"type":"structure","members":{"headers":{"type":"map","key":{},"value":{}},"queryString":{}}},"mqttContext":{"type":"structure","members":{"username":{},"password":{"type":"blob"},"clientId":{}}},"tlsContext":{"type":"structure","members":{"serverName":{}}}}},"output":{"type":"structure","members":{"isAuthenticated":{"type":"boolean"},"principalId":{},"policyDocuments":{"type":"list","member":{}},"refreshAfterInSeconds":{"type":"integer"},"disconnectAfterInSeconds":{"type":"integer"}}}},"TransferCertificate":{"http":{"method":"PATCH","requestUri":"/transfer-certificate/{certificateId}"},"input":{"type":"structure","required":["certificateId","targetAwsAccount"],"members":{"certificateId":{"location":"uri","locationName":"certificateId"},"targetAwsAccount":{"location":"querystring","locationName":"targetAwsAccount"},"transferMessage":{}}},"output":{"type":"structure","members":{"transferredCertificateArn":{}}}},"UntagResource":{"http":{"requestUri":"/untag"},"input":{"type":"structure","required":["resourceArn","tagKeys"],"members":{"resourceArn":{},"tagKeys":{"type":"list","member":{}}}},"output":{"type":"structure","members":{}}},"UpdateAccountAuditConfiguration":{"http":{"method":"PATCH","requestUri":"/audit/configuration"},"input":{"type":"structure","members":{"roleArn":{},"auditNotificationTargetConfigurations":{"shape":"Sd2"},"auditCheckConfigurations":{"shape":"Sd5"}}},"output":{"type":"structure","members":{}}},"UpdateAuthorizer":{"http":{"method":"PUT","requestUri":"/authorizer/{authorizerName}"},"input":{"type":"structure","required":["authorizerName"],"members":{"authorizerName":{"location":"uri","locationName":"authorizerName"},"authorizerFunctionArn":{},"tokenKeyName":{},"tokenSigningPublicKeys":{"shape":"S1n"},"status":{}}},"output":{"type":"structure","members":{"authorizerName":{},"authorizerArn":{}}}},"UpdateBillingGroup":{"http":{"method":"PATCH","requestUri":"/billing-groups/{billingGroupName}"},"input":{"type":"structure","required":["billingGroupName","billingGroupProperties"],"members":{"billingGroupName":{"location":"uri","locationName":"billingGroupName"},"billingGroupProperties":{"shape":"S1z"},"expectedVersion":{"type":"long"}}},"output":{"type":"structure","members":{"version":{"type":"long"}}}},"UpdateCACertificate":{"http":{"method":"PUT","requestUri":"/cacertificate/{caCertificateId}"},"input":{"type":"structure","required":["certificateId"],"members":{"certificateId":{"location":"uri","locationName":"caCertificateId"},"newStatus":{"location":"querystring","locationName":"newStatus"},"newAutoRegistrationStatus":{"location":"querystring","locationName":"newAutoRegistrationStatus"},"registrationConfig":{"shape":"Sf7"},"removeAutoRegistration":{"type":"boolean"}}}},"UpdateCertificate":{"http":{"method":"PUT","requestUri":"/certificates/{certificateId}"},"input":{"type":"structure","required":["certificateId","newStatus"],"members":{"certificateId":{"location":"uri","locationName":"certificateId"},"newStatus":{"location":"querystring","locationName":"newStatus"}}}},"UpdateDimension":{"http":{"method":"PATCH","requestUri":"/dimensions/{name}"},"input":{"type":"structure","required":["name","stringValues"],"members":{"name":{"location":"uri","locationName":"name"},"stringValues":{"shape":"S2b"}}},"output":{"type":"structure","members":{"name":{},"arn":{},"type":{},"stringValues":{"shape":"S2b"},"creationDate":{"type":"timestamp"},"lastModifiedDate":{"type":"timestamp"}}}},"UpdateDomainConfiguration":{"http":{"method":"PUT","requestUri":"/domainConfigurations/{domainConfigurationName}"},"input":{"type":"structure","required":["domainConfigurationName"],"members":{"domainConfigurationName":{"location":"uri","locationName":"domainConfigurationName"},"authorizerConfig":{"shape":"S2l"},"domainConfigurationStatus":{},"removeAuthorizerConfig":{"type":"boolean"}}},"output":{"type":"structure","members":{"domainConfigurationName":{},"domainConfigurationArn":{}}}},"UpdateDynamicThingGroup":{"http":{"method":"PATCH","requestUri":"/dynamic-thing-groups/{thingGroupName}"},"input":{"type":"structure","required":["thingGroupName","thingGroupProperties"],"members":{"thingGroupName":{"location":"uri","locationName":"thingGroupName"},"thingGroupProperties":{"shape":"S2r"},"expectedVersion":{"type":"long"},"indexName":{},"queryString":{},"queryVersion":{}}},"output":{"type":"structure","members":{"version":{"type":"long"}}}},"UpdateEventConfigurations":{"http":{"method":"PATCH","requestUri":"/event-configurations"},"input":{"type":"structure","members":{"eventConfigurations":{"shape":"Sfy"}}},"output":{"type":"structure","members":{}}},"UpdateIndexingConfiguration":{"http":{"requestUri":"/indexing/config"},"input":{"type":"structure","members":{"thingIndexingConfiguration":{"shape":"Sic"},"thingGroupIndexingConfiguration":{"shape":"Sij"}}},"output":{"type":"structure","members":{}}},"UpdateJob":{"http":{"method":"PATCH","requestUri":"/jobs/{jobId}"},"input":{"type":"structure","required":["jobId"],"members":{"jobId":{"location":"uri","locationName":"jobId"},"description":{},"presignedUrlConfig":{"shape":"S36"},"jobExecutionsRolloutConfig":{"shape":"S3a"},"abortConfig":{"shape":"S3h"},"timeoutConfig":{"shape":"S3o"}}}},"UpdateMitigationAction":{"http":{"method":"PATCH","requestUri":"/mitigationactions/actions/{actionName}"},"input":{"type":"structure","required":["actionName"],"members":{"actionName":{"location":"uri","locationName":"actionName"},"roleArn":{},"actionParams":{"shape":"S3y"}}},"output":{"type":"structure","members":{"actionArn":{},"actionId":{}}}},"UpdateProvisioningTemplate":{"http":{"method":"PATCH","requestUri":"/provisioning-templates/{templateName}"},"input":{"type":"structure","required":["templateName"],"members":{"templateName":{"location":"uri","locationName":"templateName"},"description":{},"enabled":{"type":"boolean"},"defaultVersionId":{"type":"integer"},"provisioningRoleArn":{},"preProvisioningHook":{"shape":"S6n"},"removePreProvisioningHook":{"type":"boolean"}}},"output":{"type":"structure","members":{}}},"UpdateRoleAlias":{"http":{"method":"PUT","requestUri":"/role-aliases/{roleAlias}"},"input":{"type":"structure","required":["roleAlias"],"members":{"roleAlias":{"location":"uri","locationName":"roleAlias"},"roleArn":{},"credentialDurationSeconds":{"type":"integer"}}},"output":{"type":"structure","members":{"roleAlias":{},"roleAliasArn":{}}}},"UpdateScheduledAudit":{"http":{"method":"PATCH","requestUri":"/audit/scheduledaudits/{scheduledAuditName}"},"input":{"type":"structure","required":["scheduledAuditName"],"members":{"frequency":{},"dayOfMonth":{},"dayOfWeek":{},"targetCheckNames":{"shape":"S73"},"scheduledAuditName":{"location":"uri","locationName":"scheduledAuditName"}}},"output":{"type":"structure","members":{"scheduledAuditArn":{}}}},"UpdateSecurityProfile":{"http":{"method":"PATCH","requestUri":"/security-profiles/{securityProfileName}"},"input":{"type":"structure","required":["securityProfileName"],"members":{"securityProfileName":{"location":"uri","locationName":"securityProfileName"},"securityProfileDescription":{},"behaviors":{"shape":"S7a"},"alertTargets":{"shape":"S7t"},"additionalMetricsToRetain":{"shape":"S7x","deprecated":true,"deprecatedMessage":"Use additionalMetricsToRetainV2."},"additionalMetricsToRetainV2":{"shape":"S7y"},"deleteBehaviors":{"type":"boolean"},"deleteAlertTargets":{"type":"boolean"},"deleteAdditionalMetricsToRetain":{"type":"boolean"},"expectedVersion":{"location":"querystring","locationName":"expectedVersion","type":"long"}}},"output":{"type":"structure","members":{"securityProfileName":{},"securityProfileArn":{},"securityProfileDescription":{},"behaviors":{"shape":"S7a"},"alertTargets":{"shape":"S7t"},"additionalMetricsToRetain":{"shape":"S7x","deprecated":true,"deprecatedMessage":"Use additionalMetricsToRetainV2."},"additionalMetricsToRetainV2":{"shape":"S7y"},"version":{"type":"long"},"creationDate":{"type":"timestamp"},"lastModifiedDate":{"type":"timestamp"}}}},"UpdateStream":{"http":{"method":"PUT","requestUri":"/streams/{streamId}"},"input":{"type":"structure","required":["streamId"],"members":{"streamId":{"location":"uri","locationName":"streamId"},"description":{},"files":{"shape":"S84"},"roleArn":{}}},"output":{"type":"structure","members":{"streamId":{},"streamArn":{},"description":{},"streamVersion":{"type":"integer"}}}},"UpdateThing":{"http":{"method":"PATCH","requestUri":"/things/{thingName}"},"input":{"type":"structure","required":["thingName"],"members":{"thingName":{"location":"uri","locationName":"thingName"},"thingTypeName":{},"attributePayload":{"shape":"S2t"},"expectedVersion":{"type":"long"},"removeThingType":{"type":"boolean"}}},"output":{"type":"structure","members":{}}},"UpdateThingGroup":{"http":{"method":"PATCH","requestUri":"/thing-groups/{thingGroupName}"},"input":{"type":"structure","required":["thingGroupName","thingGroupProperties"],"members":{"thingGroupName":{"location":"uri","locationName":"thingGroupName"},"thingGroupProperties":{"shape":"S2r"},"expectedVersion":{"type":"long"}}},"output":{"type":"structure","members":{"version":{"type":"long"}}}},"UpdateThingGroupsForThing":{"http":{"method":"PUT","requestUri":"/thing-groups/updateThingGroupsForThing"},"input":{"type":"structure","members":{"thingName":{},"thingGroupsToAdd":{"shape":"Ssp"},"thingGroupsToRemove":{"shape":"Ssp"},"overrideDynamicGroups":{"type":"boolean"}}},"output":{"type":"structure","members":{}}},"UpdateTopicRuleDestination":{"http":{"method":"PATCH","requestUri":"/destinations"},"input":{"type":"structure","required":["arn","status"],"members":{"arn":{},"status":{}}},"output":{"type":"structure","members":{}}},"ValidateSecurityProfileBehaviors":{"http":{"requestUri":"/security-profile-behaviors/validate"},"input":{"type":"structure","required":["behaviors"],"members":{"behaviors":{"shape":"S7a"}}},"output":{"type":"structure","members":{"valid":{"type":"boolean"},"validationErrors":{"type":"list","member":{"type":"structure","members":{"errorMessage":{}}}}}}}},"shapes":{"Sg":{"type":"list","member":{}},"S1b":{"type":"map","key":{},"value":{}},"S1n":{"type":"map","key":{},"value":{}},"S1r":{"type":"list","member":{"type":"structure","required":["Key"],"members":{"Key":{},"Value":{}}}},"S1z":{"type":"structure","members":{"billingGroupDescription":{}}},"S2b":{"type":"list","member":{}},"S2l":{"type":"structure","members":{"defaultAuthorizerName":{},"allowAuthorizerOverride":{"type":"boolean"}}},"S2r":{"type":"structure","members":{"thingGroupDescription":{},"attributePayload":{"shape":"S2t"}}},"S2t":{"type":"structure","members":{"attributes":{"shape":"S2u"},"merge":{"type":"boolean"}}},"S2u":{"type":"map","key":{},"value":{}},"S36":{"type":"structure","members":{"roleArn":{},"expiresInSec":{"type":"long"}}},"S3a":{"type":"structure","members":{"maximumPerMinute":{"type":"integer"},"exponentialRate":{"type":"structure","required":["baseRatePerMinute","incrementFactor","rateIncreaseCriteria"],"members":{"baseRatePerMinute":{"type":"integer"},"incrementFactor":{"type":"double"},"rateIncreaseCriteria":{"type":"structure","members":{"numberOfNotifiedThings":{"type":"integer"},"numberOfSucceededThings":{"type":"integer"}}}}}}},"S3h":{"type":"structure","required":["criteriaList"],"members":{"criteriaList":{"type":"list","member":{"type":"structure","required":["failureType","action","thresholdPercentage","minNumberOfExecutedThings"],"members":{"failureType":{},"action":{},"thresholdPercentage":{"type":"double"},"minNumberOfExecutedThings":{"type":"integer"}}}}}},"S3o":{"type":"structure","members":{"inProgressTimeoutInMinutes":{"type":"long"}}},"S3t":{"type":"structure","members":{"PublicKey":{},"PrivateKey":{"type":"string","sensitive":true}}},"S3y":{"type":"structure","members":{"updateDeviceCertificateParams":{"type":"structure","required":["action"],"members":{"action":{}}},"updateCACertificateParams":{"type":"structure","required":["action"],"members":{"action":{}}},"addThingsToThingGroupParams":{"type":"structure","required":["thingGroupNames"],"members":{"thingGroupNames":{"type":"list","member":{}},"overrideDynamicGroups":{"type":"boolean"}}},"replaceDefaultPolicyVersionParams":{"type":"structure","required":["templateName"],"members":{"templateName":{}}},"enableIoTLoggingParams":{"type":"structure","required":["roleArnForLogging","logLevel"],"members":{"roleArnForLogging":{},"logLevel":{}}},"publishFindingToSnsParams":{"type":"structure","required":["topicArn"],"members":{"topicArn":{}}}}},"S4h":{"type":"list","member":{}},"S4j":{"type":"list","member":{}},"S4l":{"type":"structure","members":{"maximumPerMinute":{"type":"integer"},"exponentialRate":{"type":"structure","required":["baseRatePerMinute","incrementFactor","rateIncreaseCriteria"],"members":{"baseRatePerMinute":{"type":"integer"},"incrementFactor":{"type":"double"},"rateIncreaseCriteria":{"type":"structure","members":{"numberOfNotifiedThings":{"type":"integer"},"numberOfSucceededThings":{"type":"integer"}}}}}}},"S4s":{"type":"structure","members":{"expiresInSec":{"type":"long"}}},"S53":{"type":"list","member":{"type":"structure","members":{"fileName":{},"fileVersion":{},"fileLocation":{"type":"structure","members":{"stream":{"type":"structure","members":{"streamId":{},"fileId":{"type":"integer"}}},"s3Location":{"shape":"S5b"}}},"codeSigning":{"type":"structure","members":{"awsSignerJobId":{},"startSigningJobParameter":{"type":"structure","members":{"signingProfileParameter":{"type":"structure","members":{"certificateArn":{},"platform":{},"certificatePathOnDevice":{}}},"signingProfileName":{},"destination":{"type":"structure","members":{"s3Destination":{"type":"structure","members":{"bucket":{},"prefix":{}}}}}}},"customCodeSigning":{"type":"structure","members":{"signature":{"type":"structure","members":{"inlineDocument":{"type":"blob"}}},"certificateChain":{"type":"structure","members":{"certificateName":{},"inlineDocument":{}}},"hashAlgorithm":{},"signatureAlgorithm":{}}}}},"attributes":{"type":"map","key":{},"value":{}}}}},"S5b":{"type":"structure","members":{"bucket":{},"key":{},"version":{}}},"S60":{"type":"map","key":{},"value":{}},"S6n":{"type":"structure","required":["targetArn"],"members":{"payloadVersion":{},"targetArn":{}}},"S73":{"type":"list","member":{}},"S7a":{"type":"list","member":{"shape":"S7b"}},"S7b":{"type":"structure","required":["name"],"members":{"name":{},"metric":{},"metricDimension":{"shape":"S7e"},"criteria":{"type":"structure","members":{"comparisonOperator":{},"value":{"shape":"S7i"},"durationSeconds":{"type":"integer"},"consecutiveDatapointsToAlarm":{"type":"integer"},"consecutiveDatapointsToClear":{"type":"integer"},"statisticalThreshold":{"type":"structure","members":{"statistic":{}}}}}}},"S7e":{"type":"structure","required":["dimensionName"],"members":{"dimensionName":{},"operator":{}}},"S7i":{"type":"structure","members":{"count":{"type":"long"},"cidrs":{"type":"list","member":{}},"ports":{"type":"list","member":{"type":"integer"}}}},"S7t":{"type":"map","key":{},"value":{"type":"structure","required":["alertTargetArn","roleArn"],"members":{"alertTargetArn":{},"roleArn":{}}}},"S7x":{"type":"list","member":{}},"S7y":{"type":"list","member":{"type":"structure","required":["metric"],"members":{"metric":{},"metricDimension":{"shape":"S7e"}}}},"S84":{"type":"list","member":{"type":"structure","members":{"fileId":{"type":"integer"},"s3Location":{"shape":"S5b"}}}},"S8g":{"type":"structure","members":{"thingTypeDescription":{},"searchableAttributes":{"type":"list","member":{}}}},"S8o":{"type":"structure","required":["sql","actions"],"members":{"sql":{},"description":{},"actions":{"shape":"S8r"},"ruleDisabled":{"type":"boolean"},"awsIotSqlVersion":{},"errorAction":{"shape":"S8s"}}},"S8r":{"type":"list","member":{"shape":"S8s"}},"S8s":{"type":"structure","members":{"dynamoDB":{"type":"structure","required":["tableName","roleArn","hashKeyField","hashKeyValue"],"members":{"tableName":{},"roleArn":{},"operation":{},"hashKeyField":{},"hashKeyValue":{},"hashKeyType":{},"rangeKeyField":{},"rangeKeyValue":{},"rangeKeyType":{},"payloadField":{}}},"dynamoDBv2":{"type":"structure","required":["roleArn","putItem"],"members":{"roleArn":{},"putItem":{"type":"structure","required":["tableName"],"members":{"tableName":{}}}}},"lambda":{"type":"structure","required":["functionArn"],"members":{"functionArn":{}}},"sns":{"type":"structure","required":["targetArn","roleArn"],"members":{"targetArn":{},"roleArn":{},"messageFormat":{}}},"sqs":{"type":"structure","required":["roleArn","queueUrl"],"members":{"roleArn":{},"queueUrl":{},"useBase64":{"type":"boolean"}}},"kinesis":{"type":"structure","required":["roleArn","streamName"],"members":{"roleArn":{},"streamName":{},"partitionKey":{}}},"republish":{"type":"structure","required":["roleArn","topic"],"members":{"roleArn":{},"topic":{},"qos":{"type":"integer"}}},"s3":{"type":"structure","required":["roleArn","bucketName","key"],"members":{"roleArn":{},"bucketName":{},"key":{},"cannedAcl":{}}},"firehose":{"type":"structure","required":["roleArn","deliveryStreamName"],"members":{"roleArn":{},"deliveryStreamName":{},"separator":{}}},"cloudwatchMetric":{"type":"structure","required":["roleArn","metricNamespace","metricName","metricValue","metricUnit"],"members":{"roleArn":{},"metricNamespace":{},"metricName":{},"metricValue":{},"metricUnit":{},"metricTimestamp":{}}},"cloudwatchAlarm":{"type":"structure","required":["roleArn","alarmName","stateReason","stateValue"],"members":{"roleArn":{},"alarmName":{},"stateReason":{},"stateValue":{}}},"cloudwatchLogs":{"type":"structure","required":["roleArn","logGroupName"],"members":{"roleArn":{},"logGroupName":{}}},"elasticsearch":{"type":"structure","required":["roleArn","endpoint","index","type","id"],"members":{"roleArn":{},"endpoint":{},"index":{},"type":{},"id":{}}},"salesforce":{"type":"structure","required":["token","url"],"members":{"token":{},"url":{}}},"iotAnalytics":{"type":"structure","members":{"channelArn":{},"channelName":{},"roleArn":{}}},"iotEvents":{"type":"structure","required":["inputName","roleArn"],"members":{"inputName":{},"messageId":{},"roleArn":{}}},"iotSiteWise":{"type":"structure","required":["putAssetPropertyValueEntries","roleArn"],"members":{"putAssetPropertyValueEntries":{"type":"list","member":{"type":"structure","required":["propertyValues"],"members":{"entryId":{},"assetId":{},"propertyId":{},"propertyAlias":{},"propertyValues":{"type":"list","member":{"type":"structure","required":["value","timestamp"],"members":{"value":{"type":"structure","members":{"stringValue":{},"integerValue":{},"doubleValue":{},"booleanValue":{}}},"timestamp":{"type":"structure","required":["timeInSeconds"],"members":{"timeInSeconds":{},"offsetInNanos":{}}},"quality":{}}}}}}},"roleArn":{}}},"stepFunctions":{"type":"structure","required":["stateMachineName","roleArn"],"members":{"executionNamePrefix":{},"stateMachineName":{},"roleArn":{}}},"http":{"type":"structure","required":["url"],"members":{"url":{},"confirmationUrl":{},"headers":{"type":"list","member":{"type":"structure","required":["key","value"],"members":{"key":{},"value":{}}}},"auth":{"type":"structure","members":{"sigv4":{"type":"structure","required":["signingRegion","serviceName","roleArn"],"members":{"signingRegion":{},"serviceName":{},"roleArn":{}}}}}}}}},"Sbb":{"type":"structure","members":{"arn":{},"status":{},"statusReason":{},"httpUrlProperties":{"type":"structure","members":{"confirmationUrl":{}}}}},"Sd2":{"type":"map","key":{},"value":{"type":"structure","members":{"targetArn":{},"roleArn":{},"enabled":{"type":"boolean"}}}},"Sd5":{"type":"map","key":{},"value":{"type":"structure","members":{"enabled":{"type":"boolean"}}}},"Sda":{"type":"structure","members":{"findingId":{},"taskId":{},"checkName":{},"taskStartTime":{"type":"timestamp"},"findingTime":{"type":"timestamp"},"severity":{},"nonCompliantResource":{"type":"structure","members":{"resourceType":{},"resourceIdentifier":{"shape":"Sdf"},"additionalInfo":{"shape":"Sdk"}}},"relatedResources":{"type":"list","member":{"type":"structure","members":{"resourceType":{},"resourceIdentifier":{"shape":"Sdf"},"additionalInfo":{"shape":"Sdk"}}}},"reasonForNonCompliance":{},"reasonForNonComplianceCode":{}}},"Sdf":{"type":"structure","members":{"deviceCertificateId":{},"caCertificateId":{},"cognitoIdentityPoolId":{},"clientId":{},"policyVersionIdentifier":{"type":"structure","members":{"policyName":{},"policyVersionId":{}}},"account":{},"iamRoleArn":{},"roleAliasArn":{}}},"Sdk":{"type":"map","key":{},"value":{}},"Sdz":{"type":"structure","members":{"auditTaskId":{},"findingIds":{"type":"list","member":{}},"auditCheckToReasonCodeFilter":{"type":"map","key":{},"value":{"type":"list","member":{}}}}},"Se3":{"type":"map","key":{},"value":{"type":"list","member":{}}},"Set":{"type":"structure","members":{"authorizerName":{},"authorizerArn":{},"authorizerFunctionArn":{},"tokenKeyName":{},"tokenSigningPublicKeys":{"shape":"S1n"},"status":{},"creationDate":{"type":"timestamp"},"lastModifiedDate":{"type":"timestamp"},"signingDisabled":{"type":"boolean"}}},"Sf6":{"type":"structure","members":{"notBefore":{"type":"timestamp"},"notAfter":{"type":"timestamp"}}},"Sf7":{"type":"structure","members":{"templateBody":{},"roleArn":{}}},"Sfy":{"type":"map","key":{},"value":{"type":"structure","members":{"Enabled":{"type":"boolean"}}}},"Shf":{"type":"list","member":{"shape":"Shg"}},"Shg":{"type":"structure","members":{"groupName":{},"groupArn":{}}},"Shs":{"type":"structure","members":{"deprecated":{"type":"boolean"},"deprecationDate":{"type":"timestamp"},"creationDate":{"type":"timestamp"}}},"Sic":{"type":"structure","required":["thingIndexingMode"],"members":{"thingIndexingMode":{},"thingConnectivityIndexingMode":{},"managedFields":{"shape":"Sif"},"customFields":{"shape":"Sif"}}},"Sif":{"type":"list","member":{"type":"structure","members":{"name":{},"type":{}}}},"Sij":{"type":"structure","required":["thingGroupIndexingMode"],"members":{"thingGroupIndexingMode":{},"managedFields":{"shape":"Sif"},"customFields":{"shape":"Sif"}}},"Sk6":{"type":"list","member":{"type":"structure","members":{"policyName":{},"policyArn":{}}}},"Sl3":{"type":"list","member":{"type":"structure","members":{"certificateArn":{},"certificateId":{},"status":{},"certificateMode":{},"creationDate":{"type":"timestamp"}}}},"Sln":{"type":"structure","members":{"status":{},"queuedAt":{"type":"timestamp"},"startedAt":{"type":"timestamp"},"lastUpdatedAt":{"type":"timestamp"},"executionNumber":{"type":"long"}}},"Smc":{"type":"list","member":{}},"Smm":{"type":"list","member":{}},"Sn5":{"type":"structure","required":["name","arn"],"members":{"name":{},"arn":{}}},"Sna":{"type":"structure","required":["arn"],"members":{"arn":{}}},"Sow":{"type":"structure","required":["targetType"],"members":{"targetType":{},"targetName":{}}},"Spq":{"type":"list","member":{}},"Sqf":{"type":"structure","required":["resources"],"members":{"actionType":{},"resources":{"type":"list","member":{}}}},"Sqj":{"type":"list","member":{}},"Ssp":{"type":"list","member":{}}}}; + if (statusCode === 204 || !contentType || !length) { + queueMicrotask(() => callback(new ResponseStatusCodeError(message, statusCode, headers))) + return + } -/***/ }), + const stackTraceLimit = Error.stackTraceLimit + Error.stackTraceLimit = 0 + let payload -/***/ 4604: -/***/ (function(module, __unusedexports, __webpack_require__) { + try { + if (isContentTypeApplicationJson(contentType)) { + payload = JSON.parse(chunksDecode(chunks, length)) + } else if (isContentTypeText(contentType)) { + payload = chunksDecode(chunks, length) + } + } catch { + // process in a callback to avoid throwing in the microtask queue + } finally { + Error.stackTraceLimit = stackTraceLimit + } + queueMicrotask(() => callback(new ResponseStatusCodeError(message, statusCode, headers, payload))) +} -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; +const isContentTypeApplicationJson = (contentType) => { + return ( + contentType.length > 15 && + contentType[11] === '/' && + contentType[0] === 'a' && + contentType[1] === 'p' && + contentType[2] === 'p' && + contentType[3] === 'l' && + contentType[4] === 'i' && + contentType[5] === 'c' && + contentType[6] === 'a' && + contentType[7] === 't' && + contentType[8] === 'i' && + contentType[9] === 'o' && + contentType[10] === 'n' && + contentType[12] === 'j' && + contentType[13] === 's' && + contentType[14] === 'o' && + contentType[15] === 'n' + ) +} -apiLoader.services['backup'] = {}; -AWS.Backup = Service.defineService('backup', ['2018-11-15']); -Object.defineProperty(apiLoader.services['backup'], '2018-11-15', { - get: function get() { - var model = __webpack_require__(9601); - model.paginators = __webpack_require__(8447).pagination; - return model; - }, - enumerable: true, - configurable: true -}); +const isContentTypeText = (contentType) => { + return ( + contentType.length > 4 && + contentType[4] === '/' && + contentType[0] === 't' && + contentType[1] === 'e' && + contentType[2] === 'x' && + contentType[3] === 't' + ) +} -module.exports = AWS.Backup; +module.exports = { + getResolveErrorBodyCallback, + isContentTypeApplicationJson, + isContentTypeText +} /***/ }), -/***/ 4612: -/***/ (function(module, __unusedexports, __webpack_require__) { - -__webpack_require__(3234); -var AWS = __webpack_require__(395); -var Service = AWS.Service; -var apiLoader = AWS.apiLoader; - -apiLoader.services['sso'] = {}; -AWS.SSO = Service.defineService('sso', ['2019-06-10']); -Object.defineProperty(apiLoader.services['sso'], '2019-06-10', { - get: function get() { - var model = __webpack_require__(3881); - model.paginators = __webpack_require__(682).pagination; - return model; - }, - enumerable: true, - configurable: true -}); - -module.exports = AWS.SSO; +/***/ 9136: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { +"use strict"; -/***/ }), -/***/ 4618: -/***/ (function(module, __unusedexports, __webpack_require__) { +const net = __nccwpck_require__(7030) +const assert = __nccwpck_require__(4589) +const util = __nccwpck_require__(3440) +const { InvalidArgumentError, ConnectTimeoutError } = __nccwpck_require__(8707) +const timers = __nccwpck_require__(6603) + +function noop () {} + +let tls // include tls conditionally since it is not always available + +// TODO: session re-use does not wait for the first +// connection to resolve the session and might therefore +// resolve the same servername multiple times even when +// re-use is enabled. + +let SessionCache +// FIXME: remove workaround when the Node bug is fixed +// https://github.com/nodejs/node/issues/49344#issuecomment-1741776308 +if (global.FinalizationRegistry && !(process.env.NODE_V8_COVERAGE || process.env.UNDICI_NO_FG)) { + SessionCache = class WeakSessionCache { + constructor (maxCachedSessions) { + this._maxCachedSessions = maxCachedSessions + this._sessionCache = new Map() + this._sessionRegistry = new global.FinalizationRegistry((key) => { + if (this._sessionCache.size < this._maxCachedSessions) { + return + } -var util = __webpack_require__(153); -var populateHostPrefix = __webpack_require__(904).populateHostPrefix; + const ref = this._sessionCache.get(key) + if (ref !== undefined && ref.deref() === undefined) { + this._sessionCache.delete(key) + } + }) + } -function populateMethod(req) { - req.httpRequest.method = req.service.api.operations[req.operation].httpMethod; -} + get (sessionKey) { + const ref = this._sessionCache.get(sessionKey) + return ref ? ref.deref() : null + } -function generateURI(endpointPath, operationPath, input, params) { - var uri = [endpointPath, operationPath].join('/'); - uri = uri.replace(/\/+/g, '/'); + set (sessionKey, session) { + if (this._maxCachedSessions === 0) { + return + } - var queryString = {}, queryStringSet = false; - util.each(input.members, function (name, member) { - var paramValue = params[name]; - if (paramValue === null || paramValue === undefined) return; - if (member.location === 'uri') { - var regex = new RegExp('\\{' + member.name + '(\\+)?\\}'); - uri = uri.replace(regex, function(_, plus) { - var fn = plus ? util.uriEscapePath : util.uriEscape; - return fn(String(paramValue)); - }); - } else if (member.location === 'querystring') { - queryStringSet = true; + this._sessionCache.set(sessionKey, new WeakRef(session)) + this._sessionRegistry.register(session, sessionKey) + } + } +} else { + SessionCache = class SimpleSessionCache { + constructor (maxCachedSessions) { + this._maxCachedSessions = maxCachedSessions + this._sessionCache = new Map() + } - if (member.type === 'list') { - queryString[member.name] = paramValue.map(function(val) { - return util.uriEscape(member.member.toWireFormat(val).toString()); - }); - } else if (member.type === 'map') { - util.each(paramValue, function(key, value) { - if (Array.isArray(value)) { - queryString[key] = value.map(function(val) { - return util.uriEscape(String(val)); - }); - } else { - queryString[key] = util.uriEscape(String(value)); - } - }); - } else { - queryString[member.name] = util.uriEscape(member.toWireFormat(paramValue).toString()); - } + get (sessionKey) { + return this._sessionCache.get(sessionKey) } - }); - if (queryStringSet) { - uri += (uri.indexOf('?') >= 0 ? '&' : '?'); - var parts = []; - util.arrayEach(Object.keys(queryString).sort(), function(key) { - if (!Array.isArray(queryString[key])) { - queryString[key] = [queryString[key]]; + set (sessionKey, session) { + if (this._maxCachedSessions === 0) { + return } - for (var i = 0; i < queryString[key].length; i++) { - parts.push(util.uriEscape(String(key)) + '=' + queryString[key][i]); + + if (this._sessionCache.size >= this._maxCachedSessions) { + // remove the oldest session + const { value: oldestKey } = this._sessionCache.keys().next() + this._sessionCache.delete(oldestKey) } - }); - uri += parts.join('&'); - } - return uri; + this._sessionCache.set(sessionKey, session) + } + } } -function populateURI(req) { - var operation = req.service.api.operations[req.operation]; - var input = operation.input; +function buildConnector ({ allowH2, maxCachedSessions, socketPath, timeout, session: customSession, ...opts }) { + if (maxCachedSessions != null && (!Number.isInteger(maxCachedSessions) || maxCachedSessions < 0)) { + throw new InvalidArgumentError('maxCachedSessions must be a positive integer or zero') + } + + const options = { path: socketPath, ...opts } + const sessionCache = new SessionCache(maxCachedSessions == null ? 100 : maxCachedSessions) + timeout = timeout == null ? 10e3 : timeout + allowH2 = allowH2 != null ? allowH2 : false + return function connect ({ hostname, host, protocol, port, servername, localAddress, httpSocket }, callback) { + let socket + if (protocol === 'https:') { + if (!tls) { + tls = __nccwpck_require__(1692) + } + servername = servername || options.servername || util.getServerName(host) || null + + const sessionKey = servername || hostname + assert(sessionKey) + + const session = customSession || sessionCache.get(sessionKey) || null + + port = port || 443 + + socket = tls.connect({ + highWaterMark: 16384, // TLS in node can't have bigger HWM anyway... + ...options, + servername, + session, + localAddress, + // TODO(HTTP/2): Add support for h2c + ALPNProtocols: allowH2 ? ['http/1.1', 'h2'] : ['http/1.1'], + socket: httpSocket, // upgrade socket connection + port, + host: hostname + }) - var uri = generateURI(req.httpRequest.endpoint.path, operation.httpPath, input, req.params); - req.httpRequest.path = uri; -} + socket + .on('session', function (session) { + // TODO (fix): Can a session become invalid once established? Don't think so? + sessionCache.set(sessionKey, session) + }) + } else { + assert(!httpSocket, 'httpSocket can only be sent on TLS update') -function populateHeaders(req) { - var operation = req.service.api.operations[req.operation]; - util.each(operation.input.members, function (name, member) { - var value = req.params[name]; - if (value === null || value === undefined) return; + port = port || 80 - if (member.location === 'headers' && member.type === 'map') { - util.each(value, function(key, memberValue) { - req.httpRequest.headers[member.name + key] = memberValue; - }); - } else if (member.location === 'header') { - value = member.toWireFormat(value).toString(); - if (member.isJsonValue) { - value = util.base64.encode(value); - } - req.httpRequest.headers[member.name] = value; + socket = net.connect({ + highWaterMark: 64 * 1024, // Same as nodejs fs streams. + ...options, + localAddress, + port, + host: hostname + }) } - }); -} -function buildRequest(req) { - populateMethod(req); - populateURI(req); - populateHeaders(req); - populateHostPrefix(req); -} + // Set TCP keep alive options on the socket here instead of in connect() for the case of assigning the socket + if (options.keepAlive == null || options.keepAlive) { + const keepAliveInitialDelay = options.keepAliveInitialDelay === undefined ? 60e3 : options.keepAliveInitialDelay + socket.setKeepAlive(true, keepAliveInitialDelay) + } -function extractError() { -} + const clearConnectTimeout = setupConnectTimeout(new WeakRef(socket), { timeout, hostname, port }) -function extractData(resp) { - var req = resp.request; - var data = {}; - var r = resp.httpResponse; - var operation = req.service.api.operations[req.operation]; - var output = operation.output; + socket + .setNoDelay(true) + .once(protocol === 'https:' ? 'secureConnect' : 'connect', function () { + queueMicrotask(clearConnectTimeout) - // normalize headers names to lower-cased keys for matching - var headers = {}; - util.each(r.headers, function (k, v) { - headers[k.toLowerCase()] = v; - }); + if (callback) { + const cb = callback + callback = null + cb(null, this) + } + }) + .on('error', function (err) { + queueMicrotask(clearConnectTimeout) - util.each(output.members, function(name, member) { - var header = (member.name || name).toLowerCase(); - if (member.location === 'headers' && member.type === 'map') { - data[name] = {}; - var location = member.isLocationName ? member.name : ''; - var pattern = new RegExp('^' + location + '(.+)', 'i'); - util.each(r.headers, function (k, v) { - var result = k.match(pattern); - if (result !== null) { - data[name][result[1]] = v; + if (callback) { + const cb = callback + callback = null + cb(err) } - }); - } else if (member.location === 'header') { - if (headers[header] !== undefined) { - var value = member.isJsonValue ? - util.base64.decode(headers[header]) : - headers[header]; - data[name] = member.toType(value); - } - } else if (member.location === 'statusCode') { - data[name] = parseInt(r.statusCode, 10); - } - }); + }) - resp.data = data; + return socket + } } /** - * @api private + * @param {WeakRef} socketWeakRef + * @param {object} opts + * @param {number} opts.timeout + * @param {string} opts.hostname + * @param {number} opts.port + * @returns {() => void} */ -module.exports = { - buildRequest: buildRequest, - extractError: extractError, - extractData: extractData, - generateURI: generateURI -}; +const setupConnectTimeout = process.platform === 'win32' + ? (socketWeakRef, opts) => { + if (!opts.timeout) { + return noop + } + + let s1 = null + let s2 = null + const fastTimer = timers.setFastTimeout(() => { + // setImmediate is added to make sure that we prioritize socket error events over timeouts + s1 = setImmediate(() => { + // Windows needs an extra setImmediate probably due to implementation differences in the socket logic + s2 = setImmediate(() => onConnectTimeout(socketWeakRef.deref(), opts)) + }) + }, opts.timeout) + return () => { + timers.clearFastTimeout(fastTimer) + clearImmediate(s1) + clearImmediate(s2) + } + } + : (socketWeakRef, opts) => { + if (!opts.timeout) { + return noop + } + + let s1 = null + const fastTimer = timers.setFastTimeout(() => { + // setImmediate is added to make sure that we prioritize socket error events over timeouts + s1 = setImmediate(() => { + onConnectTimeout(socketWeakRef.deref(), opts) + }) + }, opts.timeout) + return () => { + timers.clearFastTimeout(fastTimer) + clearImmediate(s1) + } + } + +/** + * @param {net.Socket} socket + * @param {object} opts + * @param {number} opts.timeout + * @param {string} opts.hostname + * @param {number} opts.port + */ +function onConnectTimeout (socket, opts) { + // The socket could be already garbage collected + if (socket == null) { + return + } + + let message = 'Connect Timeout Error' + if (Array.isArray(socket.autoSelectFamilyAttemptedAddresses)) { + message += ` (attempted addresses: ${socket.autoSelectFamilyAttemptedAddresses.join(', ')},` + } else { + message += ` (attempted address: ${opts.hostname}:${opts.port},` + } + + message += ` timeout: ${opts.timeout}ms)` + + util.destroy(socket, new ConnectTimeoutError(message)) +} + +module.exports = buildConnector /***/ }), -/***/ 4622: -/***/ (function(module) { +/***/ 735: +/***/ ((module) => { + +"use strict"; + + +/** @type {Record} */ +const headerNameLowerCasedRecord = {} + +// https://developer.mozilla.org/docs/Web/HTTP/Headers +const wellknownHeaderNames = [ + 'Accept', + 'Accept-Encoding', + 'Accept-Language', + 'Accept-Ranges', + 'Access-Control-Allow-Credentials', + 'Access-Control-Allow-Headers', + 'Access-Control-Allow-Methods', + 'Access-Control-Allow-Origin', + 'Access-Control-Expose-Headers', + 'Access-Control-Max-Age', + 'Access-Control-Request-Headers', + 'Access-Control-Request-Method', + 'Age', + 'Allow', + 'Alt-Svc', + 'Alt-Used', + 'Authorization', + 'Cache-Control', + 'Clear-Site-Data', + 'Connection', + 'Content-Disposition', + 'Content-Encoding', + 'Content-Language', + 'Content-Length', + 'Content-Location', + 'Content-Range', + 'Content-Security-Policy', + 'Content-Security-Policy-Report-Only', + 'Content-Type', + 'Cookie', + 'Cross-Origin-Embedder-Policy', + 'Cross-Origin-Opener-Policy', + 'Cross-Origin-Resource-Policy', + 'Date', + 'Device-Memory', + 'Downlink', + 'ECT', + 'ETag', + 'Expect', + 'Expect-CT', + 'Expires', + 'Forwarded', + 'From', + 'Host', + 'If-Match', + 'If-Modified-Since', + 'If-None-Match', + 'If-Range', + 'If-Unmodified-Since', + 'Keep-Alive', + 'Last-Modified', + 'Link', + 'Location', + 'Max-Forwards', + 'Origin', + 'Permissions-Policy', + 'Pragma', + 'Proxy-Authenticate', + 'Proxy-Authorization', + 'RTT', + 'Range', + 'Referer', + 'Referrer-Policy', + 'Refresh', + 'Retry-After', + 'Sec-WebSocket-Accept', + 'Sec-WebSocket-Extensions', + 'Sec-WebSocket-Key', + 'Sec-WebSocket-Protocol', + 'Sec-WebSocket-Version', + 'Server', + 'Server-Timing', + 'Service-Worker-Allowed', + 'Service-Worker-Navigation-Preload', + 'Set-Cookie', + 'SourceMap', + 'Strict-Transport-Security', + 'Supports-Loading-Mode', + 'TE', + 'Timing-Allow-Origin', + 'Trailer', + 'Transfer-Encoding', + 'Upgrade', + 'Upgrade-Insecure-Requests', + 'User-Agent', + 'Vary', + 'Via', + 'WWW-Authenticate', + 'X-Content-Type-Options', + 'X-DNS-Prefetch-Control', + 'X-Frame-Options', + 'X-Permitted-Cross-Domain-Policies', + 'X-Powered-By', + 'X-Requested-With', + 'X-XSS-Protection' +] + +for (let i = 0; i < wellknownHeaderNames.length; ++i) { + const key = wellknownHeaderNames[i] + const lowerCasedKey = key.toLowerCase() + headerNameLowerCasedRecord[key] = headerNameLowerCasedRecord[lowerCasedKey] = + lowerCasedKey +} + +// Note: object prototypes should not be able to be referenced. e.g. `Object#hasOwnProperty`. +Object.setPrototypeOf(headerNameLowerCasedRecord, null) + +module.exports = { + wellknownHeaderNames, + headerNameLowerCasedRecord +} -module.exports = {"version":"2.0","metadata":{"apiVersion":"2015-06-23","endpointPrefix":"devicefarm","jsonVersion":"1.1","protocol":"json","serviceFullName":"AWS Device Farm","serviceId":"Device Farm","signatureVersion":"v4","targetPrefix":"DeviceFarm_20150623","uid":"devicefarm-2015-06-23"},"operations":{"CreateDevicePool":{"input":{"type":"structure","required":["projectArn","name","rules"],"members":{"projectArn":{},"name":{},"description":{},"rules":{"shape":"S5"},"maxDevices":{"type":"integer"}}},"output":{"type":"structure","members":{"devicePool":{"shape":"Sc"}}}},"CreateInstanceProfile":{"input":{"type":"structure","required":["name"],"members":{"name":{},"description":{},"packageCleanup":{"type":"boolean"},"excludeAppPackagesFromCleanup":{"shape":"Sg"},"rebootAfterUse":{"type":"boolean"}}},"output":{"type":"structure","members":{"instanceProfile":{"shape":"Si"}}}},"CreateNetworkProfile":{"input":{"type":"structure","required":["projectArn","name"],"members":{"projectArn":{},"name":{},"description":{},"type":{},"uplinkBandwidthBits":{"type":"long"},"downlinkBandwidthBits":{"type":"long"},"uplinkDelayMs":{"type":"long"},"downlinkDelayMs":{"type":"long"},"uplinkJitterMs":{"type":"long"},"downlinkJitterMs":{"type":"long"},"uplinkLossPercent":{"type":"integer"},"downlinkLossPercent":{"type":"integer"}}},"output":{"type":"structure","members":{"networkProfile":{"shape":"So"}}}},"CreateProject":{"input":{"type":"structure","required":["name"],"members":{"name":{},"defaultJobTimeoutMinutes":{"type":"integer"}}},"output":{"type":"structure","members":{"project":{"shape":"Ss"}}}},"CreateRemoteAccessSession":{"input":{"type":"structure","required":["projectArn","deviceArn"],"members":{"projectArn":{},"deviceArn":{},"instanceArn":{},"sshPublicKey":{},"remoteDebugEnabled":{"type":"boolean"},"remoteRecordEnabled":{"type":"boolean"},"remoteRecordAppArn":{},"name":{},"clientId":{},"configuration":{"type":"structure","members":{"billingMethod":{},"vpceConfigurationArns":{"shape":"Sz"}}},"interactionMode":{},"skipAppResign":{"type":"boolean"}}},"output":{"type":"structure","members":{"remoteAccessSession":{"shape":"S12"}}}},"CreateTestGridProject":{"input":{"type":"structure","required":["name"],"members":{"name":{},"description":{}}},"output":{"type":"structure","members":{"testGridProject":{"shape":"S1n"}}}},"CreateTestGridUrl":{"input":{"type":"structure","required":["projectArn","expiresInSeconds"],"members":{"projectArn":{},"expiresInSeconds":{"type":"integer"}}},"output":{"type":"structure","members":{"url":{},"expires":{"type":"timestamp"}}}},"CreateUpload":{"input":{"type":"structure","required":["projectArn","name","type"],"members":{"projectArn":{},"name":{},"type":{},"contentType":{}}},"output":{"type":"structure","members":{"upload":{"shape":"S1w"}}}},"CreateVPCEConfiguration":{"input":{"type":"structure","required":["vpceConfigurationName","vpceServiceName","serviceDnsName"],"members":{"vpceConfigurationName":{},"vpceServiceName":{},"serviceDnsName":{},"vpceConfigurationDescription":{}}},"output":{"type":"structure","members":{"vpceConfiguration":{"shape":"S27"}}}},"DeleteDevicePool":{"input":{"type":"structure","required":["arn"],"members":{"arn":{}}},"output":{"type":"structure","members":{}}},"DeleteInstanceProfile":{"input":{"type":"structure","required":["arn"],"members":{"arn":{}}},"output":{"type":"structure","members":{}}},"DeleteNetworkProfile":{"input":{"type":"structure","required":["arn"],"members":{"arn":{}}},"output":{"type":"structure","members":{}}},"DeleteProject":{"input":{"type":"structure","required":["arn"],"members":{"arn":{}}},"output":{"type":"structure","members":{}}},"DeleteRemoteAccessSession":{"input":{"type":"structure","required":["arn"],"members":{"arn":{}}},"output":{"type":"structure","members":{}}},"DeleteRun":{"input":{"type":"structure","required":["arn"],"members":{"arn":{}}},"output":{"type":"structure","members":{}}},"DeleteTestGridProject":{"input":{"type":"structure","required":["projectArn"],"members":{"projectArn":{}}},"output":{"type":"structure","members":{}}},"DeleteUpload":{"input":{"type":"structure","required":["arn"],"members":{"arn":{}}},"output":{"type":"structure","members":{}}},"DeleteVPCEConfiguration":{"input":{"type":"structure","required":["arn"],"members":{"arn":{}}},"output":{"type":"structure","members":{}}},"GetAccountSettings":{"input":{"type":"structure","members":{}},"output":{"type":"structure","members":{"accountSettings":{"type":"structure","members":{"awsAccountNumber":{},"unmeteredDevices":{"shape":"S2u"},"unmeteredRemoteAccessDevices":{"shape":"S2u"},"maxJobTimeoutMinutes":{"type":"integer"},"trialMinutes":{"type":"structure","members":{"total":{"type":"double"},"remaining":{"type":"double"}}},"maxSlots":{"type":"map","key":{},"value":{"type":"integer"}},"defaultJobTimeoutMinutes":{"type":"integer"},"skipAppResign":{"type":"boolean"}}}}}},"GetDevice":{"input":{"type":"structure","required":["arn"],"members":{"arn":{}}},"output":{"type":"structure","members":{"device":{"shape":"S15"}}}},"GetDeviceInstance":{"input":{"type":"structure","required":["arn"],"members":{"arn":{}}},"output":{"type":"structure","members":{"deviceInstance":{"shape":"S1c"}}}},"GetDevicePool":{"input":{"type":"structure","required":["arn"],"members":{"arn":{}}},"output":{"type":"structure","members":{"devicePool":{"shape":"Sc"}}}},"GetDevicePoolCompatibility":{"input":{"type":"structure","required":["devicePoolArn"],"members":{"devicePoolArn":{},"appArn":{},"testType":{},"test":{"shape":"S35"},"configuration":{"shape":"S38"}}},"output":{"type":"structure","members":{"compatibleDevices":{"shape":"S3g"},"incompatibleDevices":{"shape":"S3g"}}}},"GetInstanceProfile":{"input":{"type":"structure","required":["arn"],"members":{"arn":{}}},"output":{"type":"structure","members":{"instanceProfile":{"shape":"Si"}}}},"GetJob":{"input":{"type":"structure","required":["arn"],"members":{"arn":{}}},"output":{"type":"structure","members":{"job":{"shape":"S3o"}}}},"GetNetworkProfile":{"input":{"type":"structure","required":["arn"],"members":{"arn":{}}},"output":{"type":"structure","members":{"networkProfile":{"shape":"So"}}}},"GetOfferingStatus":{"input":{"type":"structure","members":{"nextToken":{}}},"output":{"type":"structure","members":{"current":{"shape":"S3w"},"nextPeriod":{"shape":"S3w"},"nextToken":{}}}},"GetProject":{"input":{"type":"structure","required":["arn"],"members":{"arn":{}}},"output":{"type":"structure","members":{"project":{"shape":"Ss"}}}},"GetRemoteAccessSession":{"input":{"type":"structure","required":["arn"],"members":{"arn":{}}},"output":{"type":"structure","members":{"remoteAccessSession":{"shape":"S12"}}}},"GetRun":{"input":{"type":"structure","required":["arn"],"members":{"arn":{}}},"output":{"type":"structure","members":{"run":{"shape":"S4d"}}}},"GetSuite":{"input":{"type":"structure","required":["arn"],"members":{"arn":{}}},"output":{"type":"structure","members":{"suite":{"shape":"S4m"}}}},"GetTest":{"input":{"type":"structure","required":["arn"],"members":{"arn":{}}},"output":{"type":"structure","members":{"test":{"shape":"S4p"}}}},"GetTestGridProject":{"input":{"type":"structure","required":["projectArn"],"members":{"projectArn":{}}},"output":{"type":"structure","members":{"testGridProject":{"shape":"S1n"}}}},"GetTestGridSession":{"input":{"type":"structure","members":{"projectArn":{},"sessionId":{},"sessionArn":{}}},"output":{"type":"structure","members":{"testGridSession":{"shape":"S4v"}}}},"GetUpload":{"input":{"type":"structure","required":["arn"],"members":{"arn":{}}},"output":{"type":"structure","members":{"upload":{"shape":"S1w"}}}},"GetVPCEConfiguration":{"input":{"type":"structure","required":["arn"],"members":{"arn":{}}},"output":{"type":"structure","members":{"vpceConfiguration":{"shape":"S27"}}}},"InstallToRemoteAccessSession":{"input":{"type":"structure","required":["remoteAccessSessionArn","appArn"],"members":{"remoteAccessSessionArn":{},"appArn":{}}},"output":{"type":"structure","members":{"appUpload":{"shape":"S1w"}}}},"ListArtifacts":{"input":{"type":"structure","required":["arn","type"],"members":{"arn":{},"type":{},"nextToken":{}}},"output":{"type":"structure","members":{"artifacts":{"type":"list","member":{"type":"structure","members":{"arn":{},"name":{},"type":{},"extension":{},"url":{}}}},"nextToken":{}}}},"ListDeviceInstances":{"input":{"type":"structure","members":{"maxResults":{"type":"integer"},"nextToken":{}}},"output":{"type":"structure","members":{"deviceInstances":{"shape":"S1b"},"nextToken":{}}}},"ListDevicePools":{"input":{"type":"structure","required":["arn"],"members":{"arn":{},"type":{},"nextToken":{}}},"output":{"type":"structure","members":{"devicePools":{"type":"list","member":{"shape":"Sc"}},"nextToken":{}}}},"ListDevices":{"input":{"type":"structure","members":{"arn":{},"nextToken":{},"filters":{"shape":"S4g"}}},"output":{"type":"structure","members":{"devices":{"type":"list","member":{"shape":"S15"}},"nextToken":{}}}},"ListInstanceProfiles":{"input":{"type":"structure","members":{"maxResults":{"type":"integer"},"nextToken":{}}},"output":{"type":"structure","members":{"instanceProfiles":{"type":"list","member":{"shape":"Si"}},"nextToken":{}}}},"ListJobs":{"input":{"type":"structure","required":["arn"],"members":{"arn":{},"nextToken":{}}},"output":{"type":"structure","members":{"jobs":{"type":"list","member":{"shape":"S3o"}},"nextToken":{}}}},"ListNetworkProfiles":{"input":{"type":"structure","required":["arn"],"members":{"arn":{},"type":{},"nextToken":{}}},"output":{"type":"structure","members":{"networkProfiles":{"type":"list","member":{"shape":"So"}},"nextToken":{}}}},"ListOfferingPromotions":{"input":{"type":"structure","members":{"nextToken":{}}},"output":{"type":"structure","members":{"offeringPromotions":{"type":"list","member":{"type":"structure","members":{"id":{},"description":{}}}},"nextToken":{}}}},"ListOfferingTransactions":{"input":{"type":"structure","members":{"nextToken":{}}},"output":{"type":"structure","members":{"offeringTransactions":{"type":"list","member":{"shape":"S5y"}},"nextToken":{}}}},"ListOfferings":{"input":{"type":"structure","members":{"nextToken":{}}},"output":{"type":"structure","members":{"offerings":{"type":"list","member":{"shape":"S40"}},"nextToken":{}}}},"ListProjects":{"input":{"type":"structure","members":{"arn":{},"nextToken":{}}},"output":{"type":"structure","members":{"projects":{"type":"list","member":{"shape":"Ss"}},"nextToken":{}}}},"ListRemoteAccessSessions":{"input":{"type":"structure","required":["arn"],"members":{"arn":{},"nextToken":{}}},"output":{"type":"structure","members":{"remoteAccessSessions":{"type":"list","member":{"shape":"S12"}},"nextToken":{}}}},"ListRuns":{"input":{"type":"structure","required":["arn"],"members":{"arn":{},"nextToken":{}}},"output":{"type":"structure","members":{"runs":{"type":"list","member":{"shape":"S4d"}},"nextToken":{}}}},"ListSamples":{"input":{"type":"structure","required":["arn"],"members":{"arn":{},"nextToken":{}}},"output":{"type":"structure","members":{"samples":{"type":"list","member":{"type":"structure","members":{"arn":{},"type":{},"url":{}}}},"nextToken":{}}}},"ListSuites":{"input":{"type":"structure","required":["arn"],"members":{"arn":{},"nextToken":{}}},"output":{"type":"structure","members":{"suites":{"type":"list","member":{"shape":"S4m"}},"nextToken":{}}}},"ListTagsForResource":{"input":{"type":"structure","required":["ResourceARN"],"members":{"ResourceARN":{}}},"output":{"type":"structure","members":{"Tags":{"shape":"S6m"}}}},"ListTestGridProjects":{"input":{"type":"structure","members":{"maxResult":{"type":"integer"},"nextToken":{}}},"output":{"type":"structure","members":{"testGridProjects":{"type":"list","member":{"shape":"S1n"}},"nextToken":{}}}},"ListTestGridSessionActions":{"input":{"type":"structure","required":["sessionArn"],"members":{"sessionArn":{},"maxResult":{"type":"integer"},"nextToken":{}}},"output":{"type":"structure","members":{"actions":{"type":"list","member":{"type":"structure","members":{"action":{},"started":{"type":"timestamp"},"duration":{"type":"long"},"statusCode":{},"requestMethod":{}}}},"nextToken":{}}}},"ListTestGridSessionArtifacts":{"input":{"type":"structure","required":["sessionArn"],"members":{"sessionArn":{},"type":{},"maxResult":{"type":"integer"},"nextToken":{}}},"output":{"type":"structure","members":{"artifacts":{"type":"list","member":{"type":"structure","members":{"filename":{},"type":{},"url":{}}}},"nextToken":{}}}},"ListTestGridSessions":{"input":{"type":"structure","required":["projectArn"],"members":{"projectArn":{},"status":{},"creationTimeAfter":{"type":"timestamp"},"creationTimeBefore":{"type":"timestamp"},"endTimeAfter":{"type":"timestamp"},"endTimeBefore":{"type":"timestamp"},"maxResult":{"type":"integer"},"nextToken":{}}},"output":{"type":"structure","members":{"testGridSessions":{"type":"list","member":{"shape":"S4v"}},"nextToken":{}}}},"ListTests":{"input":{"type":"structure","required":["arn"],"members":{"arn":{},"nextToken":{}}},"output":{"type":"structure","members":{"tests":{"type":"list","member":{"shape":"S4p"}},"nextToken":{}}}},"ListUniqueProblems":{"input":{"type":"structure","required":["arn"],"members":{"arn":{},"nextToken":{}}},"output":{"type":"structure","members":{"uniqueProblems":{"type":"map","key":{},"value":{"type":"list","member":{"type":"structure","members":{"message":{},"problems":{"type":"list","member":{"type":"structure","members":{"run":{"shape":"S7h"},"job":{"shape":"S7h"},"suite":{"shape":"S7h"},"test":{"shape":"S7h"},"device":{"shape":"S15"},"result":{},"message":{}}}}}}}},"nextToken":{}}}},"ListUploads":{"input":{"type":"structure","required":["arn"],"members":{"arn":{},"type":{},"nextToken":{}}},"output":{"type":"structure","members":{"uploads":{"type":"list","member":{"shape":"S1w"}},"nextToken":{}}}},"ListVPCEConfigurations":{"input":{"type":"structure","members":{"maxResults":{"type":"integer"},"nextToken":{}}},"output":{"type":"structure","members":{"vpceConfigurations":{"type":"list","member":{"shape":"S27"}},"nextToken":{}}}},"PurchaseOffering":{"input":{"type":"structure","members":{"offeringId":{},"quantity":{"type":"integer"},"offeringPromotionId":{}}},"output":{"type":"structure","members":{"offeringTransaction":{"shape":"S5y"}}}},"RenewOffering":{"input":{"type":"structure","members":{"offeringId":{},"quantity":{"type":"integer"}}},"output":{"type":"structure","members":{"offeringTransaction":{"shape":"S5y"}}}},"ScheduleRun":{"input":{"type":"structure","required":["projectArn","test"],"members":{"projectArn":{},"appArn":{},"devicePoolArn":{},"deviceSelectionConfiguration":{"type":"structure","required":["filters","maxDevices"],"members":{"filters":{"shape":"S4g"},"maxDevices":{"type":"integer"}}},"name":{},"test":{"shape":"S35"},"configuration":{"shape":"S38"},"executionConfiguration":{"type":"structure","members":{"jobTimeoutMinutes":{"type":"integer"},"accountsCleanup":{"type":"boolean"},"appPackagesCleanup":{"type":"boolean"},"videoCapture":{"type":"boolean"},"skipAppResign":{"type":"boolean"}}}}},"output":{"type":"structure","members":{"run":{"shape":"S4d"}}}},"StopJob":{"input":{"type":"structure","required":["arn"],"members":{"arn":{}}},"output":{"type":"structure","members":{"job":{"shape":"S3o"}}}},"StopRemoteAccessSession":{"input":{"type":"structure","required":["arn"],"members":{"arn":{}}},"output":{"type":"structure","members":{"remoteAccessSession":{"shape":"S12"}}}},"StopRun":{"input":{"type":"structure","required":["arn"],"members":{"arn":{}}},"output":{"type":"structure","members":{"run":{"shape":"S4d"}}}},"TagResource":{"input":{"type":"structure","required":["ResourceARN","Tags"],"members":{"ResourceARN":{},"Tags":{"shape":"S6m"}}},"output":{"type":"structure","members":{}}},"UntagResource":{"input":{"type":"structure","required":["ResourceARN","TagKeys"],"members":{"ResourceARN":{},"TagKeys":{"type":"list","member":{}}}},"output":{"type":"structure","members":{}}},"UpdateDeviceInstance":{"input":{"type":"structure","required":["arn"],"members":{"arn":{},"profileArn":{},"labels":{"shape":"S1d"}}},"output":{"type":"structure","members":{"deviceInstance":{"shape":"S1c"}}}},"UpdateDevicePool":{"input":{"type":"structure","required":["arn"],"members":{"arn":{},"name":{},"description":{},"rules":{"shape":"S5"},"maxDevices":{"type":"integer"},"clearMaxDevices":{"type":"boolean"}}},"output":{"type":"structure","members":{"devicePool":{"shape":"Sc"}}}},"UpdateInstanceProfile":{"input":{"type":"structure","required":["arn"],"members":{"arn":{},"name":{},"description":{},"packageCleanup":{"type":"boolean"},"excludeAppPackagesFromCleanup":{"shape":"Sg"},"rebootAfterUse":{"type":"boolean"}}},"output":{"type":"structure","members":{"instanceProfile":{"shape":"Si"}}}},"UpdateNetworkProfile":{"input":{"type":"structure","required":["arn"],"members":{"arn":{},"name":{},"description":{},"type":{},"uplinkBandwidthBits":{"type":"long"},"downlinkBandwidthBits":{"type":"long"},"uplinkDelayMs":{"type":"long"},"downlinkDelayMs":{"type":"long"},"uplinkJitterMs":{"type":"long"},"downlinkJitterMs":{"type":"long"},"uplinkLossPercent":{"type":"integer"},"downlinkLossPercent":{"type":"integer"}}},"output":{"type":"structure","members":{"networkProfile":{"shape":"So"}}}},"UpdateProject":{"input":{"type":"structure","required":["arn"],"members":{"arn":{},"name":{},"defaultJobTimeoutMinutes":{"type":"integer"}}},"output":{"type":"structure","members":{"project":{"shape":"Ss"}}}},"UpdateTestGridProject":{"input":{"type":"structure","required":["projectArn"],"members":{"projectArn":{},"name":{},"description":{}}},"output":{"type":"structure","members":{"testGridProject":{"shape":"S1n"}}}},"UpdateUpload":{"input":{"type":"structure","required":["arn"],"members":{"arn":{},"name":{},"contentType":{},"editContent":{"type":"boolean"}}},"output":{"type":"structure","members":{"upload":{"shape":"S1w"}}}},"UpdateVPCEConfiguration":{"input":{"type":"structure","required":["arn"],"members":{"arn":{},"vpceConfigurationName":{},"vpceServiceName":{},"serviceDnsName":{},"vpceConfigurationDescription":{}}},"output":{"type":"structure","members":{"vpceConfiguration":{"shape":"S27"}}}}},"shapes":{"S5":{"type":"list","member":{"type":"structure","members":{"attribute":{},"operator":{},"value":{}}}},"Sc":{"type":"structure","members":{"arn":{},"name":{},"description":{},"type":{},"rules":{"shape":"S5"},"maxDevices":{"type":"integer"}}},"Sg":{"type":"list","member":{}},"Si":{"type":"structure","members":{"arn":{},"packageCleanup":{"type":"boolean"},"excludeAppPackagesFromCleanup":{"shape":"Sg"},"rebootAfterUse":{"type":"boolean"},"name":{},"description":{}}},"So":{"type":"structure","members":{"arn":{},"name":{},"description":{},"type":{},"uplinkBandwidthBits":{"type":"long"},"downlinkBandwidthBits":{"type":"long"},"uplinkDelayMs":{"type":"long"},"downlinkDelayMs":{"type":"long"},"uplinkJitterMs":{"type":"long"},"downlinkJitterMs":{"type":"long"},"uplinkLossPercent":{"type":"integer"},"downlinkLossPercent":{"type":"integer"}}},"Ss":{"type":"structure","members":{"arn":{},"name":{},"defaultJobTimeoutMinutes":{"type":"integer"},"created":{"type":"timestamp"}}},"Sz":{"type":"list","member":{}},"S12":{"type":"structure","members":{"arn":{},"name":{},"created":{"type":"timestamp"},"status":{},"result":{},"message":{},"started":{"type":"timestamp"},"stopped":{"type":"timestamp"},"device":{"shape":"S15"},"instanceArn":{},"remoteDebugEnabled":{"type":"boolean"},"remoteRecordEnabled":{"type":"boolean"},"remoteRecordAppArn":{},"hostAddress":{},"clientId":{},"billingMethod":{},"deviceMinutes":{"shape":"S1h"},"endpoint":{},"deviceUdid":{},"interactionMode":{},"skipAppResign":{"type":"boolean"}}},"S15":{"type":"structure","members":{"arn":{},"name":{},"manufacturer":{},"model":{},"modelId":{},"formFactor":{},"platform":{},"os":{},"cpu":{"type":"structure","members":{"frequency":{},"architecture":{},"clock":{"type":"double"}}},"resolution":{"type":"structure","members":{"width":{"type":"integer"},"height":{"type":"integer"}}},"heapSize":{"type":"long"},"memory":{"type":"long"},"image":{},"carrier":{},"radio":{},"remoteAccessEnabled":{"type":"boolean"},"remoteDebugEnabled":{"type":"boolean"},"fleetType":{},"fleetName":{},"instances":{"shape":"S1b"},"availability":{}}},"S1b":{"type":"list","member":{"shape":"S1c"}},"S1c":{"type":"structure","members":{"arn":{},"deviceArn":{},"labels":{"shape":"S1d"},"status":{},"udid":{},"instanceProfile":{"shape":"Si"}}},"S1d":{"type":"list","member":{}},"S1h":{"type":"structure","members":{"total":{"type":"double"},"metered":{"type":"double"},"unmetered":{"type":"double"}}},"S1n":{"type":"structure","members":{"arn":{},"name":{},"description":{},"created":{"type":"timestamp"}}},"S1w":{"type":"structure","members":{"arn":{},"name":{},"created":{"type":"timestamp"},"type":{},"status":{},"url":{},"metadata":{},"contentType":{},"message":{},"category":{}}},"S27":{"type":"structure","members":{"arn":{},"vpceConfigurationName":{},"vpceServiceName":{},"serviceDnsName":{},"vpceConfigurationDescription":{}}},"S2u":{"type":"map","key":{},"value":{"type":"integer"}},"S35":{"type":"structure","required":["type"],"members":{"type":{},"testPackageArn":{},"testSpecArn":{},"filter":{},"parameters":{"type":"map","key":{},"value":{}}}},"S38":{"type":"structure","members":{"extraDataPackageArn":{},"networkProfileArn":{},"locale":{},"location":{"shape":"S39"},"vpceConfigurationArns":{"shape":"Sz"},"customerArtifactPaths":{"shape":"S3a"},"radios":{"shape":"S3e"},"auxiliaryApps":{"shape":"Sz"},"billingMethod":{}}},"S39":{"type":"structure","required":["latitude","longitude"],"members":{"latitude":{"type":"double"},"longitude":{"type":"double"}}},"S3a":{"type":"structure","members":{"iosPaths":{"type":"list","member":{}},"androidPaths":{"type":"list","member":{}},"deviceHostPaths":{"type":"list","member":{}}}},"S3e":{"type":"structure","members":{"wifi":{"type":"boolean"},"bluetooth":{"type":"boolean"},"nfc":{"type":"boolean"},"gps":{"type":"boolean"}}},"S3g":{"type":"list","member":{"type":"structure","members":{"device":{"shape":"S15"},"compatible":{"type":"boolean"},"incompatibilityMessages":{"type":"list","member":{"type":"structure","members":{"message":{},"type":{}}}}}}},"S3o":{"type":"structure","members":{"arn":{},"name":{},"type":{},"created":{"type":"timestamp"},"status":{},"result":{},"started":{"type":"timestamp"},"stopped":{"type":"timestamp"},"counters":{"shape":"S3p"},"message":{},"device":{"shape":"S15"},"instanceArn":{},"deviceMinutes":{"shape":"S1h"},"videoEndpoint":{},"videoCapture":{"type":"boolean"}}},"S3p":{"type":"structure","members":{"total":{"type":"integer"},"passed":{"type":"integer"},"failed":{"type":"integer"},"warned":{"type":"integer"},"errored":{"type":"integer"},"stopped":{"type":"integer"},"skipped":{"type":"integer"}}},"S3w":{"type":"map","key":{},"value":{"shape":"S3y"}},"S3y":{"type":"structure","members":{"type":{},"offering":{"shape":"S40"},"quantity":{"type":"integer"},"effectiveOn":{"type":"timestamp"}}},"S40":{"type":"structure","members":{"id":{},"description":{},"type":{},"platform":{},"recurringCharges":{"type":"list","member":{"type":"structure","members":{"cost":{"shape":"S44"},"frequency":{}}}}}},"S44":{"type":"structure","members":{"amount":{"type":"double"},"currencyCode":{}}},"S4d":{"type":"structure","members":{"arn":{},"name":{},"type":{},"platform":{},"created":{"type":"timestamp"},"status":{},"result":{},"started":{"type":"timestamp"},"stopped":{"type":"timestamp"},"counters":{"shape":"S3p"},"message":{},"totalJobs":{"type":"integer"},"completedJobs":{"type":"integer"},"billingMethod":{},"deviceMinutes":{"shape":"S1h"},"networkProfile":{"shape":"So"},"parsingResultUrl":{},"resultCode":{},"seed":{"type":"integer"},"appUpload":{},"eventCount":{"type":"integer"},"jobTimeoutMinutes":{"type":"integer"},"devicePoolArn":{},"locale":{},"radios":{"shape":"S3e"},"location":{"shape":"S39"},"customerArtifactPaths":{"shape":"S3a"},"webUrl":{},"skipAppResign":{"type":"boolean"},"testSpecArn":{},"deviceSelectionResult":{"type":"structure","members":{"filters":{"shape":"S4g"},"matchedDevicesCount":{"type":"integer"},"maxDevices":{"type":"integer"}}}}},"S4g":{"type":"list","member":{"type":"structure","members":{"attribute":{},"operator":{},"values":{"type":"list","member":{}}}}},"S4m":{"type":"structure","members":{"arn":{},"name":{},"type":{},"created":{"type":"timestamp"},"status":{},"result":{},"started":{"type":"timestamp"},"stopped":{"type":"timestamp"},"counters":{"shape":"S3p"},"message":{},"deviceMinutes":{"shape":"S1h"}}},"S4p":{"type":"structure","members":{"arn":{},"name":{},"type":{},"created":{"type":"timestamp"},"status":{},"result":{},"started":{"type":"timestamp"},"stopped":{"type":"timestamp"},"counters":{"shape":"S3p"},"message":{},"deviceMinutes":{"shape":"S1h"}}},"S4v":{"type":"structure","members":{"arn":{},"status":{},"created":{"type":"timestamp"},"ended":{"type":"timestamp"},"billingMinutes":{"type":"double"},"seleniumProperties":{}}},"S5y":{"type":"structure","members":{"offeringStatus":{"shape":"S3y"},"transactionId":{},"offeringPromotionId":{},"createdOn":{"type":"timestamp"},"cost":{"shape":"S44"}}},"S6m":{"type":"list","member":{"type":"structure","required":["Key","Value"],"members":{"Key":{},"Value":{}}}},"S7h":{"type":"structure","members":{"arn":{},"name":{}}}}}; /***/ }), -/***/ 4645: -/***/ (function(__unusedmodule, exports, __webpack_require__) { - -;(function (sax) { // wrapper for non-node envs - sax.parser = function (strict, opt) { return new SAXParser(strict, opt) } - sax.SAXParser = SAXParser - sax.SAXStream = SAXStream - sax.createStream = createStream - - // When we pass the MAX_BUFFER_LENGTH position, start checking for buffer overruns. - // When we check, schedule the next check for MAX_BUFFER_LENGTH - (max(buffer lengths)), - // since that's the earliest that a buffer overrun could occur. This way, checks are - // as rare as required, but as often as necessary to ensure never crossing this bound. - // Furthermore, buffers are only tested at most once per write(), so passing a very - // large string into write() might have undesirable effects, but this is manageable by - // the caller, so it is assumed to be safe. Thus, a call to write() may, in the extreme - // edge case, result in creating at most one complete copy of the string passed in. - // Set to Infinity to have unlimited buffers. - sax.MAX_BUFFER_LENGTH = 64 * 1024 - - var buffers = [ - 'comment', 'sgmlDecl', 'textNode', 'tagName', 'doctype', - 'procInstName', 'procInstBody', 'entity', 'attribName', - 'attribValue', 'cdata', 'script' - ] +/***/ 2414: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - sax.EVENTS = [ - 'text', - 'processinginstruction', - 'sgmldeclaration', - 'doctype', - 'comment', - 'opentagstart', - 'attribute', - 'opentag', - 'closetag', - 'opencdata', - 'cdata', - 'closecdata', - 'error', - 'end', - 'ready', - 'script', - 'opennamespace', - 'closenamespace' - ] +"use strict"; - function SAXParser (strict, opt) { - if (!(this instanceof SAXParser)) { - return new SAXParser(strict, opt) - } +const diagnosticsChannel = __nccwpck_require__(3053) +const util = __nccwpck_require__(7975) + +const undiciDebugLog = util.debuglog('undici') +const fetchDebuglog = util.debuglog('fetch') +const websocketDebuglog = util.debuglog('websocket') +let isClientSet = false +const channels = { + // Client + beforeConnect: diagnosticsChannel.channel('undici:client:beforeConnect'), + connected: diagnosticsChannel.channel('undici:client:connected'), + connectError: diagnosticsChannel.channel('undici:client:connectError'), + sendHeaders: diagnosticsChannel.channel('undici:client:sendHeaders'), + // Request + create: diagnosticsChannel.channel('undici:request:create'), + bodySent: diagnosticsChannel.channel('undici:request:bodySent'), + headers: diagnosticsChannel.channel('undici:request:headers'), + trailers: diagnosticsChannel.channel('undici:request:trailers'), + error: diagnosticsChannel.channel('undici:request:error'), + // WebSocket + open: diagnosticsChannel.channel('undici:websocket:open'), + close: diagnosticsChannel.channel('undici:websocket:close'), + socketError: diagnosticsChannel.channel('undici:websocket:socket_error'), + ping: diagnosticsChannel.channel('undici:websocket:ping'), + pong: diagnosticsChannel.channel('undici:websocket:pong') +} - var parser = this - clearBuffers(parser) - parser.q = parser.c = '' - parser.bufferCheckPosition = sax.MAX_BUFFER_LENGTH - parser.opt = opt || {} - parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags - parser.looseCase = parser.opt.lowercase ? 'toLowerCase' : 'toUpperCase' - parser.tags = [] - parser.closed = parser.closedRoot = parser.sawRoot = false - parser.tag = parser.error = null - parser.strict = !!strict - parser.noscript = !!(strict || parser.opt.noscript) - parser.state = S.BEGIN - parser.strictEntities = parser.opt.strictEntities - parser.ENTITIES = parser.strictEntities ? Object.create(sax.XML_ENTITIES) : Object.create(sax.ENTITIES) - parser.attribList = [] +if (undiciDebugLog.enabled || fetchDebuglog.enabled) { + const debuglog = fetchDebuglog.enabled ? fetchDebuglog : undiciDebugLog + + // Track all Client events + diagnosticsChannel.channel('undici:client:beforeConnect').subscribe(evt => { + const { + connectParams: { version, protocol, port, host } + } = evt + debuglog( + 'connecting to %s using %s%s', + `${host}${port ? `:${port}` : ''}`, + protocol, + version + ) + }) - // namespaces form a prototype chain. - // it always points at the current tag, - // which protos to its parent tag. - if (parser.opt.xmlns) { - parser.ns = Object.create(rootNS) - } + diagnosticsChannel.channel('undici:client:connected').subscribe(evt => { + const { + connectParams: { version, protocol, port, host } + } = evt + debuglog( + 'connected to %s using %s%s', + `${host}${port ? `:${port}` : ''}`, + protocol, + version + ) + }) - // mostly just for error reporting - parser.trackPosition = parser.opt.position !== false - if (parser.trackPosition) { - parser.position = parser.line = parser.column = 0 - } - emit(parser, 'onready') - } + diagnosticsChannel.channel('undici:client:connectError').subscribe(evt => { + const { + connectParams: { version, protocol, port, host }, + error + } = evt + debuglog( + 'connection to %s using %s%s errored - %s', + `${host}${port ? `:${port}` : ''}`, + protocol, + version, + error.message + ) + }) - if (!Object.create) { - Object.create = function (o) { - function F () {} - F.prototype = o - var newf = new F() - return newf - } + diagnosticsChannel.channel('undici:client:sendHeaders').subscribe(evt => { + const { + request: { method, path, origin } + } = evt + debuglog('sending request to %s %s/%s', method, origin, path) + }) + + // Track Request events + diagnosticsChannel.channel('undici:request:headers').subscribe(evt => { + const { + request: { method, path, origin }, + response: { statusCode } + } = evt + debuglog( + 'received response to %s %s/%s - HTTP %d', + method, + origin, + path, + statusCode + ) + }) + + diagnosticsChannel.channel('undici:request:trailers').subscribe(evt => { + const { + request: { method, path, origin } + } = evt + debuglog('trailers received from %s %s/%s', method, origin, path) + }) + + diagnosticsChannel.channel('undici:request:error').subscribe(evt => { + const { + request: { method, path, origin }, + error + } = evt + debuglog( + 'request to %s %s/%s errored - %s', + method, + origin, + path, + error.message + ) + }) + + isClientSet = true +} + +if (websocketDebuglog.enabled) { + if (!isClientSet) { + const debuglog = undiciDebugLog.enabled ? undiciDebugLog : websocketDebuglog + diagnosticsChannel.channel('undici:client:beforeConnect').subscribe(evt => { + const { + connectParams: { version, protocol, port, host } + } = evt + debuglog( + 'connecting to %s%s using %s%s', + host, + port ? `:${port}` : '', + protocol, + version + ) + }) + + diagnosticsChannel.channel('undici:client:connected').subscribe(evt => { + const { + connectParams: { version, protocol, port, host } + } = evt + debuglog( + 'connected to %s%s using %s%s', + host, + port ? `:${port}` : '', + protocol, + version + ) + }) + + diagnosticsChannel.channel('undici:client:connectError').subscribe(evt => { + const { + connectParams: { version, protocol, port, host }, + error + } = evt + debuglog( + 'connection to %s%s using %s%s errored - %s', + host, + port ? `:${port}` : '', + protocol, + version, + error.message + ) + }) + + diagnosticsChannel.channel('undici:client:sendHeaders').subscribe(evt => { + const { + request: { method, path, origin } + } = evt + debuglog('sending request to %s %s/%s', method, origin, path) + }) } - if (!Object.keys) { - Object.keys = function (o) { - var a = [] - for (var i in o) if (o.hasOwnProperty(i)) a.push(i) - return a - } + // Track all WebSocket events + diagnosticsChannel.channel('undici:websocket:open').subscribe(evt => { + const { + address: { address, port } + } = evt + websocketDebuglog('connection opened %s%s', address, port ? `:${port}` : '') + }) + + diagnosticsChannel.channel('undici:websocket:close').subscribe(evt => { + const { websocket, code, reason } = evt + websocketDebuglog( + 'closed connection to %s - %s %s', + websocket.url, + code, + reason + ) + }) + + diagnosticsChannel.channel('undici:websocket:socket_error').subscribe(err => { + websocketDebuglog('connection errored - %s', err.message) + }) + + diagnosticsChannel.channel('undici:websocket:ping').subscribe(evt => { + websocketDebuglog('ping received') + }) + + diagnosticsChannel.channel('undici:websocket:pong').subscribe(evt => { + websocketDebuglog('pong received') + }) +} + +module.exports = { + channels +} + + +/***/ }), + +/***/ 8707: +/***/ ((module) => { + +"use strict"; + + +const kUndiciError = Symbol.for('undici.error.UND_ERR') +class UndiciError extends Error { + constructor (message) { + super(message) + this.name = 'UndiciError' + this.code = 'UND_ERR' } - function checkBufferLength (parser) { - var maxAllowed = Math.max(sax.MAX_BUFFER_LENGTH, 10) - var maxActual = 0 - for (var i = 0, l = buffers.length; i < l; i++) { - var len = parser[buffers[i]].length - if (len > maxAllowed) { - // Text/cdata nodes can get big, and since they're buffered, - // we can get here under normal conditions. - // Avoid issues by emitting the text node now, - // so at least it won't get any bigger. - switch (buffers[i]) { - case 'textNode': - closeText(parser) - break + static [Symbol.hasInstance] (instance) { + return instance && instance[kUndiciError] === true + } - case 'cdata': - emitNode(parser, 'oncdata', parser.cdata) - parser.cdata = '' - break + [kUndiciError] = true +} - case 'script': - emitNode(parser, 'onscript', parser.script) - parser.script = '' - break +const kConnectTimeoutError = Symbol.for('undici.error.UND_ERR_CONNECT_TIMEOUT') +class ConnectTimeoutError extends UndiciError { + constructor (message) { + super(message) + this.name = 'ConnectTimeoutError' + this.message = message || 'Connect Timeout Error' + this.code = 'UND_ERR_CONNECT_TIMEOUT' + } - default: - error(parser, 'Max buffer length exceeded: ' + buffers[i]) - } - } - maxActual = Math.max(maxActual, len) - } - // schedule the next check for the earliest possible buffer overrun. - var m = sax.MAX_BUFFER_LENGTH - maxActual - parser.bufferCheckPosition = m + parser.position + static [Symbol.hasInstance] (instance) { + return instance && instance[kConnectTimeoutError] === true } - function clearBuffers (parser) { - for (var i = 0, l = buffers.length; i < l; i++) { - parser[buffers[i]] = '' - } + [kConnectTimeoutError] = true +} + +const kHeadersTimeoutError = Symbol.for('undici.error.UND_ERR_HEADERS_TIMEOUT') +class HeadersTimeoutError extends UndiciError { + constructor (message) { + super(message) + this.name = 'HeadersTimeoutError' + this.message = message || 'Headers Timeout Error' + this.code = 'UND_ERR_HEADERS_TIMEOUT' } - function flushBuffers (parser) { - closeText(parser) - if (parser.cdata !== '') { - emitNode(parser, 'oncdata', parser.cdata) - parser.cdata = '' - } - if (parser.script !== '') { - emitNode(parser, 'onscript', parser.script) - parser.script = '' - } + static [Symbol.hasInstance] (instance) { + return instance && instance[kHeadersTimeoutError] === true } - SAXParser.prototype = { - end: function () { end(this) }, - write: write, - resume: function () { this.error = null; return this }, - close: function () { return this.write(null) }, - flush: function () { flushBuffers(this) } + [kHeadersTimeoutError] = true +} + +const kHeadersOverflowError = Symbol.for('undici.error.UND_ERR_HEADERS_OVERFLOW') +class HeadersOverflowError extends UndiciError { + constructor (message) { + super(message) + this.name = 'HeadersOverflowError' + this.message = message || 'Headers Overflow Error' + this.code = 'UND_ERR_HEADERS_OVERFLOW' } - var Stream - try { - Stream = __webpack_require__(2413).Stream - } catch (ex) { - Stream = function () {} + static [Symbol.hasInstance] (instance) { + return instance && instance[kHeadersOverflowError] === true } - var streamWraps = sax.EVENTS.filter(function (ev) { - return ev !== 'error' && ev !== 'end' - }) + [kHeadersOverflowError] = true +} - function createStream (strict, opt) { - return new SAXStream(strict, opt) +const kBodyTimeoutError = Symbol.for('undici.error.UND_ERR_BODY_TIMEOUT') +class BodyTimeoutError extends UndiciError { + constructor (message) { + super(message) + this.name = 'BodyTimeoutError' + this.message = message || 'Body Timeout Error' + this.code = 'UND_ERR_BODY_TIMEOUT' } - function SAXStream (strict, opt) { - if (!(this instanceof SAXStream)) { - return new SAXStream(strict, opt) - } + static [Symbol.hasInstance] (instance) { + return instance && instance[kBodyTimeoutError] === true + } - Stream.apply(this) + [kBodyTimeoutError] = true +} - this._parser = new SAXParser(strict, opt) - this.writable = true - this.readable = true +const kResponseStatusCodeError = Symbol.for('undici.error.UND_ERR_RESPONSE_STATUS_CODE') +class ResponseStatusCodeError extends UndiciError { + constructor (message, statusCode, headers, body) { + super(message) + this.name = 'ResponseStatusCodeError' + this.message = message || 'Response Status Code Error' + this.code = 'UND_ERR_RESPONSE_STATUS_CODE' + this.body = body + this.status = statusCode + this.statusCode = statusCode + this.headers = headers + } - var me = this + static [Symbol.hasInstance] (instance) { + return instance && instance[kResponseStatusCodeError] === true + } - this._parser.onend = function () { - me.emit('end') - } + [kResponseStatusCodeError] = true +} - this._parser.onerror = function (er) { - me.emit('error', er) +const kInvalidArgumentError = Symbol.for('undici.error.UND_ERR_INVALID_ARG') +class InvalidArgumentError extends UndiciError { + constructor (message) { + super(message) + this.name = 'InvalidArgumentError' + this.message = message || 'Invalid Argument Error' + this.code = 'UND_ERR_INVALID_ARG' + } - // if didn't throw, then means error was handled. - // go ahead and clear error, so we can write again. - me._parser.error = null - } + static [Symbol.hasInstance] (instance) { + return instance && instance[kInvalidArgumentError] === true + } - this._decoder = null + [kInvalidArgumentError] = true +} - streamWraps.forEach(function (ev) { - Object.defineProperty(me, 'on' + ev, { - get: function () { - return me._parser['on' + ev] - }, - set: function (h) { - if (!h) { - me.removeAllListeners(ev) - me._parser['on' + ev] = h - return h - } - me.on(ev, h) - }, - enumerable: true, - configurable: false - }) - }) +const kInvalidReturnValueError = Symbol.for('undici.error.UND_ERR_INVALID_RETURN_VALUE') +class InvalidReturnValueError extends UndiciError { + constructor (message) { + super(message) + this.name = 'InvalidReturnValueError' + this.message = message || 'Invalid Return Value Error' + this.code = 'UND_ERR_INVALID_RETURN_VALUE' } - SAXStream.prototype = Object.create(Stream.prototype, { - constructor: { - value: SAXStream - } - }) + static [Symbol.hasInstance] (instance) { + return instance && instance[kInvalidReturnValueError] === true + } - SAXStream.prototype.write = function (data) { - if (typeof Buffer === 'function' && - typeof Buffer.isBuffer === 'function' && - Buffer.isBuffer(data)) { - if (!this._decoder) { - var SD = __webpack_require__(4304).StringDecoder - this._decoder = new SD('utf8') - } - data = this._decoder.write(data) - } + [kInvalidReturnValueError] = true +} - this._parser.write(data.toString()) - this.emit('data', data) - return true +const kAbortError = Symbol.for('undici.error.UND_ERR_ABORT') +class AbortError extends UndiciError { + constructor (message) { + super(message) + this.name = 'AbortError' + this.message = message || 'The operation was aborted' + this.code = 'UND_ERR_ABORT' } - SAXStream.prototype.end = function (chunk) { - if (chunk && chunk.length) { - this.write(chunk) - } - this._parser.end() - return true + static [Symbol.hasInstance] (instance) { + return instance && instance[kAbortError] === true } - SAXStream.prototype.on = function (ev, handler) { - var me = this - if (!me._parser['on' + ev] && streamWraps.indexOf(ev) !== -1) { - me._parser['on' + ev] = function () { - var args = arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments) - args.splice(0, 0, ev) - me.emit.apply(me, args) - } - } - - return Stream.prototype.on.call(me, ev, handler) - } - - // character classes and tokens - var whitespace = '\r\n\t ' - - // this really needs to be replaced with character classes. - // XML allows all manner of ridiculous numbers and digits. - var number = '0124356789' - var letter = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' - - // (Letter | "_" | ":") - var quote = '\'"' - var attribEnd = whitespace + '>' - var CDATA = '[CDATA[' - var DOCTYPE = 'DOCTYPE' - var XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace' - var XMLNS_NAMESPACE = 'http://www.w3.org/2000/xmlns/' - var rootNS = { xml: XML_NAMESPACE, xmlns: XMLNS_NAMESPACE } - - // turn all the string character sets into character class objects. - whitespace = charClass(whitespace) - number = charClass(number) - letter = charClass(letter) - - // http://www.w3.org/TR/REC-xml/#NT-NameStartChar - // This implementation works on strings, a single character at a time - // as such, it cannot ever support astral-plane characters (10000-EFFFF) - // without a significant breaking change to either this parser, or the - // JavaScript language. Implementation of an emoji-capable xml parser - // is left as an exercise for the reader. - var nameStart = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/ - - var nameBody = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040\.\d-]/ - - var entityStart = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/ - var entityBody = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040\.\d-]/ - - quote = charClass(quote) - attribEnd = charClass(attribEnd) - - function charClass (str) { - return str.split('').reduce(function (s, c) { - s[c] = true - return s - }, {}) - } - - function isRegExp (c) { - return Object.prototype.toString.call(c) === '[object RegExp]' - } - - function is (charclass, c) { - return isRegExp(charclass) ? !!c.match(charclass) : charclass[c] - } - - function not (charclass, c) { - return !is(charclass, c) - } - - var S = 0 - sax.STATE = { - BEGIN: S++, // leading byte order mark or whitespace - BEGIN_WHITESPACE: S++, // leading whitespace - TEXT: S++, // general stuff - TEXT_ENTITY: S++, // & and such. - OPEN_WAKA: S++, // < - SGML_DECL: S++, // - SCRIPT: S++, //