remove build status note from README

This test triggers the scenario that a required response element exists, which
forces our check for "we do not expect data for this call" to be comptime.
It previously was accidentally runtime, which was solved by making
expected_body_field_len a comptime var.

.drone.yml

@@ -1,37 +0,0 @@
-kind: pipeline
-type: docker
-name: default
-
-steps:
-- name: make
-  image: r.lerch.org/aws-zig-build:1
-  environment:
-    USERNAME:
-      from_secret: docker_username
-    PASSWORD:
-      from_secret: docker_password
-    REGISTRY:
-      from_secret: docker_registry
-  commands:
-  - wget https://ziglang.org/download/0.9.0/zig-linux-x86_64-0.9.0.tar.xz
-  - tar x -C /usr/local -f zig-linux-x86_64-0.9.0.tar.xz
-  - rm /usr/local/bin/zig
-  - ln -s /usr/local/zig-linux-x86_64-0.9.0/zig /usr/local/bin/zig
-  - (cd codegen && zig build test)
-  - zig build # implicitly does a codegen
-  - zig build test
-- name: notify
-  image: plugins/matrix
-  when:
-    status:
-    - success
-    - failure
-  settings:
-    homeserver:
-      from_secret: matrix-homeserver
-    roomid:
-      from_secret: matrix-room-id
-    userid:
-      from_secret: matrix-user-id
-    accesstoken:
-      from_secret: matrix-access-token

.gitea/workflows/build.yaml

@@ -0,0 +1,82 @@
+name: AWS-Zig Build
+on:
+  push:
+    branches:
+      - '*'
+      - '!zig-develop*'
+env:
+  ACTIONS_RUNTIME_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+  ACTIONS_RUNTIME_URL: ${{ env.GITHUB_SERVER_URL }}/api/actions_pipeline/
+jobs:
+  build-zig-amd64-host:
+    runs-on: ubuntu-latest
+    # Need to use the default container with node and all that, so we can
+    # use JS-based actions like actions/checkout@v3...
+    # container:
+    #   image: alpine:3.15.0
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v4
+      - name: Setup Zig
+        uses: mlugg/setup-zig@v1.2.1
+        with:
+          version: 0.13.0
+      - name: Run tests
+        run: zig build test --verbose
+      # Zig build scripts don't have the ability to import depenedencies directly
+      # (https://github.com/ziglang/zig/issues/18164). We can allow downstream
+      # build scripts to import aws with a few tweaks, but we can't @import("src/aws.zig")
+      # until we have our models built. So we have to have the build script
+      # basically modified, only during packaging, to allow this use case
+      #
+      # Zig package manager expects everything to be inside a directory in the archive,
+      # which it then strips out on download. So we need to shove everything inside a directory
+      # the way GitHub/Gitea does for repo archives
+      #
+      # Also, zig tar process doesn't handle gnu format for long names, nor does it seam to
+      # handle posix long name semantics cleanly either. ustar works. This
+      # should be using git archive, but we need our generated code to be part of it
+      - name: Package source code with generated models
+        run: |
+          sed -i 's#// UNCOMMENT AFTER MODEL GEN TO USE IN BUILD SCRIPTS //##' build.zig
+          tar -czf ${{ runner.temp }}/${{ github.sha }}-with-models.tar.gz \
+            --format ustar \
+            --exclude 'zig-*' \
+            *
+      # Something in this PR broke this transform. I don't mind removing it, but
+      # the PR attempts to handle situations with or without a prefix, but it
+      # doesn't. I have not yet determined what the problem is, though
+      # https://github.com/ziglang/zig/pull/19111/files
+      # --transform 's,^,${{ github.sha }}/,' *
+      # - name: Sign
+      #   id: sign
+      #   uses: https://git.lerch.org/lobo/action-hsm-sign@v1
+      #   with:
+      #     pin: ${{ secrets.HSM_USER_PIN }}
+      #     files: ???
+      #     public_key: 'https://emil.lerch.org/serverpublic.pem'
+      # - run: |
+      #     echo "Source 0 should be ./bar: ${{ steps.sign.outputs.SOURCE_0 }}"
+      # - run: |
+      #     echo "Signature 0 should be ./bar.sig: ${{ steps.sign.outputs.SIG_0 }}"
+      # - run: echo "URL of bar (0) is ${{ steps.sign.outputs.URL_0 }}"
+      # - run: |
+      #     echo "Source 1 should be ./foo: ${{ steps.sign.outputs.SOURCE_1 }}"
+      # - run: |
+      #     echo "Signature 1 should be ./foo.sig: ${{ steps.sign.outputs.SIG_1 }}"
+      # - run: echo "URL of foo (1) is ${{ steps.sign.outputs.URL_1 }}"
+      - name: Publish source code with generated models
+        run: |
+          curl --user ${{ github.actor }}:${{ secrets.PACKAGE_PUSH }} \
+            --upload-file ${{ runner.temp }}/${{ github.sha }}-with-models.tar.gz \
+            https://git.lerch.org/api/packages/lobo/generic/aws-sdk-with-models/${{ github.sha }}/${{ github.sha }}-with-models.tar.gz
+      - name: Build example
+        run: ( cd example && zig build ) # Make sure example builds
+      - name: Notify
+        uses: https://git.lerch.org/lobo/action-notify-ntfy@v2
+        if: always()
+        with:
+          host: ${{ secrets.NTFY_HOST }}
+          topic: ${{ secrets.NTFY_TOPIC }}
+          user: ${{ secrets.NTFY_USER }}
+          password: ${{ secrets.NTFY_PASSWORD }}

.gitea/workflows/zig-mach.yaml

@@ -0,0 +1,77 @@
+name: aws-zig mach nominated build
+on:
+  schedule:
+    - cron: '0 12 * * *' # noon UTC, 4AM Pacific
+  push:
+    branches:
+      - 'zig-develop*'
+env:
+  PKG_PREFIX: nominated-zig
+jobs:
+  build-zig-nominated-mach-latest:
+    container:
+      # We need CAP_SYS_PTRACE for stack traces due to a regression in 0.14.0
+      # TODO: Remove this after https://github.com/ziglang/zig/issues/21815 is
+      # addressed
+      options: --cap-add CAP_SYS_PTRACE
+    runs-on: ubuntu-latest
+    # Need to use the default container with node and all that, so we can
+    # use JS-based actions like actions/checkout@v3...
+    # container:
+    #   image: alpine:3.15.0
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v4
+        with:
+          ref: zig-develop
+      - name: Setup Zig
+        uses: mlugg/setup-zig@v1.2.1
+        with:
+          version: mach-latest
+      - name: Run tests
+        run: zig build test --verbose
+      # Zig package manager expects everything to be inside a directory in the archive,
+      # which it then strips out on download. So we need to shove everything inside a directory
+      # the way GitHub/Gitea does for repo archives
+      #
+      # Also, zig tar process doesn't handle gnu format for long names, nor does it seam to
+      # handle posix long name semantics cleanly either. ustar works. This
+      # should be using git archive, but we need our generated code to be part of it
+      - name: Package source code with generated models
+        run: |
+          tar -czf ${{ runner.temp }}/${{ github.sha }}${{ env.PKG_PREFIX }}-with-models.tar.gz \
+            --format ustar \
+            --exclude 'zig-*' \
+            --transform 's,^,${{ github.sha }}/,' *
+      # - name: Sign
+      #   id: sign
+      #   uses: https://git.lerch.org/lobo/action-hsm-sign@v1
+      #   with:
+      #     pin: ${{ secrets.HSM_USER_PIN }}
+      #     files: ???
+      #     public_key: 'https://emil.lerch.org/serverpublic.pem'
+      # - run: |
+      #     echo "Source 0 should be ./bar: ${{ steps.sign.outputs.SOURCE_0 }}"
+      # - run: |
+      #     echo "Signature 0 should be ./bar.sig: ${{ steps.sign.outputs.SIG_0 }}"
+      # - run: echo "URL of bar (0) is ${{ steps.sign.outputs.URL_0 }}"
+      # - run: |
+      #     echo "Source 1 should be ./foo: ${{ steps.sign.outputs.SOURCE_1 }}"
+      # - run: |
+      #     echo "Signature 1 should be ./foo.sig: ${{ steps.sign.outputs.SIG_1 }}"
+      # - run: echo "URL of foo (1) is ${{ steps.sign.outputs.URL_1 }}"
+      - name: Publish source code with generated models
+        run: |
+          curl --user ${{ github.actor }}:${{ secrets.PACKAGE_PUSH }} \
+            --upload-file ${{ runner.temp }}/${{ github.sha }}${{ env.PKG_PREFIX }}-with-models.tar.gz \
+            https://git.lerch.org/api/packages/lobo/generic/aws-sdk-with-models/${{ github.sha }}/${{ github.sha }}${{ env.PKG_PREFIX }}-with-models.tar.gz
+      - name: Build example
+        run: ( cd example && zig build ) # Make sure example builds
+      - name: Notify
+        uses: https://git.lerch.org/lobo/action-notify-ntfy@v2
+        if: always()
+        with:
+          host: ${{ secrets.NTFY_HOST }}
+          topic: ${{ secrets.NTFY_TOPIC }}
+          user: ${{ secrets.NTFY_USER }}
+          password: ${{ secrets.NTFY_PASSWORD }}

.gitea/workflows/zig-nightly.yaml

@@ -0,0 +1,77 @@
+name: aws-zig nightly build
+on:
+  schedule:
+    - cron: '30 12 * * *' # 12:30 UTC, 4:30AM Pacific
+  push:
+    branches:
+      - 'zig-develop*'
+env:
+  PKG_PREFIX: nightly-zig
+jobs:
+  build-zig-nightly:
+    container:
+      # We need CAP_SYS_PTRACE for stack traces due to a regression in 0.14.0
+      # TODO: Remove this after https://github.com/ziglang/zig/issues/21815 is
+      # addressed
+      options: --cap-add CAP_SYS_PTRACE
+    runs-on: ubuntu-latest
+    # Need to use the default container with node and all that, so we can
+    # use JS-based actions like actions/checkout@v3...
+    # container:
+    #   image: alpine:3.15.0
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v4
+        with:
+          ref: zig-develop
+      - name: Setup Zig
+        uses: mlugg/setup-zig@v1.2.1
+        with:
+          version: master
+      - name: Run tests
+        run: zig build test --verbose
+      # Zig package manager expects everything to be inside a directory in the archive,
+      # which it then strips out on download. So we need to shove everything inside a directory
+      # the way GitHub/Gitea does for repo archives
+      #
+      # Also, zig tar process doesn't handle gnu format for long names, nor does it seam to
+      # handle posix long name semantics cleanly either. ustar works. This
+      # should be using git archive, but we need our generated code to be part of it
+      - name: Package source code with generated models
+        run: |
+          tar -czf ${{ runner.temp }}/${{ github.sha }}${{ env.PKG_PREFIX }}-with-models.tar.gz \
+            --format ustar \
+            --exclude 'zig-*' \
+            --transform 's,^,${{ github.sha }}/,' *
+      # - name: Sign
+      #   id: sign
+      #   uses: https://git.lerch.org/lobo/action-hsm-sign@v1
+      #   with:
+      #     pin: ${{ secrets.HSM_USER_PIN }}
+      #     files: ???
+      #     public_key: 'https://emil.lerch.org/serverpublic.pem'
+      # - run: |
+      #     echo "Source 0 should be ./bar: ${{ steps.sign.outputs.SOURCE_0 }}"
+      # - run: |
+      #     echo "Signature 0 should be ./bar.sig: ${{ steps.sign.outputs.SIG_0 }}"
+      # - run: echo "URL of bar (0) is ${{ steps.sign.outputs.URL_0 }}"
+      # - run: |
+      #     echo "Source 1 should be ./foo: ${{ steps.sign.outputs.SOURCE_1 }}"
+      # - run: |
+      #     echo "Signature 1 should be ./foo.sig: ${{ steps.sign.outputs.SIG_1 }}"
+      # - run: echo "URL of foo (1) is ${{ steps.sign.outputs.URL_1 }}"
+      - name: Publish source code with generated models
+        run: |
+          curl --user ${{ github.actor }}:${{ secrets.PACKAGE_PUSH }} \
+            --upload-file ${{ runner.temp }}/${{ github.sha }}${{ env.PKG_PREFIX }}-with-models.tar.gz \
+            https://git.lerch.org/api/packages/lobo/generic/aws-sdk-with-models/${{ github.sha }}/${{ github.sha }}${{ env.PKG_PREFIX }}-with-models.tar.gz
+      - name: Build example
+        run: ( cd example && zig build ) # Make sure example builds
+      - name: Notify
+        uses: https://git.lerch.org/lobo/action-notify-ntfy@v2
+        if: always()
+        with:
+          host: ${{ secrets.NTFY_HOST }}
+          topic: ${{ secrets.NTFY_TOPIC }}
+          user: ${{ secrets.NTFY_USER }}
+          password: ${{ secrets.NTFY_PASSWORD }}

.github/workflows/build.yaml

@@ -0,0 +1,21 @@
+name: AWS-Zig Build
+on:
+  push:
+    branches:
+      - '*'
+      - '!zig-develop*'
+jobs:
+  build-zig-0-12-0-amd64:
+    runs-on: ubuntu-latest
+    if: ${{ github.env.GITEA_ACTIONS != 'true' }}
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v4
+      - name: Setup Zig
+        uses: mlugg/setup-zig@v1.2.1
+        with:
+          version: 0.13.0
+      - name: Run tests
+        run: zig build test -Dbroken-windows --verbose # Github runners try to run the windows tests despite disabling foreign checks
+      - name: Build example
+        run: ( cd example && zig build ) # Make sure example builds

.github/workflows/zig-mach.yaml

@@ -0,0 +1,20 @@
+name: aws-zig mach nominated build
+on:
+  push:
+    branches:
+      - 'zig-develop*'
+jobs:
+  build-zig-mach-latest:
+    runs-on: ubuntu-latest
+    if: ${{ github.env.GITEA_ACTIONS != 'true' }}
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v4
+      - name: Setup Zig
+        uses: mlugg/setup-zig@v1.2.1
+        with:
+          version: mach-latest
+      - name: Run tests
+        run: zig build test -Dbroken-windows --verbose
+      - name: Build example
+        run: ( cd example && zig build ) # Make sure example builds

.github/workflows/zig-nightly.yaml

@@ -0,0 +1,20 @@
+name: aws-zig nightly build
+on:
+  push:
+    branches:
+      - 'zig-develop*'
+jobs:
+  build-zig-nightly:
+    runs-on: ubuntu-latest
+    if: ${{ github.env.GITEA_ACTIONS != 'true' }}
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v4
+      - name: Setup Zig
+        uses: mlugg/setup-zig@v1.2.1
+        with:
+          version: master
+      - name: Run tests
+        run: zig build test -Dbroken-windows --verbose
+      - name: Build example
+        run: ( cd example && zig build ) # Make sure example builds

.gitignore

@@ -7,3 +7,8 @@ service_manifest.zig
 demo
 src/models/
 smithy/zig-out/
+libs/
+src/git_version.zig
+zig-out
+core
+.zig-cache

Dockerfile

@@ -1,110 +0,0 @@
-# We are looking for a static build, so we need to be on a musl system
-# Zig uses clang, so for best compatibility, everything should be built
-# using that compiler
-
-
-# Establish a base container with build tools common to most projects
-FROM alpine:3.13 AS base
-# gcc gets us libgcc.a, even though the build should be using clang
-RUN apk add --no-cache clang git cmake make lld musl-dev gcc && \
-    rm /usr/bin/ld && \
-    ln -s /usr/bin/ld.lld /usr/bin/ld && rm /usr/bin/gcc # just to be sure
-
-FROM base AS common
-RUN git clone --depth 1 -b v0.5.2 https://github.com/awslabs/aws-c-common && \
-    mkdir aws-c-common-build && cd aws-c-common-build && \
-    cmake ../aws-c-common && \
-    make -j12 && make test && make install
-
-RUN tar -czf aws-c-common-clang.tgz /usr/local/*
-
-# The only tags currently on the repo are from 9/2020 and don't install
-# anything, so we'll use current head of main branch (d60b60e)
-FROM base AS awslc
-RUN apk add --no-cache perl go g++ linux-headers && rm /usr/bin/g++ && rm /usr/bin/c++ && \
-    git clone --depth 1000 https://github.com/awslabs/aws-lc && cd aws-lc && \
-    git reset d60b60e --hard && cd .. && \
-    cmake -S aws-lc -B aws-lc/build -DCMAKE_BUILD_TYPE=RelWithDebInfo -DCMAKE_PREFIX_PATH=/usr/local -DCMAKE_INSTALL_PREFIX=/usr/local && \
-    cmake --build aws-lc/build --config RelWithDebInfo --target install
-
-RUN tar -czf aws-lc-clang.tgz /usr/local/*
-
-FROM base AS s2n
-ENV S2N_LIBCRYPTO=awslc
-COPY --from=awslc /aws-lc-clang.tgz /
-RUN git clone --depth 1 -b v1.0.5 https://github.com/aws/s2n-tls && \
-    tar -xzf aws-lc-clang.tgz && \
-    mkdir s2n-build && cd s2n-build && \
-    cmake ../s2n-tls && \
-    make -j12 && make install
-
-RUN tar -czf s2n-clang.tgz /usr/local/*
-
-FROM base AS cal
-COPY --from=awslc /aws-lc-clang.tgz /
-COPY --from=common /aws-c-common-clang.tgz /
-# RUN git clone --depth 1 -b v0.5.5 https://github.com/awslabs/aws-c-cal && \
-RUN git clone --depth 1 -b static-musl-builds https://github.com/elerch/aws-c-cal && \
-    tar -xzf aws-c-common-clang.tgz && \
-    tar -xzf aws-lc-clang.tgz && \
-    mkdir cal-build && cd cal-build && \
-    cmake -DCMAKE_MODULE_PATH=/usr/local/lib64/cmake ../aws-c-cal && \
-    make -j12 && make install
-# No make test:
-#  40 - ecdsa_p384_test_key_gen_export (Failed)
-RUN tar -czf aws-c-cal-clang.tgz /usr/local/*
-
-FROM base AS compression
-COPY --from=common /aws-c-common-clang.tgz /
-RUN git clone --depth 1 -b v0.2.10 https://github.com/awslabs/aws-c-compression && \
-    tar -xzf aws-c-common-clang.tgz && \
-    mkdir compression-build && cd compression-build && \
-    cmake -DCMAKE_MODULE_PATH=/usr/local/lib64/cmake ../aws-c-compression && \
-    make -j12 && make test && make install
-
-RUN tar -czf aws-c-compression-clang.tgz /usr/local/*
-
-FROM base AS io
-# Cal includes common and openssl
-COPY --from=cal /aws-c-cal-clang.tgz /
-COPY --from=s2n /s2n-clang.tgz /
-RUN git clone --depth 1 -b v0.9.1 https://github.com/awslabs/aws-c-io && \
-    tar -xzf s2n-clang.tgz && \
-    tar -xzf aws-c-cal-clang.tgz && \
-    mkdir io-build && cd io-build && \
-    cmake -DCMAKE_MODULE_PATH=/usr/local/lib64/cmake ../aws-c-io && \
-    make -j12 && make install
-
-RUN tar -czf aws-c-io-clang.tgz /usr/local/*
-
-FROM base AS http
-# Cal includes common and openssl
-# 2 test failures on musl - both "download medium file"
-COPY --from=io /aws-c-io-clang.tgz /
-COPY --from=compression /aws-c-compression-clang.tgz /
-# RUN git clone --depth 1 -b v0.5.19 https://github.com/awslabs/aws-c-http && \
-RUN git clone --depth 1 -b v0.6.1 https://github.com/awslabs/aws-c-http && \
-    tar -xzf aws-c-io-clang.tgz && \
-    tar -xzf aws-c-compression-clang.tgz && \
-    mkdir http-build && cd http-build && \
-    cmake -DCMAKE_MODULE_PATH=/usr/local/lib64/cmake ../aws-c-http && \
-    make -j12 && make install
-
-RUN tar -czf aws-c-http-clang.tgz /usr/local/*
-
-FROM base AS auth
-# http should have all other dependencies
-COPY --from=http /aws-c-http-clang.tgz /
-RUN git clone --depth 1 -b v0.5.0 https://github.com/awslabs/aws-c-auth && \
-    tar -xzf aws-c-http-clang.tgz && \
-    mkdir auth-build && cd auth-build && \
-    cmake -DCMAKE_MODULE_PATH=/usr/local/lib64/cmake ../aws-c-auth && \
-    make -j12 && make install # chunked_signing_test fails
-
-RUN tar -czf aws-c-auth-clang.tgz /usr/local/*
-
-FROM alpine:3.13 as final
-COPY --from=auth /aws-c-auth-clang.tgz /
-ADD https://ziglang.org/download/0.9.0/zig-linux-x86_64-0.9.0.tar.xz /
-RUN tar -xzf /aws-c-auth-clang.tgz && mkdir /src && tar -C /usr/local -xf zig-linux* && \
-    ln -s /usr/local/zig-linux*/zig /usr/local/bin/zig

README.md

@@ -1,124 +1,135 @@
-# AWS SDK for Zig
+AWS SDK for Zig
+===============
 
-[![Build Status](https://drone.lerch.org/api/badges/lobo/aws-sdk-for-zig/status.svg?ref=refs/heads/aws-crt)](https://drone.lerch.org/lobo/aws-sdk-for-zig)
+[Zig 0.13](https://ziglang.org/download/#release-0.13.0):
 
-This SDK currently supports all AWS services except EC2 and S3. These two
-services only support XML, and zig 0.8.0 and master both trigger compile
-errors while incorporating the XML parser. S3 also requires some plumbing
-tweaks in the signature calculation, which is planned for a zig version
-(probably self-hosted 0.9.0) that no longer has an error triggered. Examples
-of usage are in src/main.zig.
+[![Build Status: Zig 0.13.0](https://git.lerch.org/lobo/aws-sdk-for-zig/actions/workflows/build.yaml/badge.svg)](https://git.lerch.org/lobo/aws-sdk-for-zig/actions?workflow=build.yaml&state=closed)
 
-This is designed to be built statically using the `aws_c_*` libraries, so
-we inherit a lot of the goodness of the work going on there. Current
-executable size is 9.7M, about half of which is due to the SSL library.
-Running strip on the executable after compilation (it seems zig strip
-only goes so far), reduces this to 4.3M. This is for x86_linux,
-(which is all that's tested at the moment).
+[Last Mach Nominated Zig Version](https://machengine.org/about/nominated-zig/):
 
-# 2022-01-10 SDK Update
+[![Build Status: Mach nominated](https://git.lerch.org/lobo/aws-sdk-for-zig/actions/workflows/zig-mach.yaml/badge.svg)](https://git.lerch.org/lobo/aws-sdk-for-zig/actions?workflow=zig-mach.yaml&state=closed)
 
-To get smaller executable size and better portability with faster compilation,
-my intent is to rework the http communications using
-[requestz](https://github.com/ducdetronquito/requestz).  This relies on a
-couple other projects, and will require the creation of a zig implementation
-for [Signature Version 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html),
-along with support for some S3 quirks, etc. It will also reduce compatibility
-with some edge cases. Long term I think this is a better approach, however and
-will remove (or replace) a ton of the C dependencies as well as avoid a bunch
-of complexity such as the event loop C implementation found in the AWS
-libraries, which eventually could be replaced by zig async. I have created a
-[new branch](https://github.com/elerch/aws-sdk-for-zig/tree/zig-native)
-for this work as master is currently working fairly well. I'd also love to have
-an official package manager in zig, but I know this is high on the priority
-list for the foundation. In the meantime I will depend on git commands executed
-by build.zig to handle packages.
+[Nightly Zig](https://ziglang.org/download/):
 
-## Building
+[![Build Status: Zig Nightly](https://git.lerch.org/lobo/aws-sdk-for-zig/actions/workflows/zig-nightly.yaml/badge.svg)](https://git.lerch.org/lobo/aws-sdk-for-zig/actions?workflow=zig-nightly.yaml&state=closed)
 
-I am assuming here that if you're playing with zig, you pretty much know
-what you're doing, so I will stay brief.
+Current executable size for the demo is 980k after compiling with -Doptimize=ReleaseSmall
+in x86_linux, and will vary based on services used. Tested targets:
 
-First, the dependencies are required. Use the Dockerfile to build these.
-a `docker build` will do, but be prepared for it to run a while. The
-Dockerfile has been tested on x86_64 linux, but I do hope to get arm64
-supported as well.
+* x86_64-linux
+* riscv64-linux\*
+* aarch64-linux
+* x86_64-windows
+* arm-linux
+* aarch64-macos
+* x86_64-macos
 
-Once that's done, you'll have an alpine image with all dependencies ready
-to go and zig master installed. There are some build-related things still
-broken in 0.8.0 and hopefully 0.8.1 will address those and we can be on
-a standard release.
+Tested targets are built, but not continuously tested, by CI.
 
-* `zig build` should work. It will build the code generation project, run
-  the code generation, then build the main project with the generated code.
-  There is also a Makefile included, but this hasn't been used in a while
-  and I'm not sure that works at the moment.
-
-## Running
-
-This library uses the aws c libraries for it's work, so it operates like most
-other 'AWS things'. Note that I tested by setting the appropriate environment
-variables, so config files haven't gotten a run through.
-main.zig gives you a handful of examples for working with services.
-For local testing or alternative endpoints, there's no real standard, so
-there is code to look for `AWS_ENDPOINT_URL` environment variable that will
-supercede all other configuration.
-
-## Dependencies
+\* On Zig 0.12/0.13, riscv64-linux disabled due to [LLLM's O(N^2) codegen](https://github.com/ziglang/zig/issues/18872)
 
 
-Full dependency tree:
-aws-c-auth
-   * s2n
-      * aws-lc
-   * aws-c-common
-   * aws-c-compression
-     * aws-c-common
-   * aws-c-http
-     * s2n
-     * aws-c-common
-     * aws-c-io
-       * aws-c-common
-       * s2n
-         * aws-lc
-       * aws-c-cal
-         * aws-c-common
-         * aws-lc
-     * aws-c-compression
-       * aws-c-common
-   * aws-c-cal
-     * aws-c-common
-     * aws-lc
+Zig-Develop Branch
+------------------
 
-Build order based on above:
+This branch is intended for use with the in-development version of Zig. This
+starts with 0.12.0-dev.3180+83e578a18. This is aligned with [Mach Engine's Nominated
+Zig Versions](https://machengine.org/about/nominated-zig/). Nightly zig versions
+are difficult to keep up with and there is no special effort made there, build
+status is FYI (and used as a canary for nominated zig versions).
 
-1. aws-c-common
-1. aws-lc
-2. s2n
-2. aws-c-cal
-2. aws-c-compression
-3. aws-c-io
-4. aws-c-http
-5. aws-c-auth
+Building
+--------
 
-Dockerfile in this repo will manage this
+`zig build` should work. It will build the code generation project, fetch model
+files from upstream AWS Go SDK v2, run the code generation, then build the main
+project with the generated code. Testing can be done with `zig test`.
+
+
+Using
+-----
+
+This is designed for use with the Zig package manager, and exposes a module
+called "aws". Set up `build.zig.zon` and add the dependency/module to your project
+as normal and the package manager should do its thing. A full example can be found
+in [/example](example/README.md).
+
+Configuring the module and/or Running the demo
+----------------------------------------------
+
+This library mimics the aws c libraries for it's work, so it operates like most
+other 'AWS things'. [/src/main.zig](src/main.zig) gives you a handful of examples
+for working with services. For local testing or alternative endpoints, there's
+no real standard, so there is code to look for `AWS_ENDPOINT_URL` environment
+variable that will supersede all other configuration.
+
+Limitations
+-----------
+
+WebIdentityToken is not yet implemented.
 
 TODO List:
 
-* Implement jitter/exponential backoff. This appears to be configuration of
-  `aws_c_io` and should therefore be trivial
+* Json parsing is based on a fork of the 0.9.0 (maybe earlier?) json parser.
+  This needs a re-visit. Note also that a json.zig file is embedded/copied
+  from the codegen project, so that also needs a second look.
+* Take a look to see about compilation speed. With codegen caching this is
+  reasonable, but still takes longer than needed.
+* Upgrade the model files. This is a simple tasks, but I'd like the first
+  item on this list to be completed first.
+* Implement sigv4a signing
+* Implement jitter/exponential backoff
 * Implement timeouts and other TODO's in the code
-* Switch to aws-c-cal upstream once [PR for full static musl build support is merged](https://github.com/awslabs/aws-c-cal/pull/89)
-  (see Dockerfile)
-* Implement [AWS restXml protocol](https://awslabs.github.io/smithy/1.0/spec/aws/aws-restxml-protocol.html).
-  Includes S3. Total service count 4. This may be blocked due to the same issue as EC2.
-* Implement [AWS EC2 query protocol](https://awslabs.github.io/smithy/1.0/spec/aws/aws-ec2-query-protocol.html).
-  Includes EC2. Total service count 1. This is currently blocked, probably on
-  self-hosted compiler coming in zig 0.9.0 (January 2022) due to compiler bug
-  discovered. More details and llvm ir log can be found in the
-  [XML branch](https://git.lerch.org/lobo/aws-sdk-for-zig/src/branch/xml).
+* Add option to cache signature keys
 
-Compiler wishlist/watchlist:
+Services without TLS 1.3 support
+--------------------------------
 
-* [Merge PR to allow stripping -static](https://github.com/ziglang/zig/pull/8248)
-* [comptime allocations](https://github.com/ziglang/zig/issues/1291) so we can read files, etc (or is there another way)
+All AWS services should support TLS 1.3 at this point, but there are many regions
+and several partitions, and not all of them have been tested, so your mileage
+may vary. If something doesn't work, please submit an issue to let others know.
+
+Dependency tree
+---------------
+
+No dependencies:
+  * aws_authentication: base structure for credentials (only one type)
+  * aws_http_base: contains basic structures for http requests/results
+  * case: provides functions to change casing
+  * date: provides limited date manipulation functions
+  * json: custom version of earlier stdlib json parser
+  * xml: custom xml parser library
+  * url: custom url encoding
+
+aws_credentials: Allows credential handling
+  aws_authentication
+
+aws_http:
+  aws_http_base
+  aws_signing
+
+aws_signing: handles signing of http requests
+  aws_http_base
+  aws_authentication
+  date
+
+aws: main usage point for libraries
+  aws_http
+  json
+  url
+  case
+  date
+  servicemodel
+  xml_shaper
+  aws_credentials
+  aws_authentication
+
+main: main entrypoint for demo executable
+  aws
+
+servicemodel: Provides access to all aws service generated models
+  all generated model files
+
+xml_shaper: Manages interface from xml to in memory structures
+  xml
+  date

build.zig

@@ -1,6 +1,26 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const Builder = @import("std").build.Builder;
+const Builder = @import("std").Build;
+
+const models_subdir = "codegen/sdk-codegen/aws-models/"; // note will probably not work on windows
+
+// UNCOMMENT AFTER MODEL GEN TO USE IN BUILD SCRIPTS //pub const aws = @import("src/aws.zig");
+
+const test_targets = [_]std.Target.Query{
+    .{}, // native
+    .{ .cpu_arch = .x86_64, .os_tag = .linux },
+    .{ .cpu_arch = .aarch64, .os_tag = .linux },
+    // The test executable linking process just spins forever in LLVM using nominated zig 0.13 May 2024
+    // This is likely a LLVM problem unlikely to be fixed in zig 0.13
+    // Potentially this issue: https://github.com/llvm/llvm-project/issues/81440
+    // Zig tracker: https://github.com/ziglang/zig/issues/18872
+    // .{ .cpu_arch = .riscv64, .os_tag = .linux },
+    .{ .cpu_arch = .arm, .os_tag = .linux },
+    .{ .cpu_arch = .x86_64, .os_tag = .windows },
+    .{ .cpu_arch = .aarch64, .os_tag = .macos },
+    .{ .cpu_arch = .x86_64, .os_tag = .macos },
+    // .{ .cpu_arch = .wasm32, .os_tag = .wasi },
+};
 
 pub fn build(b: *Builder) !void {
     // Standard target options allows the person running `zig build` to choose
@@ -11,54 +31,64 @@ pub fn build(b: *Builder) !void {
 
     // Standard release options allow the person running `zig build` to select
     // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
-    const mode = b.standardReleaseOptions();
-    const exe = b.addExecutable("demo", "src/main.zig");
+    const optimize = b.standardOptimizeOption(.{});
 
-    // https://github.com/ziglang/zig/issues/855
-    exe.addPackagePath("smithy", "smithy/src/smithy.zig");
+    const broken_windows = b.option(
+        bool,
+        "broken-windows",
+        "Windows is broken in this environment (do not run Windows tests)",
+    ) orelse false;
+    // TODO: Embed the current git version in the code. We can do this
+    // by looking for .git/HEAD (if it exists, follow the ref to /ref/heads/whatevs,
+    // grab that commit, and use b.addOptions/exe.addOptions to generate the
+    // Options file. See https://github.com/ziglang/zig/issues/14979 for usage
+    // example.
+    //
+    // From there, I'm not sure what the generated file looks like or quite how
+    // to use, but that should be easy. It may also give some ideas on the
+    // code gen piece itself, though it might be nice to leave as a seperate
+    // executable
+    // TODO: This executable should not be built when importing as a package.
+    // It relies on code gen and is all fouled up when getting imported
+    const exe = b.addExecutable(.{
+        .name = "demo",
+        .root_source_file = b.path("src/main.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+    const smithy_dep = b.dependency("smithy", .{
+        // These are the arguments to the dependency. It expects a target and optimization level.
+        .target = target,
+        .optimize = optimize,
+    });
+    const smithy_module = smithy_dep.module("smithy");
+    exe.root_module.addImport("smithy", smithy_module); // not sure this should be here...
 
-    // This bitfield workaround will end up requiring a bunch of headers that
-    // currently mean building in the docker container is the best way to build
-    // TODO: Determine if it's a good idea to copy these files out of our
-    // docker container to the local fs so we can just build even outside
-    // the container. And maybe, just maybe these even get committed to
-    // source control?
-    exe.addCSourceFile("src/bitfield-workaround.c", &[_][]const u8{"-std=c99"});
-    const c_include_dirs = .{
-        "./src/",
-        "/usr/local/include",
-    };
-    inline for (c_include_dirs) |dir|
-        exe.addIncludeDir(dir);
+    // Expose module to others
+    _ = b.addModule("aws", .{
+        .root_source_file = b.path("src/aws.zig"),
+        .imports = &.{.{ .name = "smithy", .module = smithy_module }},
+    });
 
-    const dependent_objects = .{
-        "/usr/local/lib64/libs2n.a",
-        "/usr/local/lib64/libcrypto.a",
-        "/usr/local/lib64/libssl.a",
-        "/usr/local/lib64/libaws-c-auth.a",
-        "/usr/local/lib64/libaws-c-cal.a",
-        "/usr/local/lib64/libaws-c-common.a",
-        "/usr/local/lib64/libaws-c-compression.a",
-        "/usr/local/lib64/libaws-c-http.a",
-        "/usr/local/lib64/libaws-c-io.a",
-    };
-    inline for (dependent_objects) |obj|
-        exe.addObjectFile(obj);
+    // Expose module to others
+    _ = b.addModule("aws-signing", .{
+        .root_source_file = b.path("src/aws_signing.zig"),
+        .imports = &.{.{ .name = "smithy", .module = smithy_module }},
+    });
+    // TODO: This does not work correctly due to https://github.com/ziglang/zig/issues/16354
+    //
+    // We are working here with kind of a weird dependency though. So we can do this
+    // another way
+    //
+    // TODO: These target/optimize are not correct, as we need to run the thing
+    // const codegen = b.anonymousDependency("codegen/", @import("codegen/build.zig"), .{
+    //     .target = target,
+    //     .optimize = optimize,
+    // });
+    // const codegen_cmd = b.addRunArtifact(codegen.artifact("codegen"));
+    // exe.step.dependOn(&codegen_cmd.step);
 
-    exe.linkSystemLibrary("c");
-    exe.setTarget(target);
-    exe.setBuildMode(mode);
-
-    exe.override_dest_dir = .{ .custom = ".." };
-    exe.linkage = .static;
-
-    // TODO: Strip doesn't actually fully strip the executable. If we're on
-    //       linux we can run strip on the result, probably at the expense
-    //       of busting cache logic
-    const is_strip = b.option(bool, "strip", "strip exe [true]") orelse true;
-    exe.strip = is_strip;
-
-    const run_cmd = exe.run();
+    const run_cmd = b.addRunArtifact(exe);
     run_cmd.step.dependOn(b.getInstallStep());
     if (b.args) |args| {
         run_cmd.addArgs(args);
@@ -67,46 +97,118 @@ pub fn build(b: *Builder) !void {
     const run_step = b.step("run", "Run the app");
     run_step.dependOn(&run_cmd.step);
 
-    const test_step = b.step("test", "Run library tests");
-    var build_dir = try std.fs.openDirAbsolute(b.build_root, .{});
-    defer build_dir.close();
-    var src_dir = try build_dir.openDir("src", .{ .iterate = true });
-    defer src_dir.close();
-    var iterator = src_dir.iterate();
-    while (try iterator.next()) |entry| {
-        if (std.mem.endsWith(u8, entry.name, ".zig")) {
-            const name = try std.fmt.allocPrint(b.allocator, "src/{s}", .{entry.name});
-            defer b.allocator.free(name);
-            const t = b.addTest(name);
-            t.addPackagePath("smithy", "smithy/src/smithy.zig");
-            t.setBuildMode(mode);
-            test_step.dependOn(&t.step);
-        }
-    }
+    const gen_step = blk: {
+        const cg = b.step("gen", "Generate zig service code from smithy models");
 
-    // TODO: Support > linux
-    if (builtin.os.tag == .linux) {
-        const codegen = b.step("gen", "Generate zig service code from smithy models");
-        codegen.dependOn(&b.addSystemCommand(&.{ "/bin/sh", "-c", "cd codegen && zig build" }).step);
-        // Since codegen binary is built every time, if it's newer than our
-        // service manifest we know it needs to be regenerated. So this step
-        // will remove the service manifest if codegen has been touched, thereby
-        // triggering the re-gen
-        codegen.dependOn(&b.addSystemCommand(&.{
-            "/bin/sh", "-c",
-            \\ [ ! -f src/models/service_manifest.zig ] || \
-            \\ [ src/models/service_manifest.zig -nt codegen/codegen ] || \
-            \\ rm src/models/service_manifest.zig
-        }).step);
-        codegen.dependOn(&b.addSystemCommand(&.{
-            "/bin/sh", "-c",
-            \\ mkdir -p src/models/ && \
-            \\ [ -f src/models/service_manifest.zig ] || \
-            \\ ( cd codegen/models && ../codegen *.json && mv *.zig ../../src/models )
-        }).step);
-        b.getInstallStep().dependOn(codegen);
-        test_step.dependOn(codegen);
-    }
+        const cg_exe = b.addExecutable(.{
+            .name = "codegen",
+            .root_source_file = b.path("codegen/src/main.zig"),
+            // We need this generated for the host, not the real target
+            .target = b.host,
+            .optimize = if (b.verbose) .Debug else .ReleaseSafe,
+        });
+        cg_exe.root_module.addImport("smithy", smithy_dep.module("smithy"));
+        var cg_cmd = b.addRunArtifact(cg_exe);
+        cg_cmd.addArg("--models");
+        const hash = hash_blk: {
+            for (b.available_deps) |dep| {
+                const dep_name = dep.@"0";
+                const dep_hash = dep.@"1";
+                if (std.mem.eql(u8, dep_name, "models"))
+                    break :hash_blk dep_hash;
+            }
+            return error.DependencyNamedModelsNotFoundInBuildZigZon;
+        };
+        cg_cmd.addArg(try std.fs.path.join(
+            b.allocator,
+            &[_][]const u8{
+                b.graph.global_cache_root.path.?,
+                "p",
+                hash,
+                models_subdir,
+            },
+        ));
+        cg_cmd.addArg("--output");
+        cg_cmd.addDirectoryArg(b.path("src/models"));
+        if (b.verbose)
+            cg_cmd.addArg("--verbose");
+        // cg_cmd.step.dependOn(&fetch_step.step);
+        // TODO: this should use zig_exe from std.Build
+        // codegen should store a hash in a comment
+        // this would be hash of the exe that created the file
+        // concatenated with hash of input json. this would
+        // allow skipping generated files. May not include hash
+        // of contents of output file as maybe we want to tweak
+        // manually??
+        //
+        // All the hashes can be in service_manifest.zig, which
+        // could be fun to just parse and go nuts. Top of
+        // file, generator exe hash. Each import has comment
+        // with both input and output hash and we can decide
+        // later about warning on manual changes...
 
-    exe.install();
+        cg.dependOn(&cg_cmd.step);
+        break :blk cg;
+    };
+
+    exe.step.dependOn(gen_step);
+
+    // Similar to creating the run step earlier, this exposes a `test` step to
+    // the `zig build --help` menu, providing a way for the user to request
+    // running the unit tests.
+    const test_step = b.step("test", "Run unit tests");
+
+    // // Creates a step for unit testing. This only builds the test executable
+    // // but does not run it.
+    // const unit_tests = b.addTest(.{
+    //     .root_source_file = .{ .path = "src/aws.zig" },
+    //     .target = target,
+    //     .optimize = optimize,
+    // });
+    // unit_tests.root_module.addImport("smithy", smithy_dep.module("smithy"));
+    // unit_tests.step.dependOn(gen_step);
+    //
+    // const run_unit_tests = b.addRunArtifact(unit_tests);
+    // run_unit_tests.skip_foreign_checks = true;
+
+    // test_step.dependOn(&run_unit_tests.step);
+    for (test_targets) |t| {
+        if (broken_windows and t.os_tag == .windows) continue;
+        // Creates a step for unit testing. This only builds the test executable
+        // but does not run it.
+        const unit_tests = b.addTest(.{
+            .root_source_file = b.path("src/aws.zig"),
+            .target = b.resolveTargetQuery(t),
+            .optimize = optimize,
+        });
+        unit_tests.root_module.addImport("smithy", smithy_dep.module("smithy"));
+        unit_tests.step.dependOn(gen_step);
+
+        const run_unit_tests = b.addRunArtifact(unit_tests);
+        run_unit_tests.skip_foreign_checks = true;
+
+        test_step.dependOn(&run_unit_tests.step);
+    }
+    const check = b.step("check", "Check compilation errors");
+    check.dependOn(&exe.step);
+
+    // Similar to creating the run step earlier, this exposes a `test` step to
+    // the `zig build --help` menu, providing a way for the user to request
+    // running the unit tests.
+    const smoke_test_step = b.step("smoke-test", "Run unit tests");
+
+    // Creates a step for unit testing. This only builds the test executable
+    // but does not run it.
+    const smoke_test = b.addTest(.{
+        .root_source_file = b.path("src/aws.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+    smoke_test.root_module.addImport("smithy", smithy_dep.module("smithy"));
+    smoke_test.step.dependOn(gen_step);
+
+    const run_smoke_test = b.addRunArtifact(smoke_test);
+
+    smoke_test_step.dependOn(&run_smoke_test.step);
+    b.installArtifact(exe);
 }

build.zig.zon

@@ -0,0 +1,22 @@
+.{
+    .name = "aws",
+    .version = "0.0.1",
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+        "src",
+        "README.md",
+        "LICENSE",
+    },
+
+    .dependencies = .{
+        .smithy = .{
+            .url = "https://git.lerch.org/lobo/smithy/archive/3ed98751bc414e005af6ad185feb213d4366c0db.tar.gz",
+            .hash = "12204a784751a4ad5ed6c8955ba91fcbc4a3cad6c5a7da38f39abf074ef801d13172",
+        },
+        .models = .{
+            .url = "https://github.com/aws/aws-sdk-go-v2/archive/58cf6509525a12d64fd826da883bfdbacbd2f00e.tar.gz",
+            .hash = "122017a2f3081ce83c23e0c832feb1b8b4176d507b6077f522855dc774bcf83ee315",
+        },
+    },
+}

codegen/README.md

@@ -7,19 +7,18 @@ as they do in other languages. We can combine all models from AWS into a single
 comptime constant even, however, we're keeping zig files 1:1 with json files
 for now.
 
-The main executable, run with a "-s" first argument, will simply parse the
-Smithy json files passed by the rest of the arguments and save each one as
-its own file.json.zig. We will rely on shell commands to do the rest of the
-renaming (and moving if necessary).
+Optimization plan will be done by the placing of a json file in the output
+directory. The json file will contain a mapping between input files and generated
+outputs, as well as a top level directory hash. We can skip the output generation
+entirely if the top level hash matches, otherwise, individual hashes will be
+compared and output files will only regenerate if the input or output has changed.
 
-To run this, we can use `codegen -s models/*.json`, which takes 20 seconds
-or so on my i5 chromebook and probably significantly faster on a real machine.
-No attempt has been made to optimize. Also, there are several bugs:
+
+Todo
+----
 
 * I do not think all the optional types have been sorted.
 * I think there is necessary metadata missing from EC2Query style services
-* The output will compile and is close to what `zig fmt` likes to see, but it
-  has not yet been functionally tested
 * It handles all the types in existing AWS services, but it does not handle
   all known Smithy types (e.g. blob and document are missing)
 * It would be awesome to bring over the documentation from the model into
@@ -29,13 +28,7 @@ No attempt has been made to optimize. Also, there are several bugs:
   realistically I'm not sure if that will matter long term, and it's a fair
   amount of work as everything now can be done in a single pass without post
   processing.
-* This doesn't seem to build on 0.7.1 - you need master branch. I hope that
-  0.8.0 will be out soon. If not, a few syntax changes need to be accommodated.
-
-Some of these will likely be addressed as I integrate the code generated files into
-the SDK engine.
 
 The models are Smithy json files, sourced from the AWS v2 go sdk
-for lack of a better place. I've just downloaded the main branch and copied
-the files from the tree in place.
-
+for lack of a better place. Details are in build.zig of the parent project
+that is now responsible for downloading/caching the project.

codegen/build.zig

@@ -1,5 +1,8 @@
 const std = @import("std");
 
+// Although this function looks imperative, note that its job is to
+// declaratively construct a build graph that will be executed by an external
+// runner.
 pub fn build(b: *std.build.Builder) !void {
     // Standard target options allows the person running `zig build` to choose
     // what target to build for. Here we do not override the defaults, which
@@ -7,53 +10,65 @@ pub fn build(b: *std.build.Builder) !void {
     // for restricting supported target set are available.
     const target = b.standardTargetOptions(.{});
 
-    // Standard release options allow the person running `zig build` to select
-    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
-    const mode = b.standardReleaseOptions();
+    // Standard optimization options allow the person running `zig build` to select
+    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall. Here we do not
+    // set a preferred release mode, allowing the user to decide how to optimize.
+    const optimize = b.standardOptimizeOption(.{});
 
-    const exe = b.addExecutable("codegen", "src/main.zig");
-    exe.addPackagePath("smithy", "../smithy/src/smithy.zig");
-    exe.setTarget(target);
-    exe.setBuildMode(mode);
-    // This line works as of c5d412268
-    // Earliest nightly is 05b5e49bc on 2021-06-12
-    // https://ziglang.org/builds/zig-linux-x86_64-0.9.0-dev.113+05b5e49bc.tar.xz
-    // exe.override_dest_dir = .{ .Custom = ".." };
-    exe.override_dest_dir = .{ .custom = ".." };
+    const exe = b.addExecutable(.{
+        .name = "codegen",
+        .root_source_file = .{ .path = "src/main.zig" },
+        .target = target,
+        .optimize = optimize,
+    });
 
-    // Static linkage flag was nonfunctional until 2b2efa24d0855
-    // Did not notice this until 2021-06-28, and that nightly is:
-    // https://ziglang.org/builds/zig-linux-x86_64-0.9.0-dev.321+15a030ef3.tar.xz
-    exe.linkage = .static;
+    const smithy_dep = b.dependency("smithy", .{
+        .target = target,
+        .optimize = optimize,
+    });
+    exe.addModule("smithy", smithy_dep.module("smithy"));
 
-    const is_strip = b.option(bool, "strip", "strip exe") orelse true;
-    exe.strip = !is_strip;
-    exe.install();
+    // This declares intent for the executable to be installed into the
+    // standard location when the user invokes the "install" step (the default
+    // step when running `zig build`).
+    b.installArtifact(exe);
 
-    const run_cmd = exe.run();
+    // This *creates* a Run step in the build graph, to be executed when another
+    // step is evaluated that depends on it. The next line below will establish
+    // such a dependency.
+    const run_cmd = b.addRunArtifact(exe);
+
+    // By making the run step depend on the install step, it will be run from the
+    // installation directory rather than directly from within the cache directory.
+    // This is not necessary, however, if the application depends on other installed
+    // files, this ensures they will be present and in the expected location.
     run_cmd.step.dependOn(b.getInstallStep());
+
+    // This allows the user to pass arguments to the application in the build
+    // command itself, like this: `zig build run -- arg1 arg2 etc`
     if (b.args) |args| {
         run_cmd.addArgs(args);
     }
 
+    // This creates a build step. It will be visible in the `zig build --help` menu,
+    // and can be selected like this: `zig build run`
+    // This will evaluate the `run` step rather than the default, which is "install".
     const run_step = b.step("run", "Run the app");
     run_step.dependOn(&run_cmd.step);
 
-    const test_step = b.step("test", "Run library tests");
-    var build_dir = try std.fs.openDirAbsolute(b.build_root, .{});
-    defer build_dir.close();
-    var src_dir = try build_dir.openDir("src", .{ .iterate = true });
-    defer src_dir.close();
-    var iterator = src_dir.iterate();
-    while (try iterator.next()) |entry| {
-        if (std.mem.endsWith(u8, entry.name, ".zig") and
-            !std.mem.eql(u8, entry.name, "main.zig"))
-        {
-            const name = try std.fmt.allocPrint(b.allocator, "src/{s}", .{entry.name});
-            defer b.allocator.free(name);
-            const t = b.addTest(name);
-            t.setBuildMode(mode);
-            test_step.dependOn(&t.step);
-        }
-    }
+    // Creates a step for unit testing. This only builds the test executable
+    // but does not run it.
+    const unit_tests = b.addTest(.{
+        .root_source_file = .{ .path = "src/main.zig" },
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const run_unit_tests = b.addRunArtifact(unit_tests);
+
+    // Similar to creating the run step earlier, this exposes a `test` step to
+    // the `zig build --help` menu, providing a way for the user to request
+    // running the unit tests.
+    const test_step = b.step("test", "Run unit tests");
+    test_step.dependOn(&run_unit_tests.step);
 }

codegen/build.zig.zon

@@ -0,0 +1,11 @@
+.{
+    .name = "aws-zig-codegen",
+    .version = "0.0.1",
+
+    .dependencies = .{
+        .smithy = .{
+            .url = "https://git.lerch.org/lobo/smithy/archive/41b61745d25a65817209dd5dddbb5f9b66896a99.tar.gz",
+            .hash = "122087deb0ae309b2258d59b40d82fe5921fdfc35b420bb59033244851f7f276fa34",
+        },
+    },
+}

codegen/models/amp.2020-08-01.json

@@ -1,938 +0,0 @@
-{
-    "smithy": "1.0",
-    "shapes": {
-        "com.amazonaws.amp#AccessDeniedException": {
-            "type": "structure",
-            "members": {
-                "message": {
-                    "target": "smithy.api#String",
-                    "traits": {
-                        "smithy.api#documentation": "Description of the error.",
-                        "smithy.api#required": {}
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "User does not have sufficient access to perform this action.",
-                "smithy.api#error": "client",
-                "smithy.api#httpError": 403
-            }
-        },
-        "com.amazonaws.amp#AmazonPrometheusService": {
-            "type": "service",
-            "version": "2020-08-01",
-            "resources": [
-                {
-                    "target": "com.amazonaws.amp#Workspace"
-                }
-            ],
-            "traits": {
-                "aws.api#service": {
-                    "sdkId": "amp",
-                    "arnNamespace": "aps",
-                    "cloudFormationName": "AmazonPrometheusService",
-                    "cloudTrailEventSource": "CLOUDTRAIL_PLACEHOLDER_REPLACED_BY_CDK"
-                },
-                "aws.auth#sigv4": {
-                    "name": "aps"
-                },
-                "aws.protocols#restJson1": {},
-                "smithy.api#cors": {
-                    "additionalAllowedHeaders": [
-                        "Authorization",
-                        "x-amz-content-sha256",
-                        "X-Amz-Date",
-                        "x-amzn-trace-id",
-                        "X-Amz-Security-Token",
-                        "x-amz-user-agent",
-                        "*",
-                        "content-type",
-                        "x-amzn-platform-id",
-                        "X-Amz-Target",
-                        "Date"
-                    ],
-                    "additionalExposedHeaders": [
-                        "date",
-                        "x-amz-apigw-id",
-                        "x-amzn-trace-id",
-                        "x-amzn-errortype",
-                        "x-amzn-requestid",
-                        "x-amzn-errormessage"
-                    ]
-                },
-                "smithy.api#documentation": "Amazon Managed Service for Prometheus",
-                "smithy.api#title": "Amazon Prometheus Service"
-            }
-        },
-        "com.amazonaws.amp#ConflictException": {
-            "type": "structure",
-            "members": {
-                "message": {
-                    "target": "smithy.api#String",
-                    "traits": {
-                        "smithy.api#documentation": "Description of the error.",
-                        "smithy.api#required": {}
-                    }
-                },
-                "resourceId": {
-                    "target": "smithy.api#String",
-                    "traits": {
-                        "smithy.api#documentation": "Identifier of the resource affected.",
-                        "smithy.api#required": {}
-                    }
-                },
-                "resourceType": {
-                    "target": "smithy.api#String",
-                    "traits": {
-                        "smithy.api#documentation": "Type of the resource affected.",
-                        "smithy.api#required": {}
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "Updating or deleting a resource can cause an inconsistent state.",
-                "smithy.api#error": "client",
-                "smithy.api#httpError": 409
-            }
-        },
-        "com.amazonaws.amp#CreateWorkspace": {
-            "type": "operation",
-            "input": {
-                "target": "com.amazonaws.amp#CreateWorkspaceRequest"
-            },
-            "output": {
-                "target": "com.amazonaws.amp#CreateWorkspaceResponse"
-            },
-            "errors": [
-                {
-                    "target": "com.amazonaws.amp#AccessDeniedException"
-                },
-                {
-                    "target": "com.amazonaws.amp#ConflictException"
-                },
-                {
-                    "target": "com.amazonaws.amp#InternalServerException"
-                },
-                {
-                    "target": "com.amazonaws.amp#ServiceQuotaExceededException"
-                },
-                {
-                    "target": "com.amazonaws.amp#ThrottlingException"
-                },
-                {
-                    "target": "com.amazonaws.amp#ValidationException"
-                }
-            ],
-            "traits": {
-                "smithy.api#documentation": "Creates a new AMP workspace.",
-                "smithy.api#http": {
-                    "method": "POST",
-                    "uri": "/workspaces",
-                    "code": 202
-                },
-                "smithy.api#idempotent": {}
-            }
-        },
-        "com.amazonaws.amp#CreateWorkspaceRequest": {
-            "type": "structure",
-            "members": {
-                "alias": {
-                    "target": "com.amazonaws.amp#WorkspaceAlias",
-                    "traits": {
-                        "smithy.api#documentation": "An optional user-assigned alias for this workspace. This alias is for user reference and does not need to be unique."
-                    }
-                },
-                "clientToken": {
-                    "target": "com.amazonaws.amp#IdempotencyToken",
-                    "traits": {
-                        "smithy.api#documentation": "Optional, unique, case-sensitive, user-provided identifier to ensure the idempotency of the request.",
-                        "smithy.api#idempotencyToken": {}
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "Represents the input of a CreateWorkspace operation."
-            }
-        },
-        "com.amazonaws.amp#CreateWorkspaceResponse": {
-            "type": "structure",
-            "members": {
-                "workspaceId": {
-                    "target": "com.amazonaws.amp#WorkspaceId",
-                    "traits": {
-                        "smithy.api#documentation": "The generated ID of the workspace that was just created.",
-                        "smithy.api#required": {}
-                    }
-                },
-                "arn": {
-                    "target": "com.amazonaws.amp#WorkspaceArn",
-                    "traits": {
-                        "smithy.api#documentation": "The ARN of the workspace that was just created.",
-                        "smithy.api#required": {}
-                    }
-                },
-                "status": {
-                    "target": "com.amazonaws.amp#WorkspaceStatus",
-                    "traits": {
-                        "smithy.api#documentation": "The status of the workspace that was just created (usually CREATING).",
-                        "smithy.api#required": {}
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "Represents the output of a CreateWorkspace operation."
-            }
-        },
-        "com.amazonaws.amp#DeleteWorkspace": {
-            "type": "operation",
-            "input": {
-                "target": "com.amazonaws.amp#DeleteWorkspaceRequest"
-            },
-            "errors": [
-                {
-                    "target": "com.amazonaws.amp#AccessDeniedException"
-                },
-                {
-                    "target": "com.amazonaws.amp#InternalServerException"
-                },
-                {
-                    "target": "com.amazonaws.amp#ResourceNotFoundException"
-                },
-                {
-                    "target": "com.amazonaws.amp#ThrottlingException"
-                },
-                {
-                    "target": "com.amazonaws.amp#ValidationException"
-                }
-            ],
-            "traits": {
-                "smithy.api#documentation": "Deletes an AMP workspace.",
-                "smithy.api#http": {
-                    "method": "DELETE",
-                    "uri": "/workspaces/{workspaceId}",
-                    "code": 202
-                },
-                "smithy.api#idempotent": {}
-            }
-        },
-        "com.amazonaws.amp#DeleteWorkspaceRequest": {
-            "type": "structure",
-            "members": {
-                "workspaceId": {
-                    "target": "com.amazonaws.amp#WorkspaceId",
-                    "traits": {
-                        "smithy.api#documentation": "The ID of the workspace to delete.",
-                        "smithy.api#httpLabel": {},
-                        "smithy.api#required": {}
-                    }
-                },
-                "clientToken": {
-                    "target": "com.amazonaws.amp#IdempotencyToken",
-                    "traits": {
-                        "smithy.api#documentation": "Optional, unique, case-sensitive, user-provided identifier to ensure the idempotency of the request.",
-                        "smithy.api#httpQuery": "clientToken",
-                        "smithy.api#idempotencyToken": {}
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "Represents the input of a DeleteWorkspace operation."
-            }
-        },
-        "com.amazonaws.amp#DescribeWorkspace": {
-            "type": "operation",
-            "input": {
-                "target": "com.amazonaws.amp#DescribeWorkspaceRequest"
-            },
-            "output": {
-                "target": "com.amazonaws.amp#DescribeWorkspaceResponse"
-            },
-            "errors": [
-                {
-                    "target": "com.amazonaws.amp#AccessDeniedException"
-                },
-                {
-                    "target": "com.amazonaws.amp#InternalServerException"
-                },
-                {
-                    "target": "com.amazonaws.amp#ResourceNotFoundException"
-                },
-                {
-                    "target": "com.amazonaws.amp#ThrottlingException"
-                },
-                {
-                    "target": "com.amazonaws.amp#ValidationException"
-                }
-            ],
-            "traits": {
-                "smithy.api#documentation": "Describes an existing AMP workspace.",
-                "smithy.api#http": {
-                    "method": "GET",
-                    "uri": "/workspaces/{workspaceId}",
-                    "code": 200
-                },
-                "smithy.api#readonly": {}
-            }
-        },
-        "com.amazonaws.amp#DescribeWorkspaceRequest": {
-            "type": "structure",
-            "members": {
-                "workspaceId": {
-                    "target": "com.amazonaws.amp#WorkspaceId",
-                    "traits": {
-                        "smithy.api#documentation": "The ID of the workspace to describe.",
-                        "smithy.api#httpLabel": {},
-                        "smithy.api#required": {}
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "Represents the input of a DescribeWorkspace operation."
-            }
-        },
-        "com.amazonaws.amp#DescribeWorkspaceResponse": {
-            "type": "structure",
-            "members": {
-                "workspace": {
-                    "target": "com.amazonaws.amp#WorkspaceDescription",
-                    "traits": {
-                        "smithy.api#documentation": "The properties of the selected workspace.",
-                        "smithy.api#required": {}
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "Represents the output of a DescribeWorkspace operation."
-            }
-        },
-        "com.amazonaws.amp#IdempotencyToken": {
-            "type": "string",
-            "traits": {
-                "smithy.api#documentation": "An identifier used to ensure the idempotency of a write request.",
-                "smithy.api#length": {
-                    "min": 1,
-                    "max": 64
-                },
-                "smithy.api#pattern": "[!-~]+"
-            }
-        },
-        "com.amazonaws.amp#InternalServerException": {
-            "type": "structure",
-            "members": {
-                "message": {
-                    "target": "smithy.api#String",
-                    "traits": {
-                        "smithy.api#documentation": "Description of the error.",
-                        "smithy.api#required": {}
-                    }
-                },
-                "retryAfterSeconds": {
-                    "target": "smithy.api#Integer",
-                    "traits": {
-                        "smithy.api#documentation": "Advice to clients on when the call can be safely retried.",
-                        "smithy.api#httpHeader": "Retry-After"
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "Unexpected error during processing of request.",
-                "smithy.api#error": "server",
-                "smithy.api#httpError": 500,
-                "smithy.api#retryable": {}
-            }
-        },
-        "com.amazonaws.amp#ListWorkspaces": {
-            "type": "operation",
-            "input": {
-                "target": "com.amazonaws.amp#ListWorkspacesRequest"
-            },
-            "output": {
-                "target": "com.amazonaws.amp#ListWorkspacesResponse"
-            },
-            "errors": [
-                {
-                    "target": "com.amazonaws.amp#AccessDeniedException"
-                },
-                {
-                    "target": "com.amazonaws.amp#InternalServerException"
-                },
-                {
-                    "target": "com.amazonaws.amp#ThrottlingException"
-                },
-                {
-                    "target": "com.amazonaws.amp#ValidationException"
-                }
-            ],
-            "traits": {
-                "smithy.api#documentation": "Lists all AMP workspaces, including workspaces being created or deleted.",
-                "smithy.api#http": {
-                    "method": "GET",
-                    "uri": "/workspaces",
-                    "code": 200
-                },
-                "smithy.api#paginated": {
-                    "inputToken": "nextToken",
-                    "outputToken": "nextToken",
-                    "items": "workspaces",
-                    "pageSize": "maxResults"
-                },
-                "smithy.api#readonly": {}
-            }
-        },
-        "com.amazonaws.amp#ListWorkspacesRequest": {
-            "type": "structure",
-            "members": {
-                "nextToken": {
-                    "target": "com.amazonaws.amp#PaginationToken",
-                    "traits": {
-                        "smithy.api#documentation": "Pagination token to request the next page in a paginated list. This token is obtained from the output of the previous ListWorkspaces request.",
-                        "smithy.api#httpQuery": "nextToken"
-                    }
-                },
-                "alias": {
-                    "target": "com.amazonaws.amp#WorkspaceAlias",
-                    "traits": {
-                        "smithy.api#documentation": "Optional filter for workspace alias. Only the workspaces with aliases that begin with this value will be returned.",
-                        "smithy.api#httpQuery": "alias"
-                    }
-                },
-                "maxResults": {
-                    "target": "smithy.api#Integer",
-                    "traits": {
-                        "smithy.api#documentation": "Maximum results to return in response (default=100, maximum=1000).",
-                        "smithy.api#httpQuery": "maxResults",
-                        "smithy.api#range": {
-                            "min": 1,
-                            "max": 1000
-                        }
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "Represents the input of a ListWorkspaces operation."
-            }
-        },
-        "com.amazonaws.amp#ListWorkspacesResponse": {
-            "type": "structure",
-            "members": {
-                "workspaces": {
-                    "target": "com.amazonaws.amp#WorkspaceSummaryList",
-                    "traits": {
-                        "smithy.api#documentation": "The list of existing workspaces, including those undergoing creation or deletion.",
-                        "smithy.api#required": {}
-                    }
-                },
-                "nextToken": {
-                    "target": "com.amazonaws.amp#PaginationToken",
-                    "traits": {
-                        "smithy.api#documentation": "Pagination token to use when requesting the next page in this list."
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "Represents the output of a ListWorkspaces operation."
-            }
-        },
-        "com.amazonaws.amp#PaginationToken": {
-            "type": "string",
-            "traits": {
-                "smithy.api#documentation": "A token used to access the next page in a paginated result set."
-            }
-        },
-        "com.amazonaws.amp#ResourceNotFoundException": {
-            "type": "structure",
-            "members": {
-                "message": {
-                    "target": "smithy.api#String",
-                    "traits": {
-                        "smithy.api#documentation": "Description of the error.",
-                        "smithy.api#required": {}
-                    }
-                },
-                "resourceId": {
-                    "target": "smithy.api#String",
-                    "traits": {
-                        "smithy.api#documentation": "Identifier of the resource affected.",
-                        "smithy.api#required": {}
-                    }
-                },
-                "resourceType": {
-                    "target": "smithy.api#String",
-                    "traits": {
-                        "smithy.api#documentation": "Type of the resource affected.",
-                        "smithy.api#required": {}
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "Request references a resource which does not exist.",
-                "smithy.api#error": "client",
-                "smithy.api#httpError": 404
-            }
-        },
-        "com.amazonaws.amp#ServiceQuotaExceededException": {
-            "type": "structure",
-            "members": {
-                "message": {
-                    "target": "smithy.api#String",
-                    "traits": {
-                        "smithy.api#documentation": "Description of the error.",
-                        "smithy.api#required": {}
-                    }
-                },
-                "resourceId": {
-                    "target": "smithy.api#String",
-                    "traits": {
-                        "smithy.api#documentation": "Identifier of the resource affected.",
-                        "smithy.api#required": {}
-                    }
-                },
-                "resourceType": {
-                    "target": "smithy.api#String",
-                    "traits": {
-                        "smithy.api#documentation": "Type of the resource affected.",
-                        "smithy.api#required": {}
-                    }
-                },
-                "serviceCode": {
-                    "target": "smithy.api#String",
-                    "traits": {
-                        "smithy.api#documentation": "Service Quotas requirement to identify originating service.",
-                        "smithy.api#required": {}
-                    }
-                },
-                "quotaCode": {
-                    "target": "smithy.api#String",
-                    "traits": {
-                        "smithy.api#documentation": "Service Quotas requirement to identify originating quota.",
-                        "smithy.api#required": {}
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "Request would cause a service quota to be exceeded.",
-                "smithy.api#error": "client",
-                "smithy.api#httpError": 402
-            }
-        },
-        "com.amazonaws.amp#ThrottlingException": {
-            "type": "structure",
-            "members": {
-                "message": {
-                    "target": "smithy.api#String",
-                    "traits": {
-                        "smithy.api#documentation": "Description of the error.",
-                        "smithy.api#required": {}
-                    }
-                },
-                "serviceCode": {
-                    "target": "smithy.api#String",
-                    "traits": {
-                        "smithy.api#documentation": "Service Quotas requirement to identify originating service."
-                    }
-                },
-                "quotaCode": {
-                    "target": "smithy.api#String",
-                    "traits": {
-                        "smithy.api#documentation": "Service Quotas requirement to identify originating quota."
-                    }
-                },
-                "retryAfterSeconds": {
-                    "target": "smithy.api#Integer",
-                    "traits": {
-                        "smithy.api#documentation": "Advice to clients on when the call can be safely retried.",
-                        "smithy.api#httpHeader": "Retry-After"
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "Request was denied due to request throttling.",
-                "smithy.api#error": "client",
-                "smithy.api#httpError": 429,
-                "smithy.api#retryable": {}
-            }
-        },
-        "com.amazonaws.amp#UpdateWorkspaceAlias": {
-            "type": "operation",
-            "input": {
-                "target": "com.amazonaws.amp#UpdateWorkspaceAliasRequest"
-            },
-            "errors": [
-                {
-                    "target": "com.amazonaws.amp#AccessDeniedException"
-                },
-                {
-                    "target": "com.amazonaws.amp#ConflictException"
-                },
-                {
-                    "target": "com.amazonaws.amp#InternalServerException"
-                },
-                {
-                    "target": "com.amazonaws.amp#ResourceNotFoundException"
-                },
-                {
-                    "target": "com.amazonaws.amp#ServiceQuotaExceededException"
-                },
-                {
-                    "target": "com.amazonaws.amp#ThrottlingException"
-                },
-                {
-                    "target": "com.amazonaws.amp#ValidationException"
-                }
-            ],
-            "traits": {
-                "smithy.api#documentation": "Updates an AMP workspace alias.",
-                "smithy.api#http": {
-                    "method": "POST",
-                    "uri": "/workspaces/{workspaceId}/alias",
-                    "code": 204
-                },
-                "smithy.api#idempotent": {}
-            }
-        },
-        "com.amazonaws.amp#UpdateWorkspaceAliasRequest": {
-            "type": "structure",
-            "members": {
-                "workspaceId": {
-                    "target": "com.amazonaws.amp#WorkspaceId",
-                    "traits": {
-                        "smithy.api#documentation": "The ID of the workspace being updated.",
-                        "smithy.api#httpLabel": {},
-                        "smithy.api#required": {}
-                    }
-                },
-                "alias": {
-                    "target": "com.amazonaws.amp#WorkspaceAlias",
-                    "traits": {
-                        "smithy.api#documentation": "The new alias of the workspace."
-                    }
-                },
-                "clientToken": {
-                    "target": "com.amazonaws.amp#IdempotencyToken",
-                    "traits": {
-                        "smithy.api#documentation": "Optional, unique, case-sensitive, user-provided identifier to ensure the idempotency of the request.",
-                        "smithy.api#idempotencyToken": {}
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "Represents the input of an UpdateWorkspaceAlias operation."
-            }
-        },
-        "com.amazonaws.amp#Uri": {
-            "type": "string",
-            "traits": {
-                "smithy.api#length": {
-                    "min": 1,
-                    "max": 1024
-                }
-            }
-        },
-        "com.amazonaws.amp#ValidationException": {
-            "type": "structure",
-            "members": {
-                "message": {
-                    "target": "smithy.api#String",
-                    "traits": {
-                        "smithy.api#documentation": "Description of the error.",
-                        "smithy.api#required": {}
-                    }
-                },
-                "reason": {
-                    "target": "com.amazonaws.amp#ValidationExceptionReason",
-                    "traits": {
-                        "smithy.api#documentation": "Reason the request failed validation.",
-                        "smithy.api#required": {}
-                    }
-                },
-                "fieldList": {
-                    "target": "com.amazonaws.amp#ValidationExceptionFieldList",
-                    "traits": {
-                        "smithy.api#documentation": "The field that caused the error, if applicable. If more than one field caused the error, pick one and elaborate in the message."
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "The input fails to satisfy the constraints specified by an AWS service.",
-                "smithy.api#error": "client",
-                "smithy.api#httpError": 400
-            }
-        },
-        "com.amazonaws.amp#ValidationExceptionField": {
-            "type": "structure",
-            "members": {
-                "name": {
-                    "target": "smithy.api#String",
-                    "traits": {
-                        "smithy.api#documentation": "The field name.",
-                        "smithy.api#required": {}
-                    }
-                },
-                "message": {
-                    "target": "smithy.api#String",
-                    "traits": {
-                        "smithy.api#documentation": "Message describing why the field failed validation.",
-                        "smithy.api#required": {}
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "Stores information about a field passed inside a request that resulted in an exception."
-            }
-        },
-        "com.amazonaws.amp#ValidationExceptionFieldList": {
-            "type": "list",
-            "member": {
-                "target": "com.amazonaws.amp#ValidationExceptionField"
-            },
-            "traits": {
-                "smithy.api#documentation": "A list of fields."
-            }
-        },
-        "com.amazonaws.amp#ValidationExceptionReason": {
-            "type": "string",
-            "traits": {
-                "smithy.api#documentation": "Possible reasons a request failed validation.",
-                "smithy.api#enum": [
-                    {
-                        "value": "UNKNOWN_OPERATION",
-                        "name": "UNKNOWN_OPERATION"
-                    },
-                    {
-                        "value": "CANNOT_PARSE",
-                        "name": "CANNOT_PARSE"
-                    },
-                    {
-                        "value": "FIELD_VALIDATION_FAILED",
-                        "name": "FIELD_VALIDATION_FAILED"
-                    },
-                    {
-                        "value": "OTHER",
-                        "name": "OTHER"
-                    }
-                ]
-            }
-        },
-        "com.amazonaws.amp#Workspace": {
-            "type": "resource",
-            "identifiers": {
-                "workspaceId": {
-                    "target": "com.amazonaws.amp#WorkspaceId"
-                }
-            },
-            "create": {
-                "target": "com.amazonaws.amp#CreateWorkspace"
-            },
-            "read": {
-                "target": "com.amazonaws.amp#DescribeWorkspace"
-            },
-            "update": {
-                "target": "com.amazonaws.amp#UpdateWorkspaceAlias"
-            },
-            "delete": {
-                "target": "com.amazonaws.amp#DeleteWorkspace"
-            },
-            "list": {
-                "target": "com.amazonaws.amp#ListWorkspaces"
-            },
-            "traits": {
-                "aws.api#arn": {
-                    "template": "workspace/{workspaceId}",
-                    "absolute": false,
-                    "noAccount": false,
-                    "noRegion": false
-                },
-                "smithy.api#documentation": "An AMP workspace is a logical and isolated Prometheus server dedicated to Prometheus resources such as metrics, where you ingest, store, and query your Prometheus metrics."
-            }
-        },
-        "com.amazonaws.amp#WorkspaceAlias": {
-            "type": "string",
-            "traits": {
-                "smithy.api#documentation": "A user-assigned workspace alias.",
-                "smithy.api#length": {
-                    "min": 1,
-                    "max": 100
-                }
-            }
-        },
-        "com.amazonaws.amp#WorkspaceArn": {
-            "type": "string",
-            "traits": {
-                "aws.api#arnReference": {
-                    "type": "AWS::APS::Workspace",
-                    "service": "com.amazonaws.services.awsprometheus.serviceapi#ManagedPrometheusCP",
-                    "resource": "com.amazonaws.amp#Workspace"
-                },
-                "smithy.api#documentation": "An ARN identifying a Workspace."
-            }
-        },
-        "com.amazonaws.amp#WorkspaceDescription": {
-            "type": "structure",
-            "members": {
-                "workspaceId": {
-                    "target": "com.amazonaws.amp#WorkspaceId",
-                    "traits": {
-                        "smithy.api#documentation": "Unique string identifying this workspace.",
-                        "smithy.api#required": {}
-                    }
-                },
-                "alias": {
-                    "target": "com.amazonaws.amp#WorkspaceAlias",
-                    "traits": {
-                        "smithy.api#documentation": "Alias of this workspace."
-                    }
-                },
-                "arn": {
-                    "target": "com.amazonaws.amp#WorkspaceArn",
-                    "traits": {
-                        "smithy.api#documentation": "The Amazon Resource Name (ARN) of this workspace.",
-                        "smithy.api#required": {}
-                    }
-                },
-                "status": {
-                    "target": "com.amazonaws.amp#WorkspaceStatus",
-                    "traits": {
-                        "smithy.api#documentation": "The status of this workspace.",
-                        "smithy.api#required": {}
-                    }
-                },
-                "prometheusEndpoint": {
-                    "target": "com.amazonaws.amp#Uri",
-                    "traits": {
-                        "smithy.api#documentation": "Prometheus endpoint URI."
-                    }
-                },
-                "createdAt": {
-                    "target": "smithy.api#Timestamp",
-                    "traits": {
-                        "smithy.api#documentation": "The time when the workspace was created.",
-                        "smithy.api#required": {}
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "Represents the properties of a workspace.",
-                "smithy.api#references": [
-                    {
-                        "resource": "com.amazonaws.amp#Workspace"
-                    }
-                ]
-            }
-        },
-        "com.amazonaws.amp#WorkspaceId": {
-            "type": "string",
-            "traits": {
-                "smithy.api#documentation": "A workspace ID.",
-                "smithy.api#length": {
-                    "min": 1,
-                    "max": 64
-                },
-                "smithy.api#pattern": "[0-9A-Za-z][-.0-9A-Z_a-z]*"
-            }
-        },
-        "com.amazonaws.amp#WorkspaceStatus": {
-            "type": "structure",
-            "members": {
-                "statusCode": {
-                    "target": "com.amazonaws.amp#WorkspaceStatusCode",
-                    "traits": {
-                        "smithy.api#documentation": "Status code of this workspace.",
-                        "smithy.api#required": {}
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "Represents the status of a workspace."
-            }
-        },
-        "com.amazonaws.amp#WorkspaceStatusCode": {
-            "type": "string",
-            "traits": {
-                "smithy.api#documentation": "State of a workspace.",
-                "smithy.api#enum": [
-                    {
-                        "value": "CREATING",
-                        "name": "CREATING",
-                        "documentation": "Workspace is being created. Deletion is disallowed until status is ACTIVE."
-                    },
-                    {
-                        "value": "ACTIVE",
-                        "name": "ACTIVE",
-                        "documentation": "Workspace has been created and is usable."
-                    },
-                    {
-                        "value": "UPDATING",
-                        "name": "UPDATING",
-                        "documentation": "Workspace is being updated. Updates are allowed only when status is ACTIVE."
-                    },
-                    {
-                        "value": "DELETING",
-                        "name": "DELETING",
-                        "documentation": "Workspace is being deleted. Deletions are allowed only when status is ACTIVE."
-                    },
-                    {
-                        "value": "CREATION_FAILED",
-                        "name": "CREATION_FAILED",
-                        "documentation": "Workspace creation failed. Refer to WorkspaceStatus.failureReason for more details."
-                    }
-                ]
-            }
-        },
-        "com.amazonaws.amp#WorkspaceSummary": {
-            "type": "structure",
-            "members": {
-                "workspaceId": {
-                    "target": "com.amazonaws.amp#WorkspaceId",
-                    "traits": {
-                        "smithy.api#documentation": "Unique string identifying this workspace.",
-                        "smithy.api#required": {}
-                    }
-                },
-                "alias": {
-                    "target": "com.amazonaws.amp#WorkspaceAlias",
-                    "traits": {
-                        "smithy.api#documentation": "Alias of this workspace."
-                    }
-                },
-                "arn": {
-                    "target": "com.amazonaws.amp#WorkspaceArn",
-                    "traits": {
-                        "smithy.api#documentation": "The AmazonResourceName of this workspace.",
-                        "smithy.api#required": {}
-                    }
-                },
-                "status": {
-                    "target": "com.amazonaws.amp#WorkspaceStatus",
-                    "traits": {
-                        "smithy.api#documentation": "The status of this workspace.",
-                        "smithy.api#required": {}
-                    }
-                },
-                "createdAt": {
-                    "target": "smithy.api#Timestamp",
-                    "traits": {
-                        "smithy.api#documentation": "The time when the workspace was created.",
-                        "smithy.api#required": {}
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "Represents a summary of the properties of a workspace.",
-                "smithy.api#references": [
-                    {
-                        "resource": "com.amazonaws.amp#Workspace"
-                    }
-                ]
-            }
-        },
-        "com.amazonaws.amp#WorkspaceSummaryList": {
-            "type": "list",
-            "member": {
-                "target": "com.amazonaws.amp#WorkspaceSummary"
-            },
-            "traits": {
-                "smithy.api#documentation": "A list of workspace summaries."
-            }
-        }
-    }
-}

codegen/models/apigatewaymanagementapi.2018-11-29.json

@@ -1,297 +0,0 @@
-{
-    "smithy": "1.0",
-    "metadata": {
-        "suppressions": [
-            {
-                "id": "HttpMethodSemantics",
-                "namespace": "*"
-            },
-            {
-                "id": "HttpResponseCodeSemantics",
-                "namespace": "*"
-            },
-            {
-                "id": "PaginatedTrait",
-                "namespace": "*"
-            },
-            {
-                "id": "HttpHeaderTrait",
-                "namespace": "*"
-            },
-            {
-                "id": "HttpUriConflict",
-                "namespace": "*"
-            },
-            {
-                "id": "Service",
-                "namespace": "*"
-            }
-        ]
-    },
-    "shapes": {
-        "com.amazonaws.apigatewaymanagementapi#ApiGatewayManagementApi": {
-            "type": "service",
-            "version": "2018-11-29",
-            "operations": [
-                {
-                    "target": "com.amazonaws.apigatewaymanagementapi#DeleteConnection"
-                },
-                {
-                    "target": "com.amazonaws.apigatewaymanagementapi#GetConnection"
-                },
-                {
-                    "target": "com.amazonaws.apigatewaymanagementapi#PostToConnection"
-                }
-            ],
-            "traits": {
-                "aws.api#service": {
-                    "sdkId": "ApiGatewayManagementApi",
-                    "arnNamespace": "apigateway",
-                    "cloudFormationName": "ApiGatewayManagementApi",
-                    "cloudTrailEventSource": "apigatewaymanagementapi.amazonaws.com",
-                    "endpointPrefix": "execute-api"
-                },
-                "aws.auth#sigv4": {
-                    "name": "execute-api"
-                },
-                "aws.protocols#restJson1": {},
-                "smithy.api#documentation": "<p>The Amazon API Gateway Management API allows you to directly manage runtime aspects of your deployed APIs. To use it, you must explicitly set the SDK's endpoint to point to the endpoint of your deployed API. The endpoint will be of the form https://{api-id}.execute-api.{region}.amazonaws.com/{stage}, or will be the endpoint corresponding to your API's custom domain and base path, if applicable.</p>",
-                "smithy.api#title": "AmazonApiGatewayManagementApi"
-            }
-        },
-        "com.amazonaws.apigatewaymanagementapi#Data": {
-            "type": "blob",
-            "traits": {
-                "smithy.api#documentation": "<p>The data to be sent to the client specified by its connection id.</p>",
-                "smithy.api#length": {
-                    "min": 0,
-                    "max": 131072
-                }
-            }
-        },
-        "com.amazonaws.apigatewaymanagementapi#DeleteConnection": {
-            "type": "operation",
-            "input": {
-                "target": "com.amazonaws.apigatewaymanagementapi#DeleteConnectionRequest"
-            },
-            "errors": [
-                {
-                    "target": "com.amazonaws.apigatewaymanagementapi#ForbiddenException"
-                },
-                {
-                    "target": "com.amazonaws.apigatewaymanagementapi#GoneException"
-                },
-                {
-                    "target": "com.amazonaws.apigatewaymanagementapi#LimitExceededException"
-                }
-            ],
-            "traits": {
-                "smithy.api#documentation": "<p>Delete the connection with the provided id.</p>",
-                "smithy.api#http": {
-                    "method": "DELETE",
-                    "uri": "/@connections/{ConnectionId}",
-                    "code": 204
-                }
-            }
-        },
-        "com.amazonaws.apigatewaymanagementapi#DeleteConnectionRequest": {
-            "type": "structure",
-            "members": {
-                "ConnectionId": {
-                    "target": "com.amazonaws.apigatewaymanagementapi#__string",
-                    "traits": {
-                        "smithy.api#httpLabel": {},
-                        "smithy.api#required": {}
-                    }
-                }
-            }
-        },
-        "com.amazonaws.apigatewaymanagementapi#ForbiddenException": {
-            "type": "structure",
-            "members": {},
-            "traits": {
-                "smithy.api#documentation": "<p>The caller is not authorized to invoke this operation.</p>",
-                "smithy.api#error": "client",
-                "smithy.api#httpError": 403
-            }
-        },
-        "com.amazonaws.apigatewaymanagementapi#GetConnection": {
-            "type": "operation",
-            "input": {
-                "target": "com.amazonaws.apigatewaymanagementapi#GetConnectionRequest"
-            },
-            "output": {
-                "target": "com.amazonaws.apigatewaymanagementapi#GetConnectionResponse"
-            },
-            "errors": [
-                {
-                    "target": "com.amazonaws.apigatewaymanagementapi#ForbiddenException"
-                },
-                {
-                    "target": "com.amazonaws.apigatewaymanagementapi#GoneException"
-                },
-                {
-                    "target": "com.amazonaws.apigatewaymanagementapi#LimitExceededException"
-                }
-            ],
-            "traits": {
-                "smithy.api#documentation": "<p>Get information about the connection with the provided id.</p>",
-                "smithy.api#http": {
-                    "method": "GET",
-                    "uri": "/@connections/{ConnectionId}",
-                    "code": 200
-                }
-            }
-        },
-        "com.amazonaws.apigatewaymanagementapi#GetConnectionRequest": {
-            "type": "structure",
-            "members": {
-                "ConnectionId": {
-                    "target": "com.amazonaws.apigatewaymanagementapi#__string",
-                    "traits": {
-                        "smithy.api#httpLabel": {},
-                        "smithy.api#required": {}
-                    }
-                }
-            }
-        },
-        "com.amazonaws.apigatewaymanagementapi#GetConnectionResponse": {
-            "type": "structure",
-            "members": {
-                "ConnectedAt": {
-                    "target": "com.amazonaws.apigatewaymanagementapi#__timestampIso8601",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The time in ISO 8601 format for when the connection was established.</p>",
-                        "smithy.api#jsonName": "connectedAt"
-                    }
-                },
-                "Identity": {
-                    "target": "com.amazonaws.apigatewaymanagementapi#Identity",
-                    "traits": {
-                        "smithy.api#jsonName": "identity"
-                    }
-                },
-                "LastActiveAt": {
-                    "target": "com.amazonaws.apigatewaymanagementapi#__timestampIso8601",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The time in ISO 8601 format for when the connection was last active.</p>",
-                        "smithy.api#jsonName": "lastActiveAt"
-                    }
-                }
-            }
-        },
-        "com.amazonaws.apigatewaymanagementapi#GoneException": {
-            "type": "structure",
-            "members": {},
-            "traits": {
-                "smithy.api#documentation": "<p>The connection with the provided id no longer exists.</p>",
-                "smithy.api#error": "client",
-                "smithy.api#httpError": 410
-            }
-        },
-        "com.amazonaws.apigatewaymanagementapi#Identity": {
-            "type": "structure",
-            "members": {
-                "SourceIp": {
-                    "target": "com.amazonaws.apigatewaymanagementapi#__string",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The source IP address of the TCP connection making the request to API Gateway.</p>",
-                        "smithy.api#jsonName": "sourceIp",
-                        "smithy.api#required": {}
-                    }
-                },
-                "UserAgent": {
-                    "target": "com.amazonaws.apigatewaymanagementapi#__string",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The User Agent of the API caller.</p>",
-                        "smithy.api#jsonName": "userAgent",
-                        "smithy.api#required": {}
-                    }
-                }
-            }
-        },
-        "com.amazonaws.apigatewaymanagementapi#LimitExceededException": {
-            "type": "structure",
-            "members": {},
-            "traits": {
-                "smithy.api#documentation": "<p>The client is sending more than the allowed number of requests per unit of time or the WebSocket client side buffer is full.</p>",
-                "smithy.api#error": "client",
-                "smithy.api#httpError": 429
-            }
-        },
-        "com.amazonaws.apigatewaymanagementapi#PayloadTooLargeException": {
-            "type": "structure",
-            "members": {
-                "Message": {
-                    "target": "com.amazonaws.apigatewaymanagementapi#__string",
-                    "traits": {
-                        "smithy.api#jsonName": "message"
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>The data has exceeded the maximum size allowed.</p>",
-                "smithy.api#error": "client",
-                "smithy.api#httpError": 413
-            }
-        },
-        "com.amazonaws.apigatewaymanagementapi#PostToConnection": {
-            "type": "operation",
-            "input": {
-                "target": "com.amazonaws.apigatewaymanagementapi#PostToConnectionRequest"
-            },
-            "errors": [
-                {
-                    "target": "com.amazonaws.apigatewaymanagementapi#ForbiddenException"
-                },
-                {
-                    "target": "com.amazonaws.apigatewaymanagementapi#GoneException"
-                },
-                {
-                    "target": "com.amazonaws.apigatewaymanagementapi#LimitExceededException"
-                },
-                {
-                    "target": "com.amazonaws.apigatewaymanagementapi#PayloadTooLargeException"
-                }
-            ],
-            "traits": {
-                "smithy.api#documentation": "<p>Sends the provided data to the specified connection.</p>",
-                "smithy.api#http": {
-                    "method": "POST",
-                    "uri": "/@connections/{ConnectionId}",
-                    "code": 200
-                }
-            }
-        },
-        "com.amazonaws.apigatewaymanagementapi#PostToConnectionRequest": {
-            "type": "structure",
-            "members": {
-                "Data": {
-                    "target": "com.amazonaws.apigatewaymanagementapi#Data",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The data to be sent to the client specified by its connection id.</p>",
-                        "smithy.api#httpPayload": {},
-                        "smithy.api#required": {}
-                    }
-                },
-                "ConnectionId": {
-                    "target": "com.amazonaws.apigatewaymanagementapi#__string",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The identifier of the connection that a specific client is using.</p>",
-                        "smithy.api#httpLabel": {},
-                        "smithy.api#required": {}
-                    }
-                }
-            }
-        },
-        "com.amazonaws.apigatewaymanagementapi#__string": {
-            "type": "string"
-        },
-        "com.amazonaws.apigatewaymanagementapi#__timestampIso8601": {
-            "type": "timestamp",
-            "traits": {
-                "smithy.api#timestampFormat": "date-time"
-            }
-        }
-    }
-}

codegen/models/applicationcostprofiler.2020-09-10.json

@@ -1,834 +0,0 @@
-{
-    "smithy": "1.0",
-    "metadata": {
-        "suppressions": [
-            {
-                "id": "HttpMethodSemantics",
-                "namespace": "*"
-            },
-            {
-                "id": "HttpResponseCodeSemantics",
-                "namespace": "*"
-            },
-            {
-                "id": "PaginatedTrait",
-                "namespace": "*"
-            },
-            {
-                "id": "HttpHeaderTrait",
-                "namespace": "*"
-            },
-            {
-                "id": "HttpUriConflict",
-                "namespace": "*"
-            },
-            {
-                "id": "Service",
-                "namespace": "*"
-            }
-        ]
-    },
-    "shapes": {
-        "com.amazonaws.applicationcostprofiler#AWSApplicationCostProfiler": {
-            "type": "service",
-            "version": "2020-09-10",
-            "operations": [
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#DeleteReportDefinition"
-                },
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#GetReportDefinition"
-                },
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#ImportApplicationUsage"
-                },
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#ListReportDefinitions"
-                },
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#PutReportDefinition"
-                },
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#UpdateReportDefinition"
-                }
-            ],
-            "traits": {
-                "aws.api#service": {
-                    "sdkId": "ApplicationCostProfiler",
-                    "arnNamespace": "application-cost-profiler",
-                    "cloudFormationName": "ApplicationCostProfiler",
-                    "cloudTrailEventSource": "applicationcostprofiler.amazonaws.com",
-                    "endpointPrefix": "application-cost-profiler"
-                },
-                "aws.auth#sigv4": {
-                    "name": "application-cost-profiler"
-                },
-                "aws.protocols#restJson1": {},
-                "smithy.api#documentation": "<p>This reference provides descriptions of the AWS Application Cost Profiler API.</p>\n         <p>The AWS Application Cost Profiler API provides programmatic access to view, create, update, and delete\n      application cost report definitions, as well as to import your usage data into the Application Cost Profiler\n      service.</p>\n         <p>For more information about using this service, see the <a href=\"https://docs.aws.amazon.com/application-cost-profiler/latest/userguide/introduction.html\">AWS Application Cost\n        Profiler User Guide</a>.</p>",
-                "smithy.api#title": "AWS Application Cost Profiler"
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#AccessDeniedException": {
-            "type": "structure",
-            "members": {
-                "message": {
-                    "target": "com.amazonaws.applicationcostprofiler#ErrorMessage"
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>You do not have permission to perform this action.</p>",
-                "smithy.api#error": "client",
-                "smithy.api#httpError": 403
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#DeleteReportDefinition": {
-            "type": "operation",
-            "input": {
-                "target": "com.amazonaws.applicationcostprofiler#DeleteReportDefinitionRequest"
-            },
-            "output": {
-                "target": "com.amazonaws.applicationcostprofiler#DeleteReportDefinitionResult"
-            },
-            "errors": [
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#AccessDeniedException"
-                },
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#InternalServerException"
-                },
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#ThrottlingException"
-                },
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#ValidationException"
-                }
-            ],
-            "traits": {
-                "smithy.api#documentation": "<p>Deletes the specified report definition in AWS Application Cost Profiler. This stops the report from being\n      generated.</p>",
-                "smithy.api#http": {
-                    "method": "DELETE",
-                    "uri": "/reportDefinition/{reportId}",
-                    "code": 200
-                }
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#DeleteReportDefinitionRequest": {
-            "type": "structure",
-            "members": {
-                "reportId": {
-                    "target": "com.amazonaws.applicationcostprofiler#ReportId",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Required. ID of the report to delete.</p>",
-                        "smithy.api#httpLabel": {},
-                        "smithy.api#required": {}
-                    }
-                }
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#DeleteReportDefinitionResult": {
-            "type": "structure",
-            "members": {
-                "reportId": {
-                    "target": "com.amazonaws.applicationcostprofiler#ReportId",
-                    "traits": {
-                        "smithy.api#documentation": "<p>ID of the report that was deleted.</p>"
-                    }
-                }
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#ErrorMessage": {
-            "type": "string"
-        },
-        "com.amazonaws.applicationcostprofiler#Format": {
-            "type": "string",
-            "traits": {
-                "smithy.api#enum": [
-                    {
-                        "value": "CSV",
-                        "name": "CSV"
-                    },
-                    {
-                        "value": "PARQUET",
-                        "name": "PARQUET"
-                    }
-                ]
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#GetReportDefinition": {
-            "type": "operation",
-            "input": {
-                "target": "com.amazonaws.applicationcostprofiler#GetReportDefinitionRequest"
-            },
-            "output": {
-                "target": "com.amazonaws.applicationcostprofiler#GetReportDefinitionResult"
-            },
-            "errors": [
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#AccessDeniedException"
-                },
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#InternalServerException"
-                },
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#ThrottlingException"
-                },
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#ValidationException"
-                }
-            ],
-            "traits": {
-                "smithy.api#documentation": "<p>Retrieves the definition of a report already configured in AWS Application Cost Profiler.</p>",
-                "smithy.api#http": {
-                    "method": "GET",
-                    "uri": "/reportDefinition/{reportId}",
-                    "code": 200
-                }
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#GetReportDefinitionRequest": {
-            "type": "structure",
-            "members": {
-                "reportId": {
-                    "target": "com.amazonaws.applicationcostprofiler#ReportId",
-                    "traits": {
-                        "smithy.api#documentation": "<p>ID of the report to retrieve.</p>",
-                        "smithy.api#httpLabel": {},
-                        "smithy.api#required": {}
-                    }
-                }
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#GetReportDefinitionResult": {
-            "type": "structure",
-            "members": {
-                "reportId": {
-                    "target": "com.amazonaws.applicationcostprofiler#ReportId",
-                    "traits": {
-                        "smithy.api#documentation": "<p>ID of the report retrieved.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "reportDescription": {
-                    "target": "com.amazonaws.applicationcostprofiler#ReportDescription",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Description of the report.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "reportFrequency": {
-                    "target": "com.amazonaws.applicationcostprofiler#ReportFrequency",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Cadence used to generate the report.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "format": {
-                    "target": "com.amazonaws.applicationcostprofiler#Format",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Format of the generated report.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "destinationS3Location": {
-                    "target": "com.amazonaws.applicationcostprofiler#S3Location",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Amazon Simple Storage Service (Amazon S3) location where the report is uploaded.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "createdAt": {
-                    "target": "com.amazonaws.applicationcostprofiler#Timestamp",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Timestamp (milliseconds) when this report definition was created.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "lastUpdated": {
-                    "target": "com.amazonaws.applicationcostprofiler#Timestamp",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Timestamp (milliseconds) when this report definition was last updated.</p>",
-                        "smithy.api#required": {}
-                    }
-                }
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#ImportApplicationUsage": {
-            "type": "operation",
-            "input": {
-                "target": "com.amazonaws.applicationcostprofiler#ImportApplicationUsageRequest"
-            },
-            "output": {
-                "target": "com.amazonaws.applicationcostprofiler#ImportApplicationUsageResult"
-            },
-            "errors": [
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#AccessDeniedException"
-                },
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#InternalServerException"
-                },
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#ThrottlingException"
-                },
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#ValidationException"
-                }
-            ],
-            "traits": {
-                "smithy.api#documentation": "<p>Ingests application usage data from Amazon Simple Storage Service (Amazon S3).</p>\n         <p>The data must already exist in the S3 location. As part of the action, AWS Application Cost Profiler\n      copies the object from your S3 bucket to an S3 bucket owned by Amazon for processing\n      asynchronously.</p>",
-                "smithy.api#http": {
-                    "method": "POST",
-                    "uri": "/importApplicationUsage",
-                    "code": 200
-                }
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#ImportApplicationUsageRequest": {
-            "type": "structure",
-            "members": {
-                "sourceS3Location": {
-                    "target": "com.amazonaws.applicationcostprofiler#SourceS3Location",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Amazon S3 location to import application usage data from.</p>",
-                        "smithy.api#required": {}
-                    }
-                }
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#ImportApplicationUsageResult": {
-            "type": "structure",
-            "members": {
-                "importId": {
-                    "target": "com.amazonaws.applicationcostprofiler#ImportId",
-                    "traits": {
-                        "smithy.api#documentation": "<p>ID of the import request.</p>",
-                        "smithy.api#required": {}
-                    }
-                }
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#ImportId": {
-            "type": "string",
-            "traits": {
-                "smithy.api#length": {
-                    "min": 1,
-                    "max": 255
-                },
-                "smithy.api#pattern": "[0-9A-Za-z\\.\\-_]*"
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#Integer": {
-            "type": "integer",
-            "traits": {
-                "smithy.api#box": {},
-                "smithy.api#range": {
-                    "min": 1,
-                    "max": 100
-                }
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#InternalServerException": {
-            "type": "structure",
-            "members": {
-                "message": {
-                    "target": "com.amazonaws.applicationcostprofiler#ErrorMessage"
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>An internal server error occurred. Retry your request.</p>",
-                "smithy.api#error": "server",
-                "smithy.api#httpError": 500
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#ListReportDefinitions": {
-            "type": "operation",
-            "input": {
-                "target": "com.amazonaws.applicationcostprofiler#ListReportDefinitionsRequest"
-            },
-            "output": {
-                "target": "com.amazonaws.applicationcostprofiler#ListReportDefinitionsResult"
-            },
-            "errors": [
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#AccessDeniedException"
-                },
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#InternalServerException"
-                },
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#ThrottlingException"
-                },
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#ValidationException"
-                }
-            ],
-            "traits": {
-                "smithy.api#documentation": "<p>Retrieves a list of all reports and their configurations for your AWS account.</p>\n         <p>The maximum number of reports is one.</p>",
-                "smithy.api#http": {
-                    "method": "GET",
-                    "uri": "/reportDefinition",
-                    "code": 200
-                },
-                "smithy.api#paginated": {
-                    "inputToken": "nextToken",
-                    "outputToken": "nextToken",
-                    "pageSize": "maxResults"
-                }
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#ListReportDefinitionsRequest": {
-            "type": "structure",
-            "members": {
-                "nextToken": {
-                    "target": "com.amazonaws.applicationcostprofiler#Token",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The token value from a previous call to access the next page of results.</p>",
-                        "smithy.api#httpQuery": "nextToken"
-                    }
-                },
-                "maxResults": {
-                    "target": "com.amazonaws.applicationcostprofiler#Integer",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The maximum number of results to return.</p>",
-                        "smithy.api#httpQuery": "maxResults"
-                    }
-                }
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#ListReportDefinitionsResult": {
-            "type": "structure",
-            "members": {
-                "reportDefinitions": {
-                    "target": "com.amazonaws.applicationcostprofiler#ReportDefinitionList",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The retrieved reports.</p>"
-                    }
-                },
-                "nextToken": {
-                    "target": "com.amazonaws.applicationcostprofiler#Token",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The value of the next token, if it exists. Null if there are no more results.</p>"
-                    }
-                }
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#PutReportDefinition": {
-            "type": "operation",
-            "input": {
-                "target": "com.amazonaws.applicationcostprofiler#PutReportDefinitionRequest"
-            },
-            "output": {
-                "target": "com.amazonaws.applicationcostprofiler#PutReportDefinitionResult"
-            },
-            "errors": [
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#AccessDeniedException"
-                },
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#InternalServerException"
-                },
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#ServiceQuotaExceededException"
-                },
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#ThrottlingException"
-                },
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#ValidationException"
-                }
-            ],
-            "traits": {
-                "smithy.api#documentation": "<p>Creates the report definition for a report in Application Cost Profiler.</p>",
-                "smithy.api#http": {
-                    "method": "POST",
-                    "uri": "/reportDefinition",
-                    "code": 200
-                }
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#PutReportDefinitionRequest": {
-            "type": "structure",
-            "members": {
-                "reportId": {
-                    "target": "com.amazonaws.applicationcostprofiler#ReportId",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Required. ID of the report. You can choose any valid string matching the pattern for the\n      ID.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "reportDescription": {
-                    "target": "com.amazonaws.applicationcostprofiler#ReportDescription",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Required. Description of the report.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "reportFrequency": {
-                    "target": "com.amazonaws.applicationcostprofiler#ReportFrequency",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Required. The cadence to generate the report.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "format": {
-                    "target": "com.amazonaws.applicationcostprofiler#Format",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Required. The format to use for the generated report.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "destinationS3Location": {
-                    "target": "com.amazonaws.applicationcostprofiler#S3Location",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Required. Amazon Simple Storage Service (Amazon S3) location where Application Cost Profiler uploads the\n      report.</p>",
-                        "smithy.api#required": {}
-                    }
-                }
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#PutReportDefinitionResult": {
-            "type": "structure",
-            "members": {
-                "reportId": {
-                    "target": "com.amazonaws.applicationcostprofiler#ReportId",
-                    "traits": {
-                        "smithy.api#documentation": "<p>ID of the report.</p>"
-                    }
-                }
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#ReportDefinition": {
-            "type": "structure",
-            "members": {
-                "reportId": {
-                    "target": "com.amazonaws.applicationcostprofiler#ReportId",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The ID of the report.</p>"
-                    }
-                },
-                "reportDescription": {
-                    "target": "com.amazonaws.applicationcostprofiler#ReportDescription",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Description of the report</p>"
-                    }
-                },
-                "reportFrequency": {
-                    "target": "com.amazonaws.applicationcostprofiler#ReportFrequency",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The cadence at which the report is generated.</p>"
-                    }
-                },
-                "format": {
-                    "target": "com.amazonaws.applicationcostprofiler#Format",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The format used for the generated reports.</p>"
-                    }
-                },
-                "destinationS3Location": {
-                    "target": "com.amazonaws.applicationcostprofiler#S3Location",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The location in Amazon Simple Storage Service (Amazon S3) the reports should be saved to.</p>"
-                    }
-                },
-                "createdAt": {
-                    "target": "com.amazonaws.applicationcostprofiler#Timestamp",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Timestamp (milliseconds) when this report definition was created.</p>"
-                    }
-                },
-                "lastUpdatedAt": {
-                    "target": "com.amazonaws.applicationcostprofiler#Timestamp",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Timestamp (milliseconds) when this report definition was last updated.</p>"
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>The configuration of a report in AWS Application Cost Profiler.</p>"
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#ReportDefinitionList": {
-            "type": "list",
-            "member": {
-                "target": "com.amazonaws.applicationcostprofiler#ReportDefinition"
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#ReportDescription": {
-            "type": "string",
-            "traits": {
-                "smithy.api#length": {
-                    "min": 1,
-                    "max": 1024
-                },
-                "smithy.api#pattern": ".*\\S.*"
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#ReportFrequency": {
-            "type": "string",
-            "traits": {
-                "smithy.api#enum": [
-                    {
-                        "value": "MONTHLY",
-                        "name": "MONTHLY"
-                    },
-                    {
-                        "value": "DAILY",
-                        "name": "DAILY"
-                    },
-                    {
-                        "value": "ALL",
-                        "name": "ALL"
-                    }
-                ]
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#ReportId": {
-            "type": "string",
-            "traits": {
-                "smithy.api#length": {
-                    "min": 1,
-                    "max": 255
-                },
-                "smithy.api#pattern": "^[0-9A-Za-z\\.\\-_]+$"
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#S3Bucket": {
-            "type": "string",
-            "traits": {
-                "smithy.api#length": {
-                    "min": 3,
-                    "max": 63
-                },
-                "smithy.api#pattern": "(?=^.{3,63}$)(?!^(\\d+\\.)+\\d+$)(^(([a-z0-9]|[a-z0-9][a-z0-9\\-]*[a-z0-9])\\.)*([a-z0-9]|[a-z0-9][a-z0-9\\-]*[a-z0-9])$)"
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#S3BucketRegion": {
-            "type": "string",
-            "traits": {
-                "smithy.api#enum": [
-                    {
-                        "value": "ap-east-1",
-                        "name": "AP_EAST_1"
-                    },
-                    {
-                        "value": "me-south-1",
-                        "name": "ME_SOUTH_1"
-                    },
-                    {
-                        "value": "eu-south-1",
-                        "name": "EU_SOUTH_1"
-                    },
-                    {
-                        "value": "af-south-1",
-                        "name": "AF_SOUTH_1"
-                    }
-                ]
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#S3Key": {
-            "type": "string",
-            "traits": {
-                "smithy.api#length": {
-                    "min": 1,
-                    "max": 512
-                },
-                "smithy.api#pattern": ".*\\S.*"
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#S3Location": {
-            "type": "structure",
-            "members": {
-                "bucket": {
-                    "target": "com.amazonaws.applicationcostprofiler#S3Bucket",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Name of the S3 bucket.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "prefix": {
-                    "target": "com.amazonaws.applicationcostprofiler#S3Prefix",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Prefix for the location to write to.</p>",
-                        "smithy.api#required": {}
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>Represents the Amazon Simple Storage Service (Amazon S3) location where AWS Application Cost Profiler\n      reports are generated and then written to.</p>"
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#S3Prefix": {
-            "type": "string",
-            "traits": {
-                "smithy.api#length": {
-                    "min": 1,
-                    "max": 512
-                },
-                "smithy.api#pattern": ".*\\S.*"
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#ServiceQuotaExceededException": {
-            "type": "structure",
-            "members": {
-                "message": {
-                    "target": "com.amazonaws.applicationcostprofiler#ErrorMessage"
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>Your request exceeds one or more of the service quotas.</p>",
-                "smithy.api#error": "client",
-                "smithy.api#httpError": 402
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#SourceS3Location": {
-            "type": "structure",
-            "members": {
-                "bucket": {
-                    "target": "com.amazonaws.applicationcostprofiler#S3Bucket",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Name of the bucket.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "key": {
-                    "target": "com.amazonaws.applicationcostprofiler#S3Key",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Key of the object.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "region": {
-                    "target": "com.amazonaws.applicationcostprofiler#S3BucketRegion",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Region of the bucket. Only required for Regions that are disabled by default.\n        For more infomration about Regions that are disabled by default, see <a href=\"https://docs.aws.amazon.com/general/latest/gr/rande-manage.html#rande-manage-enable\">\n          Enabling a Region</a> in the <i>AWS General Reference guide</i>.</p>"
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>Represents the Amazon Simple Storage Service (Amazon S3) location where usage data is read\n      from.</p>"
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#ThrottlingException": {
-            "type": "structure",
-            "members": {
-                "message": {
-                    "target": "com.amazonaws.applicationcostprofiler#ErrorMessage"
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>The calls to AWS Application Cost Profiler API are throttled. The request was denied.</p>",
-                "smithy.api#error": "client",
-                "smithy.api#httpError": 429
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#Timestamp": {
-            "type": "timestamp"
-        },
-        "com.amazonaws.applicationcostprofiler#Token": {
-            "type": "string",
-            "traits": {
-                "smithy.api#length": {
-                    "min": 1,
-                    "max": 102400
-                },
-                "smithy.api#pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$"
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#UpdateReportDefinition": {
-            "type": "operation",
-            "input": {
-                "target": "com.amazonaws.applicationcostprofiler#UpdateReportDefinitionRequest"
-            },
-            "output": {
-                "target": "com.amazonaws.applicationcostprofiler#UpdateReportDefinitionResult"
-            },
-            "errors": [
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#AccessDeniedException"
-                },
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#InternalServerException"
-                },
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#ThrottlingException"
-                },
-                {
-                    "target": "com.amazonaws.applicationcostprofiler#ValidationException"
-                }
-            ],
-            "traits": {
-                "smithy.api#documentation": "<p>Updates existing report in AWS Application Cost Profiler.</p>",
-                "smithy.api#http": {
-                    "method": "PUT",
-                    "uri": "/reportDefinition/{reportId}",
-                    "code": 200
-                }
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#UpdateReportDefinitionRequest": {
-            "type": "structure",
-            "members": {
-                "reportId": {
-                    "target": "com.amazonaws.applicationcostprofiler#ReportId",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Required. ID of the report to update.</p>",
-                        "smithy.api#httpLabel": {},
-                        "smithy.api#required": {}
-                    }
-                },
-                "reportDescription": {
-                    "target": "com.amazonaws.applicationcostprofiler#ReportDescription",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Required. Description of the report.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "reportFrequency": {
-                    "target": "com.amazonaws.applicationcostprofiler#ReportFrequency",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Required. The cadence to generate the report.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "format": {
-                    "target": "com.amazonaws.applicationcostprofiler#Format",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Required. The format to use for the generated report.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "destinationS3Location": {
-                    "target": "com.amazonaws.applicationcostprofiler#S3Location",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Required. Amazon Simple Storage Service (Amazon S3) location where Application Cost Profiler uploads the\n      report.</p>",
-                        "smithy.api#required": {}
-                    }
-                }
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#UpdateReportDefinitionResult": {
-            "type": "structure",
-            "members": {
-                "reportId": {
-                    "target": "com.amazonaws.applicationcostprofiler#ReportId",
-                    "traits": {
-                        "smithy.api#documentation": "<p>ID of the report.</p>"
-                    }
-                }
-            }
-        },
-        "com.amazonaws.applicationcostprofiler#ValidationException": {
-            "type": "structure",
-            "members": {
-                "message": {
-                    "target": "com.amazonaws.applicationcostprofiler#ErrorMessage"
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>The input fails to satisfy the constraints for the API.</p>",
-                "smithy.api#error": "client",
-                "smithy.api#httpError": 400
-            }
-        }
-    }
-}

codegen/models/connectcontactlens.2020-08-21.json

@@ -1,584 +0,0 @@
-{
-    "smithy": "1.0",
-    "metadata": {
-        "suppressions": [
-            {
-                "id": "HttpMethodSemantics",
-                "namespace": "*"
-            },
-            {
-                "id": "HttpResponseCodeSemantics",
-                "namespace": "*"
-            },
-            {
-                "id": "PaginatedTrait",
-                "namespace": "*"
-            },
-            {
-                "id": "HttpHeaderTrait",
-                "namespace": "*"
-            },
-            {
-                "id": "HttpUriConflict",
-                "namespace": "*"
-            },
-            {
-                "id": "Service",
-                "namespace": "*"
-            }
-        ]
-    },
-    "shapes": {
-        "com.amazonaws.connectcontactlens#AccessDeniedException": {
-            "type": "structure",
-            "members": {
-                "Message": {
-                    "target": "com.amazonaws.connectcontactlens#Message",
-                    "traits": {
-                        "smithy.api#required": {}
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>You do not have sufficient access to perform this action.</p>",
-                "smithy.api#error": "client",
-                "smithy.api#httpError": 403
-            }
-        },
-        "com.amazonaws.connectcontactlens#AmazonConnectContactLens": {
-            "type": "service",
-            "version": "2020-08-21",
-            "operations": [
-                {
-                    "target": "com.amazonaws.connectcontactlens#ListRealtimeContactAnalysisSegments"
-                }
-            ],
-            "traits": {
-                "aws.api#service": {
-                    "sdkId": "Connect Contact Lens",
-                    "arnNamespace": "connect",
-                    "cloudFormationName": "ConnectContactLens",
-                    "cloudTrailEventSource": "connectcontactlens.amazonaws.com",
-                    "endpointPrefix": "contact-lens"
-                },
-                "aws.auth#sigv4": {
-                    "name": "connect"
-                },
-                "aws.protocols#restJson1": {},
-                "smithy.api#documentation": "<p>Contact Lens for Amazon Connect enables you to analyze conversations between customer and agents,\n      by using speech transcription, natural language processing, and intelligent search\n      capabilities. It performs sentiment analysis, detects issues, and enables you to automatically\n      categorize contacts.</p>\n         <p>Contact Lens for Amazon Connect provides both real-time and post-call analytics of customer-agent\n      conversations. For more information, see <a href=\"https://docs.aws.amazon.com/connect/latest/adminguide/analyze-conversations.html\">Analyze conversations using\n        Contact Lens</a> in the <i>Amazon Connect Administrator Guide</i>. </p>",
-                "smithy.api#title": "Amazon Connect Contact Lens"
-            }
-        },
-        "com.amazonaws.connectcontactlens#Categories": {
-            "type": "structure",
-            "members": {
-                "MatchedCategories": {
-                    "target": "com.amazonaws.connectcontactlens#MatchedCategories",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The category rules that have been matched in the analyzed segment.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "MatchedDetails": {
-                    "target": "com.amazonaws.connectcontactlens#MatchedDetails",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The category rule that was matched and when it occurred in the transcript.</p>",
-                        "smithy.api#required": {}
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>Provides the category rules that are used to automatically categorize contacts based on\n      uttered keywords and phrases.</p>"
-            }
-        },
-        "com.amazonaws.connectcontactlens#CategoryDetails": {
-            "type": "structure",
-            "members": {
-                "PointsOfInterest": {
-                    "target": "com.amazonaws.connectcontactlens#PointsOfInterest",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The section of audio where the category rule was detected.</p>",
-                        "smithy.api#required": {}
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>Provides information about the category rule that was matched.</p>"
-            }
-        },
-        "com.amazonaws.connectcontactlens#CategoryName": {
-            "type": "string",
-            "traits": {
-                "smithy.api#length": {
-                    "min": 1,
-                    "max": 256
-                },
-                "smithy.api#pattern": ".*\\S.*"
-            }
-        },
-        "com.amazonaws.connectcontactlens#CharacterOffset": {
-            "type": "integer",
-            "traits": {
-                "smithy.api#range": {
-                    "min": 0
-                }
-            }
-        },
-        "com.amazonaws.connectcontactlens#CharacterOffsets": {
-            "type": "structure",
-            "members": {
-                "BeginOffsetChar": {
-                    "target": "com.amazonaws.connectcontactlens#CharacterOffset",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The beginning of the issue.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "EndOffsetChar": {
-                    "target": "com.amazonaws.connectcontactlens#CharacterOffset",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The end of the issue.</p>",
-                        "smithy.api#required": {}
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>For characters that were detected as issues, where they occur in the transcript.</p>"
-            }
-        },
-        "com.amazonaws.connectcontactlens#ContactId": {
-            "type": "string",
-            "traits": {
-                "smithy.api#length": {
-                    "min": 1,
-                    "max": 256
-                },
-                "smithy.api#pattern": ".*\\S.*"
-            }
-        },
-        "com.amazonaws.connectcontactlens#InstanceId": {
-            "type": "string",
-            "traits": {
-                "smithy.api#length": {
-                    "min": 1,
-                    "max": 256
-                },
-                "smithy.api#pattern": ".*\\S.*"
-            }
-        },
-        "com.amazonaws.connectcontactlens#InternalServiceException": {
-            "type": "structure",
-            "members": {
-                "Message": {
-                    "target": "com.amazonaws.connectcontactlens#Message"
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>Request processing failed due to an error or failure with the service.</p>",
-                "smithy.api#error": "server",
-                "smithy.api#httpError": 500
-            }
-        },
-        "com.amazonaws.connectcontactlens#InvalidRequestException": {
-            "type": "structure",
-            "members": {
-                "Message": {
-                    "target": "com.amazonaws.connectcontactlens#Message"
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>The request is not valid.</p>",
-                "smithy.api#error": "client",
-                "smithy.api#httpError": 400
-            }
-        },
-        "com.amazonaws.connectcontactlens#IssueDetected": {
-            "type": "structure",
-            "members": {
-                "CharacterOffsets": {
-                    "target": "com.amazonaws.connectcontactlens#CharacterOffsets",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The offset for when the issue was detected in the segment.</p>",
-                        "smithy.api#required": {}
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>Potential issues that are detected based on an artificial intelligence analysis of each\n      turn in the conversation.</p>"
-            }
-        },
-        "com.amazonaws.connectcontactlens#IssuesDetected": {
-            "type": "list",
-            "member": {
-                "target": "com.amazonaws.connectcontactlens#IssueDetected"
-            },
-            "traits": {
-                "smithy.api#length": {
-                    "min": 0,
-                    "max": 20
-                }
-            }
-        },
-        "com.amazonaws.connectcontactlens#ListRealtimeContactAnalysisSegments": {
-            "type": "operation",
-            "input": {
-                "target": "com.amazonaws.connectcontactlens#ListRealtimeContactAnalysisSegmentsRequest"
-            },
-            "output": {
-                "target": "com.amazonaws.connectcontactlens#ListRealtimeContactAnalysisSegmentsResponse"
-            },
-            "errors": [
-                {
-                    "target": "com.amazonaws.connectcontactlens#AccessDeniedException"
-                },
-                {
-                    "target": "com.amazonaws.connectcontactlens#InternalServiceException"
-                },
-                {
-                    "target": "com.amazonaws.connectcontactlens#InvalidRequestException"
-                },
-                {
-                    "target": "com.amazonaws.connectcontactlens#ResourceNotFoundException"
-                },
-                {
-                    "target": "com.amazonaws.connectcontactlens#ThrottlingException"
-                }
-            ],
-            "traits": {
-                "smithy.api#documentation": "<p>Provides a list of analysis segments for a real-time analysis session.</p>",
-                "smithy.api#http": {
-                    "method": "POST",
-                    "uri": "/realtime-contact-analysis/analysis-segments",
-                    "code": 200
-                },
-                "smithy.api#paginated": {
-                    "inputToken": "NextToken",
-                    "outputToken": "NextToken",
-                    "pageSize": "MaxResults"
-                }
-            }
-        },
-        "com.amazonaws.connectcontactlens#ListRealtimeContactAnalysisSegmentsRequest": {
-            "type": "structure",
-            "members": {
-                "InstanceId": {
-                    "target": "com.amazonaws.connectcontactlens#InstanceId",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The identifier of the Amazon Connect instance.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "ContactId": {
-                    "target": "com.amazonaws.connectcontactlens#ContactId",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The identifier of the contact.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "MaxResults": {
-                    "target": "com.amazonaws.connectcontactlens#MaxResults",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The maximimum number of results to return per page.</p>"
-                    }
-                },
-                "NextToken": {
-                    "target": "com.amazonaws.connectcontactlens#NextToken",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The token for the next set of results. Use the value returned in the previous \nresponse in the next request to retrieve the next set of results.</p>"
-                    }
-                }
-            }
-        },
-        "com.amazonaws.connectcontactlens#ListRealtimeContactAnalysisSegmentsResponse": {
-            "type": "structure",
-            "members": {
-                "Segments": {
-                    "target": "com.amazonaws.connectcontactlens#RealtimeContactAnalysisSegments",
-                    "traits": {
-                        "smithy.api#documentation": "<p>An analyzed transcript or category.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "NextToken": {
-                    "target": "com.amazonaws.connectcontactlens#NextToken",
-                    "traits": {
-                        "smithy.api#documentation": "<p>If there are additional results, this is the token for the next set of results. If response includes <code>nextToken</code> there are two possible scenarios:</p>\n         <ul>\n            <li>\n               <p>There are more segments so another call is required to get them.</p>\n            </li>\n            <li>\n               <p>There are no more segments at this time, but more may be available later (real-time\n          analysis is in progress) so the client should call the operation again to get new\n          segments.</p>\n            </li>\n         </ul>\n         <p>If response does not include <code>nextToken</code>, the analysis is completed (successfully or failed) and there are no more segments to retrieve.</p>"
-                    }
-                }
-            }
-        },
-        "com.amazonaws.connectcontactlens#MatchedCategories": {
-            "type": "list",
-            "member": {
-                "target": "com.amazonaws.connectcontactlens#CategoryName"
-            },
-            "traits": {
-                "smithy.api#length": {
-                    "min": 0,
-                    "max": 150
-                }
-            }
-        },
-        "com.amazonaws.connectcontactlens#MatchedDetails": {
-            "type": "map",
-            "key": {
-                "target": "com.amazonaws.connectcontactlens#CategoryName"
-            },
-            "value": {
-                "target": "com.amazonaws.connectcontactlens#CategoryDetails"
-            },
-            "traits": {
-                "smithy.api#length": {
-                    "min": 0,
-                    "max": 150
-                }
-            }
-        },
-        "com.amazonaws.connectcontactlens#MaxResults": {
-            "type": "integer",
-            "traits": {
-                "smithy.api#range": {
-                    "min": 1,
-                    "max": 100
-                }
-            }
-        },
-        "com.amazonaws.connectcontactlens#Message": {
-            "type": "string"
-        },
-        "com.amazonaws.connectcontactlens#NextToken": {
-            "type": "string",
-            "traits": {
-                "smithy.api#length": {
-                    "min": 1,
-                    "max": 131070
-                },
-                "smithy.api#pattern": ".*\\S.*"
-            }
-        },
-        "com.amazonaws.connectcontactlens#OffsetMillis": {
-            "type": "integer",
-            "traits": {
-                "smithy.api#range": {
-                    "min": 0
-                }
-            }
-        },
-        "com.amazonaws.connectcontactlens#ParticipantId": {
-            "type": "string",
-            "traits": {
-                "smithy.api#length": {
-                    "min": 1,
-                    "max": 256
-                },
-                "smithy.api#pattern": ".*\\S.*"
-            }
-        },
-        "com.amazonaws.connectcontactlens#ParticipantRole": {
-            "type": "string",
-            "traits": {
-                "smithy.api#length": {
-                    "min": 1,
-                    "max": 256
-                },
-                "smithy.api#pattern": ".*\\S.*"
-            }
-        },
-        "com.amazonaws.connectcontactlens#PointOfInterest": {
-            "type": "structure",
-            "members": {
-                "BeginOffsetMillis": {
-                    "target": "com.amazonaws.connectcontactlens#OffsetMillis",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The beginning offset in milliseconds where the category rule was detected.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "EndOffsetMillis": {
-                    "target": "com.amazonaws.connectcontactlens#OffsetMillis",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The ending offset in milliseconds where the category rule was detected.</p>",
-                        "smithy.api#required": {}
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>The section of the contact audio where that category rule was detected.</p>"
-            }
-        },
-        "com.amazonaws.connectcontactlens#PointsOfInterest": {
-            "type": "list",
-            "member": {
-                "target": "com.amazonaws.connectcontactlens#PointOfInterest"
-            },
-            "traits": {
-                "smithy.api#length": {
-                    "min": 0,
-                    "max": 20
-                }
-            }
-        },
-        "com.amazonaws.connectcontactlens#RealtimeContactAnalysisSegment": {
-            "type": "structure",
-            "members": {
-                "Transcript": {
-                    "target": "com.amazonaws.connectcontactlens#Transcript",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The analyzed transcript.</p>"
-                    }
-                },
-                "Categories": {
-                    "target": "com.amazonaws.connectcontactlens#Categories",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The matched category rules.</p>"
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>An analyzed segment for a real-time analysis session.</p>"
-            }
-        },
-        "com.amazonaws.connectcontactlens#RealtimeContactAnalysisSegments": {
-            "type": "list",
-            "member": {
-                "target": "com.amazonaws.connectcontactlens#RealtimeContactAnalysisSegment"
-            },
-            "traits": {
-                "smithy.api#length": {
-                    "min": 0,
-                    "max": 100
-                }
-            }
-        },
-        "com.amazonaws.connectcontactlens#ResourceNotFoundException": {
-            "type": "structure",
-            "members": {
-                "Message": {
-                    "target": "com.amazonaws.connectcontactlens#Message"
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>The specified resource was not found.</p>",
-                "smithy.api#error": "client",
-                "smithy.api#httpError": 404
-            }
-        },
-        "com.amazonaws.connectcontactlens#SentimentValue": {
-            "type": "string",
-            "traits": {
-                "smithy.api#enum": [
-                    {
-                        "value": "POSITIVE",
-                        "name": "POSITIVE"
-                    },
-                    {
-                        "value": "NEUTRAL",
-                        "name": "NEUTRAL"
-                    },
-                    {
-                        "value": "NEGATIVE",
-                        "name": "NEGATIVE"
-                    }
-                ]
-            }
-        },
-        "com.amazonaws.connectcontactlens#ThrottlingException": {
-            "type": "structure",
-            "members": {
-                "Message": {
-                    "target": "com.amazonaws.connectcontactlens#Message",
-                    "traits": {
-                        "smithy.api#required": {}
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>The throttling limit has been exceeded.</p>",
-                "smithy.api#error": "client",
-                "smithy.api#httpError": 429
-            }
-        },
-        "com.amazonaws.connectcontactlens#Transcript": {
-            "type": "structure",
-            "members": {
-                "Id": {
-                    "target": "com.amazonaws.connectcontactlens#TranscriptId",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The identifier of the transcript.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "ParticipantId": {
-                    "target": "com.amazonaws.connectcontactlens#ParticipantId",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The identifier of the participant.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "ParticipantRole": {
-                    "target": "com.amazonaws.connectcontactlens#ParticipantRole",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The role of participant. For example, is it a customer, agent, or system.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "Content": {
-                    "target": "com.amazonaws.connectcontactlens#TranscriptContent",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The content of the transcript.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "BeginOffsetMillis": {
-                    "target": "com.amazonaws.connectcontactlens#OffsetMillis",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The beginning offset in the contact for this transcript.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "EndOffsetMillis": {
-                    "target": "com.amazonaws.connectcontactlens#OffsetMillis",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The end offset in the contact for this transcript.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "Sentiment": {
-                    "target": "com.amazonaws.connectcontactlens#SentimentValue",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The sentiment of the detected for this piece of transcript.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "IssuesDetected": {
-                    "target": "com.amazonaws.connectcontactlens#IssuesDetected",
-                    "traits": {
-                        "smithy.api#documentation": "<p>List of positions where issues were detected on the transcript.</p>"
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>A list of messages in the session.</p>"
-            }
-        },
-        "com.amazonaws.connectcontactlens#TranscriptContent": {
-            "type": "string",
-            "traits": {
-                "smithy.api#length": {
-                    "min": 1
-                },
-                "smithy.api#pattern": ".*\\S.*"
-            }
-        },
-        "com.amazonaws.connectcontactlens#TranscriptId": {
-            "type": "string",
-            "traits": {
-                "smithy.api#length": {
-                    "min": 1,
-                    "max": 256
-                },
-                "smithy.api#pattern": ".*\\S.*"
-            }
-        }
-    }
-}

codegen/models/costandusagereportservice.2017-01-06.json

@@ -1,695 +0,0 @@
-{
-    "smithy": "1.0",
-    "metadata": {
-        "suppressions": [
-            {
-                "id": "HttpMethodSemantics",
-                "namespace": "*"
-            },
-            {
-                "id": "HttpResponseCodeSemantics",
-                "namespace": "*"
-            },
-            {
-                "id": "PaginatedTrait",
-                "namespace": "*"
-            },
-            {
-                "id": "HttpHeaderTrait",
-                "namespace": "*"
-            },
-            {
-                "id": "HttpUriConflict",
-                "namespace": "*"
-            },
-            {
-                "id": "Service",
-                "namespace": "*"
-            }
-        ]
-    },
-    "shapes": {
-        "com.amazonaws.costandusagereportservice#AWSOrigamiServiceGatewayService": {
-            "type": "service",
-            "version": "2017-01-06",
-            "operations": [
-                {
-                    "target": "com.amazonaws.costandusagereportservice#DeleteReportDefinition"
-                },
-                {
-                    "target": "com.amazonaws.costandusagereportservice#DescribeReportDefinitions"
-                },
-                {
-                    "target": "com.amazonaws.costandusagereportservice#ModifyReportDefinition"
-                },
-                {
-                    "target": "com.amazonaws.costandusagereportservice#PutReportDefinition"
-                }
-            ],
-            "traits": {
-                "aws.api#service": {
-                    "sdkId": "Cost and Usage Report Service",
-                    "arnNamespace": "cur",
-                    "cloudFormationName": "CostandUsageReportService",
-                    "cloudTrailEventSource": "costandusagereportservice.amazonaws.com",
-                    "endpointPrefix": "cur"
-                },
-                "aws.auth#sigv4": {
-                    "name": "cur"
-                },
-                "aws.protocols#awsJson1_1": {},
-                "smithy.api#documentation": "<p>The AWS Cost and Usage Report API enables you to programmatically create, query, and delete \n        AWS Cost and Usage report definitions.</p>\n         <p>AWS Cost and Usage reports track the monthly AWS costs and usage \n   associated with your AWS account.\n    \n        The report contains line items for each unique combination of AWS product,\n        usage type, and operation that your AWS account uses. \n        \n        You can configure the AWS Cost and Usage report to show only the data that you want, using the\n        AWS Cost and Usage API.</p>\n\n         <p>Service Endpoint</p>\n         <p>The AWS Cost and Usage Report API provides the following endpoint:</p>\n         <ul>\n            <li>\n               <p>cur.us-east-1.amazonaws.com</p>\n            </li>\n         </ul>",
-                "smithy.api#title": "AWS Cost and Usage Report Service"
-            }
-        },
-        "com.amazonaws.costandusagereportservice#AWSRegion": {
-            "type": "string",
-            "traits": {
-                "smithy.api#documentation": "<p>The region of the S3 bucket that AWS delivers the report into.</p>",
-                "smithy.api#enum": [
-                    {
-                        "value": "af-south-1",
-                        "name": "CAPE_TOWN"
-                    },
-                    {
-                        "value": "ap-east-1",
-                        "name": "HONG_KONG"
-                    },
-                    {
-                        "value": "ap-south-1",
-                        "name": "MUMBAI"
-                    },
-                    {
-                        "value": "ap-southeast-1",
-                        "name": "SINGAPORE"
-                    },
-                    {
-                        "value": "ap-southeast-2",
-                        "name": "SYDNEY"
-                    },
-                    {
-                        "value": "ap-northeast-1",
-                        "name": "TOKYO"
-                    },
-                    {
-                        "value": "ap-northeast-2",
-                        "name": "SEOUL"
-                    },
-                    {
-                        "value": "ap-northeast-3",
-                        "name": "OSAKA"
-                    },
-                    {
-                        "value": "ca-central-1",
-                        "name": "CANADA_CENTRAL"
-                    },
-                    {
-                        "value": "eu-central-1",
-                        "name": "FRANKFURT"
-                    },
-                    {
-                        "value": "eu-west-1",
-                        "name": "IRELAND"
-                    },
-                    {
-                        "value": "eu-west-2",
-                        "name": "LONDON"
-                    },
-                    {
-                        "value": "eu-west-3",
-                        "name": "PARIS"
-                    },
-                    {
-                        "value": "eu-north-1",
-                        "name": "STOCKHOLM"
-                    },
-                    {
-                        "value": "eu-south-1",
-                        "name": "MILANO"
-                    },
-                    {
-                        "value": "me-south-1",
-                        "name": "BAHRAIN"
-                    },
-                    {
-                        "value": "sa-east-1",
-                        "name": "SAO_PAULO"
-                    },
-                    {
-                        "value": "us-east-1",
-                        "name": "US_STANDARD"
-                    },
-                    {
-                        "value": "us-east-2",
-                        "name": "OHIO"
-                    },
-                    {
-                        "value": "us-west-1",
-                        "name": "NORTHERN_CALIFORNIA"
-                    },
-                    {
-                        "value": "us-west-2",
-                        "name": "OREGON"
-                    },
-                    {
-                        "value": "cn-north-1",
-                        "name": "BEIJING"
-                    },
-                    {
-                        "value": "cn-northwest-1",
-                        "name": "NINGXIA"
-                    }
-                ]
-            }
-        },
-        "com.amazonaws.costandusagereportservice#AdditionalArtifact": {
-            "type": "string",
-            "traits": {
-                "smithy.api#documentation": "<p>The types of manifest that you want AWS to create for this report.</p>",
-                "smithy.api#enum": [
-                    {
-                        "value": "REDSHIFT",
-                        "name": "REDSHIFT"
-                    },
-                    {
-                        "value": "QUICKSIGHT",
-                        "name": "QUICKSIGHT"
-                    },
-                    {
-                        "value": "ATHENA",
-                        "name": "ATHENA"
-                    }
-                ]
-            }
-        },
-        "com.amazonaws.costandusagereportservice#AdditionalArtifactList": {
-            "type": "list",
-            "member": {
-                "target": "com.amazonaws.costandusagereportservice#AdditionalArtifact"
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>A list of additional artifacts.</p>"
-            }
-        },
-        "com.amazonaws.costandusagereportservice#BillingViewArn": {
-            "type": "string",
-            "traits": {
-                "smithy.api#length": {
-                    "min": 0,
-                    "max": 128
-                },
-                "smithy.api#pattern": "(arn:aws(-cn)?:billing::[0-9]{12}:billingview/)?[a-zA-Z0-9_\\+=\\.\\-@].{1,30}"
-            }
-        },
-        "com.amazonaws.costandusagereportservice#CompressionFormat": {
-            "type": "string",
-            "traits": {
-                "smithy.api#documentation": "<p>The compression format that AWS uses for the report.</p>",
-                "smithy.api#enum": [
-                    {
-                        "value": "ZIP",
-                        "name": "ZIP"
-                    },
-                    {
-                        "value": "GZIP",
-                        "name": "GZIP"
-                    },
-                    {
-                        "value": "Parquet",
-                        "name": "Parquet"
-                    }
-                ]
-            }
-        },
-        "com.amazonaws.costandusagereportservice#DeleteReportDefinition": {
-            "type": "operation",
-            "input": {
-                "target": "com.amazonaws.costandusagereportservice#DeleteReportDefinitionRequest"
-            },
-            "output": {
-                "target": "com.amazonaws.costandusagereportservice#DeleteReportDefinitionResponse"
-            },
-            "errors": [
-                {
-                    "target": "com.amazonaws.costandusagereportservice#InternalErrorException"
-                },
-                {
-                    "target": "com.amazonaws.costandusagereportservice#ValidationException"
-                }
-            ],
-            "traits": {
-                "smithy.api#documentation": "<p>Deletes the specified report.</p>"
-            }
-        },
-        "com.amazonaws.costandusagereportservice#DeleteReportDefinitionRequest": {
-            "type": "structure",
-            "members": {
-                "ReportName": {
-                    "target": "com.amazonaws.costandusagereportservice#ReportName",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The name of the report that you want to delete. The name must be unique, is case sensitive, and can't include spaces.</p>"
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>Deletes the specified report.</p>"
-            }
-        },
-        "com.amazonaws.costandusagereportservice#DeleteReportDefinitionResponse": {
-            "type": "structure",
-            "members": {
-                "ResponseMessage": {
-                    "target": "com.amazonaws.costandusagereportservice#DeleteResponseMessage"
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>If the action is successful, the service sends back an HTTP 200 response.</p>"
-            }
-        },
-        "com.amazonaws.costandusagereportservice#DeleteResponseMessage": {
-            "type": "string",
-            "traits": {
-                "smithy.api#documentation": "<p>Whether the deletion was successful or not.</p>"
-            }
-        },
-        "com.amazonaws.costandusagereportservice#DescribeReportDefinitions": {
-            "type": "operation",
-            "input": {
-                "target": "com.amazonaws.costandusagereportservice#DescribeReportDefinitionsRequest"
-            },
-            "output": {
-                "target": "com.amazonaws.costandusagereportservice#DescribeReportDefinitionsResponse"
-            },
-            "errors": [
-                {
-                    "target": "com.amazonaws.costandusagereportservice#InternalErrorException"
-                }
-            ],
-            "traits": {
-                "smithy.api#documentation": "<p>Lists the AWS Cost and Usage reports available to this account.</p>",
-                "smithy.api#paginated": {
-                    "inputToken": "NextToken",
-                    "outputToken": "NextToken",
-                    "pageSize": "MaxResults"
-                }
-            }
-        },
-        "com.amazonaws.costandusagereportservice#DescribeReportDefinitionsRequest": {
-            "type": "structure",
-            "members": {
-                "MaxResults": {
-                    "target": "com.amazonaws.costandusagereportservice#MaxResults"
-                },
-                "NextToken": {
-                    "target": "com.amazonaws.costandusagereportservice#GenericString"
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>Requests a list of AWS Cost and Usage reports owned by the account.</p>"
-            }
-        },
-        "com.amazonaws.costandusagereportservice#DescribeReportDefinitionsResponse": {
-            "type": "structure",
-            "members": {
-                "ReportDefinitions": {
-                    "target": "com.amazonaws.costandusagereportservice#ReportDefinitionList",
-                    "traits": {
-                        "smithy.api#documentation": "<p>A list of AWS Cost and Usage reports owned by the account.</p>"
-                    }
-                },
-                "NextToken": {
-                    "target": "com.amazonaws.costandusagereportservice#GenericString"
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>If the action is successful, the service sends back an HTTP 200 response.</p>"
-            }
-        },
-        "com.amazonaws.costandusagereportservice#DuplicateReportNameException": {
-            "type": "structure",
-            "members": {
-                "Message": {
-                    "target": "com.amazonaws.costandusagereportservice#ErrorMessage"
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>A report with the specified name already exists in the account. Specify a different report name.</p>",
-                "smithy.api#error": "client"
-            }
-        },
-        "com.amazonaws.costandusagereportservice#ErrorMessage": {
-            "type": "string",
-            "traits": {
-                "smithy.api#documentation": "<p>A message to show the detail of the exception.</p>"
-            }
-        },
-        "com.amazonaws.costandusagereportservice#GenericString": {
-            "type": "string",
-            "traits": {
-                "smithy.api#documentation": "<p>A generic string.</p>",
-                "smithy.api#length": {
-                    "min": 0,
-                    "max": 256
-                },
-                "smithy.api#pattern": "[A-Za-z0-9_\\.\\-=]*"
-            }
-        },
-        "com.amazonaws.costandusagereportservice#InternalErrorException": {
-            "type": "structure",
-            "members": {
-                "Message": {
-                    "target": "com.amazonaws.costandusagereportservice#ErrorMessage"
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>An error on the server occurred during the processing of your request. Try again later.</p>",
-                "smithy.api#error": "server"
-            }
-        },
-        "com.amazonaws.costandusagereportservice#MaxResults": {
-            "type": "integer",
-            "traits": {
-                "smithy.api#box": {},
-                "smithy.api#documentation": "<p>The maximum number of results that AWS returns for the operation.</p>",
-                "smithy.api#range": {
-                    "min": 5,
-                    "max": 5
-                }
-            }
-        },
-        "com.amazonaws.costandusagereportservice#ModifyReportDefinition": {
-            "type": "operation",
-            "input": {
-                "target": "com.amazonaws.costandusagereportservice#ModifyReportDefinitionRequest"
-            },
-            "output": {
-                "target": "com.amazonaws.costandusagereportservice#ModifyReportDefinitionResponse"
-            },
-            "errors": [
-                {
-                    "target": "com.amazonaws.costandusagereportservice#InternalErrorException"
-                },
-                {
-                    "target": "com.amazonaws.costandusagereportservice#ValidationException"
-                }
-            ],
-            "traits": {
-                "smithy.api#documentation": "<p>Allows you to programatically update your report preferences.</p>"
-            }
-        },
-        "com.amazonaws.costandusagereportservice#ModifyReportDefinitionRequest": {
-            "type": "structure",
-            "members": {
-                "ReportName": {
-                    "target": "com.amazonaws.costandusagereportservice#ReportName",
-                    "traits": {
-                        "smithy.api#required": {}
-                    }
-                },
-                "ReportDefinition": {
-                    "target": "com.amazonaws.costandusagereportservice#ReportDefinition",
-                    "traits": {
-                        "smithy.api#required": {}
-                    }
-                }
-            }
-        },
-        "com.amazonaws.costandusagereportservice#ModifyReportDefinitionResponse": {
-            "type": "structure",
-            "members": {}
-        },
-        "com.amazonaws.costandusagereportservice#PutReportDefinition": {
-            "type": "operation",
-            "input": {
-                "target": "com.amazonaws.costandusagereportservice#PutReportDefinitionRequest"
-            },
-            "output": {
-                "target": "com.amazonaws.costandusagereportservice#PutReportDefinitionResponse"
-            },
-            "errors": [
-                {
-                    "target": "com.amazonaws.costandusagereportservice#DuplicateReportNameException"
-                },
-                {
-                    "target": "com.amazonaws.costandusagereportservice#InternalErrorException"
-                },
-                {
-                    "target": "com.amazonaws.costandusagereportservice#ReportLimitReachedException"
-                },
-                {
-                    "target": "com.amazonaws.costandusagereportservice#ValidationException"
-                }
-            ],
-            "traits": {
-                "smithy.api#documentation": "<p>Creates a new report using the description that you provide.</p>"
-            }
-        },
-        "com.amazonaws.costandusagereportservice#PutReportDefinitionRequest": {
-            "type": "structure",
-            "members": {
-                "ReportDefinition": {
-                    "target": "com.amazonaws.costandusagereportservice#ReportDefinition",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Represents the output of the PutReportDefinition operation. The content consists of the detailed \n      metadata and data file information. </p>",
-                        "smithy.api#required": {}
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>Creates a Cost and Usage Report.</p>"
-            }
-        },
-        "com.amazonaws.costandusagereportservice#PutReportDefinitionResponse": {
-            "type": "structure",
-            "members": {},
-            "traits": {
-                "smithy.api#documentation": "<p>If the action is successful, the service sends back an HTTP 200 response with an empty HTTP body.</p>"
-            }
-        },
-        "com.amazonaws.costandusagereportservice#RefreshClosedReports": {
-            "type": "boolean",
-            "traits": {
-                "smithy.api#box": {}
-            }
-        },
-        "com.amazonaws.costandusagereportservice#ReportDefinition": {
-            "type": "structure",
-            "members": {
-                "ReportName": {
-                    "target": "com.amazonaws.costandusagereportservice#ReportName",
-                    "traits": {
-                        "smithy.api#required": {}
-                    }
-                },
-                "TimeUnit": {
-                    "target": "com.amazonaws.costandusagereportservice#TimeUnit",
-                    "traits": {
-                        "smithy.api#required": {}
-                    }
-                },
-                "Format": {
-                    "target": "com.amazonaws.costandusagereportservice#ReportFormat",
-                    "traits": {
-                        "smithy.api#required": {}
-                    }
-                },
-                "Compression": {
-                    "target": "com.amazonaws.costandusagereportservice#CompressionFormat",
-                    "traits": {
-                        "smithy.api#required": {}
-                    }
-                },
-                "AdditionalSchemaElements": {
-                    "target": "com.amazonaws.costandusagereportservice#SchemaElementList",
-                    "traits": {
-                        "smithy.api#documentation": "<p>A list of strings that indicate additional content that Amazon Web Services includes in the report, such as individual resource IDs. </p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "S3Bucket": {
-                    "target": "com.amazonaws.costandusagereportservice#S3Bucket",
-                    "traits": {
-                        "smithy.api#required": {}
-                    }
-                },
-                "S3Prefix": {
-                    "target": "com.amazonaws.costandusagereportservice#S3Prefix",
-                    "traits": {
-                        "smithy.api#required": {}
-                    }
-                },
-                "S3Region": {
-                    "target": "com.amazonaws.costandusagereportservice#AWSRegion",
-                    "traits": {
-                        "smithy.api#required": {}
-                    }
-                },
-                "AdditionalArtifacts": {
-                    "target": "com.amazonaws.costandusagereportservice#AdditionalArtifactList",
-                    "traits": {
-                        "smithy.api#documentation": "<p>A list of manifests that you want Amazon Web Services to create for this report.</p>"
-                    }
-                },
-                "RefreshClosedReports": {
-                    "target": "com.amazonaws.costandusagereportservice#RefreshClosedReports",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Whether you want Amazon Web Services to update your reports after they have been finalized if Amazon Web Services detects charges related to \n      previous months. These charges can include refunds, credits, or support fees.</p>"
-                    }
-                },
-                "ReportVersioning": {
-                    "target": "com.amazonaws.costandusagereportservice#ReportVersioning",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Whether you want Amazon Web Services to overwrite the previous version of each report or \n         to deliver the report in addition to the previous versions.</p>"
-                    }
-                },
-                "BillingViewArn": {
-                    "target": "com.amazonaws.costandusagereportservice#BillingViewArn",
-                    "traits": {
-                        "smithy.api#documentation": "<p>\n      The Amazon resource name of the billing view. You can get this value by using the billing view service public APIs.\n    </p>"
-                    }
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>The definition of AWS Cost and Usage Report. You can specify the report name, \n         time unit, report format, compression format, S3 bucket, additional artifacts, and schema \n         elements in the definition.\n    </p>"
-            }
-        },
-        "com.amazonaws.costandusagereportservice#ReportDefinitionList": {
-            "type": "list",
-            "member": {
-                "target": "com.amazonaws.costandusagereportservice#ReportDefinition"
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>A list of report definitions.</p>"
-            }
-        },
-        "com.amazonaws.costandusagereportservice#ReportFormat": {
-            "type": "string",
-            "traits": {
-                "smithy.api#documentation": "<p>The format that AWS saves the report in.</p>",
-                "smithy.api#enum": [
-                    {
-                        "value": "textORcsv",
-                        "name": "CSV"
-                    },
-                    {
-                        "value": "Parquet",
-                        "name": "Parquet"
-                    }
-                ]
-            }
-        },
-        "com.amazonaws.costandusagereportservice#ReportLimitReachedException": {
-            "type": "structure",
-            "members": {
-                "Message": {
-                    "target": "com.amazonaws.costandusagereportservice#ErrorMessage"
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>This account already has five reports defined. To define a new report, you must delete an existing report.</p>",
-                "smithy.api#error": "client"
-            }
-        },
-        "com.amazonaws.costandusagereportservice#ReportName": {
-            "type": "string",
-            "traits": {
-                "smithy.api#documentation": "<p>The name of the report that you want to create. The name must be unique,\n        is case sensitive, and can't include spaces. </p>",
-                "smithy.api#length": {
-                    "min": 0,
-                    "max": 256
-                },
-                "smithy.api#pattern": "[0-9A-Za-z!\\-_.*\\'()]+"
-            }
-        },
-        "com.amazonaws.costandusagereportservice#ReportVersioning": {
-            "type": "string",
-            "traits": {
-                "smithy.api#enum": [
-                    {
-                        "value": "CREATE_NEW_REPORT",
-                        "name": "CREATE_NEW_REPORT"
-                    },
-                    {
-                        "value": "OVERWRITE_REPORT",
-                        "name": "OVERWRITE_REPORT"
-                    }
-                ]
-            }
-        },
-        "com.amazonaws.costandusagereportservice#S3Bucket": {
-            "type": "string",
-            "traits": {
-                "smithy.api#documentation": "<p>The S3 bucket where AWS delivers the report.</p>",
-                "smithy.api#length": {
-                    "min": 0,
-                    "max": 256
-                },
-                "smithy.api#pattern": "[A-Za-z0-9_\\.\\-]+"
-            }
-        },
-        "com.amazonaws.costandusagereportservice#S3Prefix": {
-            "type": "string",
-            "traits": {
-                "smithy.api#documentation": "<p>The prefix that AWS adds to the report name when AWS delivers the report. Your prefix\n        can't include spaces.</p>",
-                "smithy.api#length": {
-                    "min": 0,
-                    "max": 256
-                },
-                "smithy.api#pattern": "[0-9A-Za-z!\\-_.*\\'()/]*"
-            }
-        },
-        "com.amazonaws.costandusagereportservice#SchemaElement": {
-            "type": "string",
-            "traits": {
-                "smithy.api#documentation": "<p>Whether or not AWS includes resource IDs in the report. </p>",
-                "smithy.api#enum": [
-                    {
-                        "value": "RESOURCES",
-                        "name": "RESOURCES"
-                    }
-                ]
-            }
-        },
-        "com.amazonaws.costandusagereportservice#SchemaElementList": {
-            "type": "list",
-            "member": {
-                "target": "com.amazonaws.costandusagereportservice#SchemaElement"
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>A list of strings that indicate the content that is included in the report, such as service or usage type.</p>"
-            }
-        },
-        "com.amazonaws.costandusagereportservice#TimeUnit": {
-            "type": "string",
-            "traits": {
-                "smithy.api#documentation": "<p>The length of time covered by the report. </p>",
-                "smithy.api#enum": [
-                    {
-                        "value": "HOURLY",
-                        "name": "HOURLY"
-                    },
-                    {
-                        "value": "DAILY",
-                        "name": "DAILY"
-                    },
-                    {
-                        "value": "MONTHLY",
-                        "name": "MONTHLY"
-                    }
-                ]
-            }
-        },
-        "com.amazonaws.costandusagereportservice#ValidationException": {
-            "type": "structure",
-            "members": {
-                "Message": {
-                    "target": "com.amazonaws.costandusagereportservice#ErrorMessage"
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>The input fails to satisfy the constraints specified by an AWS service.</p>",
-                "smithy.api#error": "client"
-            }
-        }
-    }
-}

codegen/models/ec2instanceconnect.2018-04-02.json

@@ -1,396 +0,0 @@
-{
-    "smithy": "1.0",
-    "metadata": {
-        "suppressions": [
-            {
-                "id": "HttpMethodSemantics",
-                "namespace": "*"
-            },
-            {
-                "id": "HttpResponseCodeSemantics",
-                "namespace": "*"
-            },
-            {
-                "id": "PaginatedTrait",
-                "namespace": "*"
-            },
-            {
-                "id": "HttpHeaderTrait",
-                "namespace": "*"
-            },
-            {
-                "id": "HttpUriConflict",
-                "namespace": "*"
-            },
-            {
-                "id": "Service",
-                "namespace": "*"
-            }
-        ]
-    },
-    "shapes": {
-        "com.amazonaws.ec2instanceconnect#AWSEC2InstanceConnectService": {
-            "type": "service",
-            "version": "2018-04-02",
-            "operations": [
-                {
-                    "target": "com.amazonaws.ec2instanceconnect#SendSerialConsoleSSHPublicKey"
-                },
-                {
-                    "target": "com.amazonaws.ec2instanceconnect#SendSSHPublicKey"
-                }
-            ],
-            "traits": {
-                "aws.api#service": {
-                    "sdkId": "EC2 Instance Connect",
-                    "arnNamespace": "ec2-instance-connect",
-                    "cloudFormationName": "EC2InstanceConnect",
-                    "cloudTrailEventSource": "ec2instanceconnect.amazonaws.com",
-                    "endpointPrefix": "ec2-instance-connect"
-                },
-                "aws.auth#sigv4": {
-                    "name": "ec2-instance-connect"
-                },
-                "aws.protocols#awsJson1_1": {},
-                "smithy.api#documentation": "<p>Amazon EC2 Instance Connect enables system administrators to publish one-time use SSH\n            public keys to EC2, providing users a simple and secure way to connect to their\n            instances.</p>",
-                "smithy.api#title": "AWS EC2 Instance Connect"
-            }
-        },
-        "com.amazonaws.ec2instanceconnect#AuthException": {
-            "type": "structure",
-            "members": {
-                "Message": {
-                    "target": "com.amazonaws.ec2instanceconnect#String"
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>Either your AWS credentials are not valid or you do not have access to the EC2 instance.</p>",
-                "smithy.api#error": "client",
-                "smithy.api#httpError": 403
-            }
-        },
-        "com.amazonaws.ec2instanceconnect#AvailabilityZone": {
-            "type": "string",
-            "traits": {
-                "smithy.api#length": {
-                    "min": 6,
-                    "max": 32
-                },
-                "smithy.api#pattern": "^(\\w+-){2,3}\\d+\\w+$"
-            }
-        },
-        "com.amazonaws.ec2instanceconnect#EC2InstanceNotFoundException": {
-            "type": "structure",
-            "members": {
-                "Message": {
-                    "target": "com.amazonaws.ec2instanceconnect#String"
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>The specified instance was not found.</p>",
-                "smithy.api#error": "client",
-                "smithy.api#httpError": 404
-            }
-        },
-        "com.amazonaws.ec2instanceconnect#EC2InstanceTypeInvalidException": {
-            "type": "structure",
-            "members": {
-                "Message": {
-                    "target": "com.amazonaws.ec2instanceconnect#String"
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>The instance type is not supported for connecting via the serial console. Only Nitro\n            instance types are currently supported.</p>",
-                "smithy.api#error": "client",
-                "smithy.api#httpError": 400
-            }
-        },
-        "com.amazonaws.ec2instanceconnect#InstanceId": {
-            "type": "string",
-            "traits": {
-                "smithy.api#length": {
-                    "min": 10,
-                    "max": 32
-                },
-                "smithy.api#pattern": "^i-[a-f0-9]+$"
-            }
-        },
-        "com.amazonaws.ec2instanceconnect#InstanceOSUser": {
-            "type": "string",
-            "traits": {
-                "smithy.api#length": {
-                    "min": 1,
-                    "max": 32
-                },
-                "smithy.api#pattern": "^[A-Za-z_][A-Za-z0-9\\@\\._-]{0,30}[A-Za-z0-9\\$_-]?$"
-            }
-        },
-        "com.amazonaws.ec2instanceconnect#InvalidArgsException": {
-            "type": "structure",
-            "members": {
-                "Message": {
-                    "target": "com.amazonaws.ec2instanceconnect#String"
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>One of the parameters is not valid.</p>",
-                "smithy.api#error": "client",
-                "smithy.api#httpError": 400
-            }
-        },
-        "com.amazonaws.ec2instanceconnect#RequestId": {
-            "type": "string"
-        },
-        "com.amazonaws.ec2instanceconnect#SSHPublicKey": {
-            "type": "string",
-            "traits": {
-                "smithy.api#length": {
-                    "min": 256,
-                    "max": 4096
-                }
-            }
-        },
-        "com.amazonaws.ec2instanceconnect#SendSSHPublicKey": {
-            "type": "operation",
-            "input": {
-                "target": "com.amazonaws.ec2instanceconnect#SendSSHPublicKeyRequest"
-            },
-            "output": {
-                "target": "com.amazonaws.ec2instanceconnect#SendSSHPublicKeyResponse"
-            },
-            "errors": [
-                {
-                    "target": "com.amazonaws.ec2instanceconnect#AuthException"
-                },
-                {
-                    "target": "com.amazonaws.ec2instanceconnect#EC2InstanceNotFoundException"
-                },
-                {
-                    "target": "com.amazonaws.ec2instanceconnect#InvalidArgsException"
-                },
-                {
-                    "target": "com.amazonaws.ec2instanceconnect#ServiceException"
-                },
-                {
-                    "target": "com.amazonaws.ec2instanceconnect#ThrottlingException"
-                }
-            ],
-            "traits": {
-                "smithy.api#documentation": "<p>Pushes an SSH public key to the specified EC2 instance for use by the specified user.\n            The key remains for 60 seconds. For more information, see <a href=\"https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Connect-using-EC2-Instance-Connect.html\">Connect to\n                your Linux instance using EC2 Instance Connect</a> in the <i>Amazon EC2\n                User Guide</i>.</p>"
-            }
-        },
-        "com.amazonaws.ec2instanceconnect#SendSSHPublicKeyRequest": {
-            "type": "structure",
-            "members": {
-                "InstanceId": {
-                    "target": "com.amazonaws.ec2instanceconnect#InstanceId",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The ID of the EC2 instance.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "InstanceOSUser": {
-                    "target": "com.amazonaws.ec2instanceconnect#InstanceOSUser",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The OS user on the EC2 instance for whom the key can be used to authenticate.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "SSHPublicKey": {
-                    "target": "com.amazonaws.ec2instanceconnect#SSHPublicKey",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The public key material. To use the public key, you must have the matching private key.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "AvailabilityZone": {
-                    "target": "com.amazonaws.ec2instanceconnect#AvailabilityZone",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The Availability Zone in which the EC2 instance was launched.</p>",
-                        "smithy.api#required": {}
-                    }
-                }
-            }
-        },
-        "com.amazonaws.ec2instanceconnect#SendSSHPublicKeyResponse": {
-            "type": "structure",
-            "members": {
-                "RequestId": {
-                    "target": "com.amazonaws.ec2instanceconnect#RequestId",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The ID of the request. Please provide this ID when contacting AWS Support for assistance.</p>"
-                    }
-                },
-                "Success": {
-                    "target": "com.amazonaws.ec2instanceconnect#Success",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Is true if the request succeeds and an error otherwise.</p>"
-                    }
-                }
-            }
-        },
-        "com.amazonaws.ec2instanceconnect#SendSerialConsoleSSHPublicKey": {
-            "type": "operation",
-            "input": {
-                "target": "com.amazonaws.ec2instanceconnect#SendSerialConsoleSSHPublicKeyRequest"
-            },
-            "output": {
-                "target": "com.amazonaws.ec2instanceconnect#SendSerialConsoleSSHPublicKeyResponse"
-            },
-            "errors": [
-                {
-                    "target": "com.amazonaws.ec2instanceconnect#AuthException"
-                },
-                {
-                    "target": "com.amazonaws.ec2instanceconnect#EC2InstanceNotFoundException"
-                },
-                {
-                    "target": "com.amazonaws.ec2instanceconnect#EC2InstanceTypeInvalidException"
-                },
-                {
-                    "target": "com.amazonaws.ec2instanceconnect#InvalidArgsException"
-                },
-                {
-                    "target": "com.amazonaws.ec2instanceconnect#SerialConsoleAccessDisabledException"
-                },
-                {
-                    "target": "com.amazonaws.ec2instanceconnect#SerialConsoleSessionLimitExceededException"
-                },
-                {
-                    "target": "com.amazonaws.ec2instanceconnect#SerialConsoleSessionUnavailableException"
-                },
-                {
-                    "target": "com.amazonaws.ec2instanceconnect#ServiceException"
-                },
-                {
-                    "target": "com.amazonaws.ec2instanceconnect#ThrottlingException"
-                }
-            ],
-            "traits": {
-                "smithy.api#documentation": "<p>Pushes an SSH public key to the specified EC2 instance. The key remains for 60\n            seconds, which gives you 60 seconds to establish a serial console connection to the\n            instance using SSH. For more information, see <a href=\"https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-serial-console.html\">EC2 Serial Console</a> in\n            the <i>Amazon EC2 User Guide</i>.</p>"
-            }
-        },
-        "com.amazonaws.ec2instanceconnect#SendSerialConsoleSSHPublicKeyRequest": {
-            "type": "structure",
-            "members": {
-                "InstanceId": {
-                    "target": "com.amazonaws.ec2instanceconnect#InstanceId",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The ID of the EC2 instance.</p>",
-                        "smithy.api#required": {}
-                    }
-                },
-                "SerialPort": {
-                    "target": "com.amazonaws.ec2instanceconnect#SerialPort",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The serial port of the EC2 instance. Currently only port 0 is supported.</p>\n        <p>Default: 0</p>"
-                    }
-                },
-                "SSHPublicKey": {
-                    "target": "com.amazonaws.ec2instanceconnect#SSHPublicKey",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The public key material. To use the public key, you must have the matching private\n            key. For information about the supported key formats and lengths, see <a href=\"https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html#how-to-generate-your-own-key-and-import-it-to-aws\">Requirements for key pairs</a> in the <i>Amazon EC2 User\n            Guide</i>.</p>",
-                        "smithy.api#required": {}
-                    }
-                }
-            }
-        },
-        "com.amazonaws.ec2instanceconnect#SendSerialConsoleSSHPublicKeyResponse": {
-            "type": "structure",
-            "members": {
-                "RequestId": {
-                    "target": "com.amazonaws.ec2instanceconnect#RequestId",
-                    "traits": {
-                        "smithy.api#documentation": "<p>The ID of the request. Please provide this ID when contacting AWS Support for assistance.</p>"
-                    }
-                },
-                "Success": {
-                    "target": "com.amazonaws.ec2instanceconnect#Success",
-                    "traits": {
-                        "smithy.api#documentation": "<p>Is true if the request succeeds and an error otherwise.</p>"
-                    }
-                }
-            }
-        },
-        "com.amazonaws.ec2instanceconnect#SerialConsoleAccessDisabledException": {
-            "type": "structure",
-            "members": {
-                "Message": {
-                    "target": "com.amazonaws.ec2instanceconnect#String"
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>Your account is not authorized to use the EC2 Serial Console. To authorize your\n            account, run the EnableSerialConsoleAccess API. For more information, see\n            <a href=\"https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_EnableSerialConsoleAccess.html\">EnableSerialConsoleAccess</a> in the <i>Amazon EC2 API Reference</i>.</p>",
-                "smithy.api#error": "client",
-                "smithy.api#httpError": 403
-            }
-        },
-        "com.amazonaws.ec2instanceconnect#SerialConsoleSessionLimitExceededException": {
-            "type": "structure",
-            "members": {
-                "Message": {
-                    "target": "com.amazonaws.ec2instanceconnect#String"
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>The instance currently has 1 active serial console session. Only 1 session is supported at a time.</p>",
-                "smithy.api#error": "client",
-                "smithy.api#httpError": 400
-            }
-        },
-        "com.amazonaws.ec2instanceconnect#SerialConsoleSessionUnavailableException": {
-            "type": "structure",
-            "members": {
-                "Message": {
-                    "target": "com.amazonaws.ec2instanceconnect#String"
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>Unable to start a serial console session. Please try again.</p>",
-                "smithy.api#error": "server",
-                "smithy.api#httpError": 500
-            }
-        },
-        "com.amazonaws.ec2instanceconnect#SerialPort": {
-            "type": "integer",
-            "traits": {
-                "smithy.api#range": {
-                    "min": 0,
-                    "max": 0
-                }
-            }
-        },
-        "com.amazonaws.ec2instanceconnect#ServiceException": {
-            "type": "structure",
-            "members": {
-                "Message": {
-                    "target": "com.amazonaws.ec2instanceconnect#String"
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>The service encountered an error. Follow the instructions in the error message and try again.</p>",
-                "smithy.api#error": "server",
-                "smithy.api#httpError": 500
-            }
-        },
-        "com.amazonaws.ec2instanceconnect#String": {
-            "type": "string"
-        },
-        "com.amazonaws.ec2instanceconnect#Success": {
-            "type": "boolean"
-        },
-        "com.amazonaws.ec2instanceconnect#ThrottlingException": {
-            "type": "structure",
-            "members": {
-                "Message": {
-                    "target": "com.amazonaws.ec2instanceconnect#String"
-                }
-            },
-            "traits": {
-                "smithy.api#documentation": "<p>The requests were made too frequently and have been throttled. Wait a while and try again. \n            To increase the limit on your request frequency, contact AWS Support.</p>",
-                "smithy.api#error": "client",
-                "smithy.api#httpError": 429
-            }
-        }
-    }
-}