From 0a3b997fd0cb5dabb0c1b7020e2476519886ba34 Mon Sep 17 00:00:00 2001 From: koki nishi <120067169+NenfuAT@users.noreply.github.com> Date: Wed, 28 Oct 2026 00:52:01 +0900 Subject: [PATCH 1/2] Send bearer auth to ECR Public registry requests ECR Public answers Basic auth on registry API requests with a 400 ("Your Authorization Token is invalid") instead of a 401 challenge, so TokenTransport never starts the token flow and requests to public.ecr.aws fail, or fall back to anonymous pulls and hit rate limits. Per the ECR Public HTTP API docs, registry requests take the GetAuthorizationToken token, base64("AWS:"), as a bearer token. For public.ecr.aws /v2 requests, build that token from the configured username and password (as returned by `aws ecr-public get-login-password`) and set it directly. Other paths such as /token keep the existing Basic token flow. Fixes #157 --- internal/handlers/docker_registry.go | 15 ++++ internal/handlers/docker_registry_test.go | 88 +++++++++++++++++++++++ 2 files changed, 103 insertions(+) diff --git a/internal/handlers/docker_registry.go b/internal/handlers/docker_registry.go index 67d0de1..64577f8 100644 --- a/internal/handlers/docker_registry.go +++ b/internal/handlers/docker_registry.go @@ -25,6 +25,8 @@ var ( ecrRe = regexp.MustCompile(`\A\d+.dkr.ecr.([a-z0-9-]+)\.amazonaws\.com\z`) ) +const ecrPublicHost = "public.ecr.aws" + type ecrClient interface { GetAuthorizationToken(ctx context.Context, input *ecr.GetAuthorizationTokenInput, optFns ...func(*ecr.Options)) (*ecr.GetAuthorizationTokenOutput, error) } @@ -242,6 +244,19 @@ func (h *DockerRegistryHandler) authenticateWithCredential( return } + // ECR Public rejects Basic auth on registry requests with a 400 instead of + // a 401 challenge, so the token flow below would never start. Its HTTP API + // takes the GetAuthorizationToken token, base64("AWS:"), as a + // bearer token, so send that directly. Other paths, such as /token, still + // accept Basic auth and keep the token flow below. + if _, ok := helpers.MatchingPathPrefix(req.URL.EscapedPath(), "/v2"); ok && + helpers.AreHostnamesEqual(req.URL.Hostname(), ecrPublicHost) { + logging.RequestLogf(proxyCtx, "* authenticating docker ecr public request (host: %s)", req.URL.Hostname()) + token := base64.StdEncoding.EncodeToString([]byte(cred.getUsername() + ":" + cred.getPassword())) + helpers.SetBearerAuthorization(req, token) + return + } + logging.RequestLogf(proxyCtx, "* authenticating docker registry request (host: %s)", req.URL.Hostname()) transport := ®istry.BasicTransport{ Transport: ®istry.TokenTransport{ diff --git a/internal/handlers/docker_registry_test.go b/internal/handlers/docker_registry_test.go index 0efabe2..2f5424f 100644 --- a/internal/handlers/docker_registry_test.go +++ b/internal/handlers/docker_registry_test.go @@ -33,6 +33,7 @@ func TestDockerRegistryHandler(t *testing.T) { ecrSecretKey := "BigLongAWSSecretKey" ecrDockerUser := "AWS" ecrDockerPassword := "BigLongGeneratedRegistryPassword" + ecrPublicToken := "BigLongGeneratedPublicRegistryPassword" credentials := config.Credentials{ config.Credential{ "type": "docker_registry", @@ -52,6 +53,12 @@ func TestDockerRegistryHandler(t *testing.T) { "username": ecrKeyID, "password": ecrSecretKey, }, + config.Credential{ + "type": "docker_registry", + "registry": "public.ecr.aws", + "username": ecrDockerUser, + "password": ecrPublicToken, + }, config.Credential{ "type": "docker_registry", "registry": "nexus.someco.com", @@ -159,6 +166,13 @@ func TestDockerRegistryHandler(t *testing.T) { assert.False(t, ok, "ecr request isn't assigned a docker registry transport") assertUnauthenticated(t, req, "leaked ecr credentials") + // ECR Public + req = httptest.NewRequestWithContext(t.Context(), "GET", "https://public.ecr.aws/v2/docker/library/alpine/manifests/latest", nil) + proxyCtx = &goproxy.ProxyCtx{} + req = handleRequestAndClose(handler, req, proxyCtx) + assert.Nil(t, proxyCtx.RoundTripper, "ecr public request isn't assigned a docker registry transport") + assertHasTokenAuth(t, req, "Bearer", base64.StdEncoding.EncodeToString([]byte(ecrDockerUser+":"+ecrPublicToken)), "has ecr public bearer token") + // Missing repo subdomain req = httptest.NewRequestWithContext(t.Context(), "GET", "https://bigco.com/v2/their-repo/manifests/latest", nil) proxyCtx = &goproxy.ProxyCtx{} @@ -492,6 +506,80 @@ func TestDockerRegistryHandlerPathScopedCredentialFallsBackToHost(t *testing.T) } } +func TestDockerRegistryHandlerECRPublic(t *testing.T) { + client := &http.Client{Transport: &recordingECRTransport{}, Timeout: testOIDCClient.Timeout} + bearer := base64.StdEncoding.EncodeToString([]byte("AWS:public-password")) + + tests := []struct { + name string + credential config.Credential + requestURL string + authorization string + // bearer is the expected bearer token; empty means the request keeps + // the Basic token flow transport. + bearer string + }{ + { + name: "registry API", + credential: config.Credential{"registry": "public.ecr.aws"}, + requestURL: "https://public.ecr.aws/v2/docker/library/alpine/manifests/latest", + bearer: bearer, + }, + { + name: "path scoped credential", + credential: config.Credential{"registry": "public.ecr.aws/my-alias"}, + requestURL: "https://public.ecr.aws/v2/my-alias/app/manifests/latest", + bearer: bearer, + }, + { + name: "proxy-only credential", + credential: config.Credential{"registry": "public.ecr.aws", "proxy-only": true}, + requestURL: "https://public.ecr.aws/v2/docker/library/alpine/manifests/latest", + bearer: bearer, + }, + { + name: "client authorization is kept", + credential: config.Credential{"registry": "public.ecr.aws"}, + requestURL: "https://public.ecr.aws/v2/docker/library/alpine/manifests/latest", + authorization: "Bearer client-token", + bearer: "client-token", + }, + { + name: "token endpoint", + credential: config.Credential{"registry": "public.ecr.aws"}, + requestURL: "https://public.ecr.aws/token/?service=public.ecr.aws&scope=repository:docker/library/alpine:pull", + }, + } + + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + cred := config.Credential{"type": "docker_registry", "username": "AWS", "password": "public-password"} + for key, value := range test.credential { + cred[key] = value + } + handler := NewDockerRegistryHandler(config.Credentials{cred}, client, nil) + + req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, test.requestURL, nil) + if test.authorization != "" { + req.Header.Set("Authorization", test.authorization) + } + proxyCtx := &goproxy.ProxyCtx{} + req = handleRequestAndClose(handler, req, proxyCtx) + + if test.bearer != "" { + assert.Nil(t, proxyCtx.RoundTripper, "no docker registry transport") + assertHasTokenAuth(t, req, "Bearer", test.bearer, "has ecr public bearer token") + return + } + rt, ok := proxyCtx.RoundTripper.(*dockerRegistryRoundTripper) + require.True(t, ok, "request is assigned a docker registry transport") + transport := rt.transport.(*registry.BasicTransport) + assert.Equal(t, "AWS", transport.Username) + assert.Equal(t, "public-password", transport.Password) + }) + } +} + func TestDockerRegistryHandlerPathScopedOIDCCredentialFallsBackToHost(t *testing.T) { const tokenURL = "https://token.actions.example.com" //nolint:gosec // test URL const jfrogTokenURL = "https://jfrog.example.com/access/api/v1/oidc/token" //nolint:gosec // test URL From 4f11a19fa4a48a3b68a13727f10e4c9a9d8d807d Mon Sep 17 00:00:00 2001 From: koki nishi <120067169+NenfuAT@users.noreply.github.com> Date: Wed, 28 Oct 2026 00:53:43 +0900 Subject: [PATCH 2/2] Fetch ECR Public tokens for AWS access key credentials docker_registry credentials for public.ecr.aws with a username other than AWS are now treated as an AWS access key pair, as for private ECR. The proxy exchanges them for a token with ecr-public:GetAuthorizationToken in us-east-1, so the token no longer has to be rotated by hand every 12 hours. If the exchange fails, the request is sent anonymously rather than with the secret key. getECRCredentials now checks for a private ECR host before returning a cached token, so an ECR Public token is never sent as private ECR Basic auth. Adds github.com/aws/aws-sdk-go-v2/service/ecrpublic v1.47.0, matching the vendored aws-sdk-go-v2 core version. --- go.mod | 1 + go.sum | 2 + internal/handlers/docker_registry.go | 110 +- internal/handlers/docker_registry_test.go | 88 + .../service/ecrpublic/CHANGELOG.md | 855 +++++++++ .../service/ecrpublic/LICENSE.txt | 202 ++ .../service/ecrpublic/api_client.go | 1018 ++++++++++ .../api_op_BatchCheckLayerAvailability.go | 147 ++ .../ecrpublic/api_op_BatchDeleteImage.go | 148 ++ .../ecrpublic/api_op_CompleteLayerUpload.go | 180 ++ .../ecrpublic/api_op_CreateRepository.go | 158 ++ .../ecrpublic/api_op_DeleteRepository.go | 142 ++ .../api_op_DeleteRepositoryPolicy.go | 148 ++ .../ecrpublic/api_op_DescribeImageTags.go | 263 +++ .../ecrpublic/api_op_DescribeImages.go | 273 +++ .../ecrpublic/api_op_DescribeRegistries.go | 250 +++ .../ecrpublic/api_op_DescribeRepositories.go | 264 +++ .../ecrpublic/api_op_GetAuthorizationToken.go | 116 ++ .../api_op_GetRegistryCatalogData.go | 114 ++ .../api_op_GetRepositoryCatalogData.go | 133 ++ .../ecrpublic/api_op_GetRepositoryPolicy.go | 148 ++ .../ecrpublic/api_op_InitiateLayerUpload.go | 147 ++ .../ecrpublic/api_op_ListTagsForResource.go | 120 ++ .../service/ecrpublic/api_op_PutImage.go | 171 ++ .../api_op_PutRegistryCatalogData.go | 125 ++ .../api_op_PutRepositoryCatalogData.go | 143 ++ .../ecrpublic/api_op_SetRepositoryPolicy.go | 170 ++ .../service/ecrpublic/api_op_TagResource.go | 124 ++ .../service/ecrpublic/api_op_UntagResource.go | 118 ++ .../ecrpublic/api_op_UploadLayerPart.go | 197 ++ .../aws-sdk-go-v2/service/ecrpublic/auth.go | 355 ++++ .../service/ecrpublic/common_serde.go | 453 +++++ .../aws-sdk-go-v2/service/ecrpublic/doc.go | 17 + .../service/ecrpublic/endpoints.go | 570 ++++++ .../service/ecrpublic/generated.json | 60 + .../service/ecrpublic/go_module_metadata.go | 6 + .../ecrpublic/internal/endpoints/endpoints.go | 360 ++++ .../service/ecrpublic/options.go | 245 +++ .../service/ecrpublic/schemas/schemas.go | 1694 +++++++++++++++++ .../service/ecrpublic/type_registry.go | 111 ++ .../service/ecrpublic/types/common_serde.go | 452 +++++ .../service/ecrpublic/types/enums.go | 91 + .../service/ecrpublic/types/errors.go | 1186 ++++++++++++ .../service/ecrpublic/types/types.go | 1064 +++++++++++ .../service/ecrpublic/validators.go | 751 ++++++++ vendor/modules.txt | 6 + 46 files changed, 13474 insertions(+), 22 deletions(-) create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/CHANGELOG.md create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/LICENSE.txt create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_client.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_BatchCheckLayerAvailability.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_BatchDeleteImage.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_CompleteLayerUpload.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_CreateRepository.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_DeleteRepository.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_DeleteRepositoryPolicy.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_DescribeImageTags.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_DescribeImages.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_DescribeRegistries.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_DescribeRepositories.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_GetAuthorizationToken.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_GetRegistryCatalogData.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_GetRepositoryCatalogData.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_GetRepositoryPolicy.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_InitiateLayerUpload.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_ListTagsForResource.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_PutImage.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_PutRegistryCatalogData.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_PutRepositoryCatalogData.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_SetRepositoryPolicy.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_TagResource.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_UntagResource.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_UploadLayerPart.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/auth.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/common_serde.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/doc.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/endpoints.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/generated.json create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/go_module_metadata.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/internal/endpoints/endpoints.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/options.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas/schemas.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/type_registry.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/types/common_serde.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/types/enums.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/types/errors.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/types/types.go create mode 100644 vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/validators.go diff --git a/go.mod b/go.mod index 6db2f33..629a222 100644 --- a/go.mod +++ b/go.mod @@ -7,6 +7,7 @@ require ( github.com/aws/aws-sdk-go-v2/config v1.33.5 github.com/aws/aws-sdk-go-v2/credentials v1.20.5 github.com/aws/aws-sdk-go-v2/service/ecr v1.66.0 + github.com/aws/aws-sdk-go-v2/service/ecrpublic v1.47.0 github.com/elazarl/goproxy v1.9.0 github.com/evalphobia/logrus_sentry v0.8.2 github.com/getsentry/raven-go v0.2.0 diff --git a/go.sum b/go.sum index f766f91..98ba24e 100644 --- a/go.sum +++ b/go.sum @@ -14,6 +14,8 @@ github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.3 h1:fuSCw4Z2qfRCztMPO3GXJNSiEp6W github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.3/go.mod h1:6SxcHheD1pPR5+kWm1wGvjlL/YqUsh267sAfEmN4K7A= github.com/aws/aws-sdk-go-v2/service/ecr v1.66.0 h1:9i19IigAYxnAxTUQcsxkiIXeeytHllTOetWBhr1DTQs= github.com/aws/aws-sdk-go-v2/service/ecr v1.66.0/go.mod h1:iSlv4VibruxMhWfiKrNbn97Yjhe2855EFrgUitSESfM= +github.com/aws/aws-sdk-go-v2/service/ecrpublic v1.47.0 h1:qLVBL6u7+Ob+H0s+eJAD54+UAn7eCBOlbngmBZRtv+k= +github.com/aws/aws-sdk-go-v2/service/ecrpublic v1.47.0/go.mod h1:r/ctJh/VqBZY1N0C6oKmdA4Dd4AeMHGQBTb46AGDs8A= github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19 h1:bAdDl/HkGCcGPoe25ToSHEw23VIxt6CT5fLcg111BKg= github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19/go.mod h1:KaUzbLxv4CeSxh6ZCl9B4m7CuFenS8kUEaDs+f/DQr4= github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.3 h1:bON1rJf67TSTDCKg816AAIE4xSTtoo9tl0XRkO72R+I= diff --git a/internal/handlers/docker_registry.go b/internal/handlers/docker_registry.go index 64577f8..b9d9c7e 100644 --- a/internal/handlers/docker_registry.go +++ b/internal/handlers/docker_registry.go @@ -8,9 +8,11 @@ import ( "regexp" "strings" + "github.com/aws/aws-sdk-go-v2/aws" awsconfig "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/credentials" "github.com/aws/aws-sdk-go-v2/service/ecr" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic" "github.com/elazarl/goproxy" "github.com/stackrox/docker-registry-client/registry" @@ -25,7 +27,15 @@ var ( ecrRe = regexp.MustCompile(`\A\d+.dkr.ecr.([a-z0-9-]+)\.amazonaws\.com\z`) ) -const ecrPublicHost = "public.ecr.aws" +const ( + ecrPublicHost = "public.ecr.aws" + // ECR Public only issues authorization tokens in us-east-1. + ecrPublicRegion = "us-east-1" + // ecrPublicTokenUsername is the username of a pre-generated ECR Public + // token from `aws ecr-public get-login-password`. Any other username is + // an AWS access key ID. + ecrPublicTokenUsername = "AWS" +) type ecrClient interface { GetAuthorizationToken(ctx context.Context, input *ecr.GetAuthorizationTokenInput, optFns ...func(*ecr.Options)) (*ecr.GetAuthorizationTokenOutput, error) @@ -244,17 +254,24 @@ func (h *DockerRegistryHandler) authenticateWithCredential( return } - // ECR Public rejects Basic auth on registry requests with a 400 instead of - // a 401 challenge, so the token flow below would never start. Its HTTP API - // takes the GetAuthorizationToken token, base64("AWS:"), as a - // bearer token, so send that directly. Other paths, such as /token, still - // accept Basic auth and keep the token flow below. - if _, ok := helpers.MatchingPathPrefix(req.URL.EscapedPath(), "/v2"); ok && - helpers.AreHostnamesEqual(req.URL.Hostname(), ecrPublicHost) { - logging.RequestLogf(proxyCtx, "* authenticating docker ecr public request (host: %s)", req.URL.Hostname()) - token := base64.StdEncoding.EncodeToString([]byte(cred.getUsername() + ":" + cred.getPassword())) - helpers.SetBearerAuthorization(req, token) - return + if helpers.AreHostnamesEqual(req.URL.Hostname(), ecrPublicHost) { + // Without a token the request is sent anonymously, which public + // images still allow, rather than with the AWS secret key. + if !cred.getECRPublicCredentials(req.Context(), proxyCtx) { + return + } + // ECR Public rejects Basic auth on registry requests with a 400 + // instead of a 401 challenge, so the token flow below would never + // start. Its HTTP API takes the GetAuthorizationToken token, + // base64("AWS:"), as a bearer token, so send that + // directly. Other paths, such as /token, still accept Basic auth and + // keep the token flow below. + if _, ok := helpers.MatchingPathPrefix(req.URL.EscapedPath(), "/v2"); ok { + logging.RequestLogf(proxyCtx, "* authenticating docker ecr public request (host: %s)", req.URL.Hostname()) + token := base64.StdEncoding.EncodeToString([]byte(cred.getUsername() + ":" + cred.getPassword())) + helpers.SetBearerAuthorization(req, token) + return + } } logging.RequestLogf(proxyCtx, "* authenticating docker registry request (host: %s)", req.URL.Hostname()) @@ -411,12 +428,7 @@ func dockerRegistryCredentialLocation(location string, proxyOnly bool) (matchURL } func defaultGetECRClient(ctx context.Context, region, keyID, secretKey string, client *http.Client) (ecrClient, error) { - cfg, err := awsconfig.LoadDefaultConfig( - ctx, - awsconfig.WithRegion(region), - awsconfig.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(keyID, secretKey, "")), - awsconfig.WithHTTPClient(client), - ) + cfg, err := loadAWSConfig(ctx, region, keyID, secretKey, client) if err != nil { return nil, err } @@ -424,6 +436,24 @@ func defaultGetECRClient(ctx context.Context, region, keyID, secretKey string, c return ecr.NewFromConfig(cfg), nil } +func defaultGetECRPublicClient(ctx context.Context, keyID, secretKey string, client *http.Client) (*ecrpublic.Client, error) { + cfg, err := loadAWSConfig(ctx, ecrPublicRegion, keyID, secretKey, client) + if err != nil { + return nil, err + } + + return ecrpublic.NewFromConfig(cfg), nil +} + +func loadAWSConfig(ctx context.Context, region, keyID, secretKey string, client *http.Client) (aws.Config, error) { + return awsconfig.LoadDefaultConfig( + ctx, + awsconfig.WithRegion(region), + awsconfig.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(keyID, secretKey, "")), + awsconfig.WithHTTPClient(client), + ) +} + type dockerOIDCCredential struct { matchURL string path string @@ -444,20 +474,21 @@ type dockerRegistryCredentials struct { } func (c *dockerRegistryCredentials) getECRCredentials(requestCtx context.Context, proxyCtx *goproxy.ProxyCtx) bool { - if c.ecrUsername != "" && c.ecrPassword != "" { - return true - } - regURL, err := helpers.ParseURLLax(c.registry) if err != nil { return false } + // Checked before the cached token, which may be an ECR Public one. match := ecrRe.FindStringSubmatch(regURL.Hostname()) if match == nil || len(match) != 2 { return false } + if c.ecrUsername != "" && c.ecrPassword != "" { + return true + } + region := match[1] ecrSvc, err := c.getECRClient(requestCtx, region, c.username, c.password, c.httpClient) if err != nil { @@ -490,6 +521,41 @@ func (c *dockerRegistryCredentials) getECRCredentials(requestCtx context.Context return false } +// getECRPublicCredentials exchanges an AWS access key pair for an ECR Public +// authorization token. A pre-generated token is used as is. +func (c *dockerRegistryCredentials) getECRPublicCredentials(requestCtx context.Context, proxyCtx *goproxy.ProxyCtx) bool { + if c.username == ecrPublicTokenUsername || (c.ecrUsername != "" && c.ecrPassword != "") { + return true + } + + ecrSvc, err := defaultGetECRPublicClient(requestCtx, c.username, c.password, c.httpClient) + if err != nil { + logging.RequestLogf(proxyCtx, "! failed to initialize aws ecr public client (key_id=%s)", c.username) + return false + } + + rsp, err := ecrSvc.GetAuthorizationToken(requestCtx, &ecrpublic.GetAuthorizationTokenInput{}) + if err != nil { + logging.RequestLogf(proxyCtx, "! failed to get ecr public authorization token (key_id=%s)", c.username) + return false + } + if rsp.AuthorizationData == nil || rsp.AuthorizationData.AuthorizationToken == nil { + return false + } + + decoded, err := base64.StdEncoding.DecodeString(*rsp.AuthorizationData.AuthorizationToken) + if err != nil { + return false + } + username, password, found := strings.Cut(string(decoded), ":") + if !found { + return false + } + c.ecrUsername = username + c.ecrPassword = password + return true +} + func (c *dockerRegistryCredentials) getUsername() string { if c.ecrUsername != "" { return c.ecrUsername diff --git a/internal/handlers/docker_registry_test.go b/internal/handlers/docker_registry_test.go index 2f5424f..a6663cd 100644 --- a/internal/handlers/docker_registry_test.go +++ b/internal/handlers/docker_registry_test.go @@ -580,6 +580,70 @@ func TestDockerRegistryHandlerECRPublic(t *testing.T) { } } +func TestDockerRegistryHandlerECRPublicAccessKey(t *testing.T) { + const manifestURL = "https://public.ecr.aws/v2/docker/library/alpine/manifests/latest" + newHandler := func(username string, transport *ecrPublicTokenTransport) *DockerRegistryHandler { + client := &http.Client{Transport: transport, Timeout: testOIDCClient.Timeout} + return NewDockerRegistryHandler(config.Credentials{{ + "type": "docker_registry", + "registry": "public.ecr.aws", + "username": username, + "password": "secret-key", + }}, client, nil) + } + + t.Run("registry API", func(t *testing.T) { + transport := &ecrPublicTokenTransport{status: http.StatusOK} + handler := newHandler("access-key", transport) + + for range 2 { + req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, manifestURL, nil) + proxyCtx := &goproxy.ProxyCtx{} + req = handleRequestAndClose(handler, req, proxyCtx) + assert.Nil(t, proxyCtx.RoundTripper, "no docker registry transport") + assertHasTokenAuth(t, req, "Bearer", base64.StdEncoding.EncodeToString([]byte("AWS:fetched-password")), "has fetched bearer token") + } + assert.Equal(t, []string{"api.ecr-public.us-east-1.amazonaws.com"}, transport.hosts, "token is fetched once from us-east-1") + }) + + t.Run("token endpoint", func(t *testing.T) { + transport := &ecrPublicTokenTransport{status: http.StatusOK} + handler := newHandler("access-key", transport) + + req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, + "https://public.ecr.aws/token/?service=public.ecr.aws&scope=repository:docker/library/alpine:pull", nil) + proxyCtx := &goproxy.ProxyCtx{} + handleRequestAndClose(handler, req, proxyCtx) + rt, ok := proxyCtx.RoundTripper.(*dockerRegistryRoundTripper) + require.True(t, ok, "request is assigned a docker registry transport") + trans := rt.transport.(*registry.BasicTransport) + assert.Equal(t, "AWS", trans.Username) + assert.Equal(t, "fetched-password", trans.Password) + }) + + t.Run("failed token request", func(t *testing.T) { + transport := &ecrPublicTokenTransport{status: http.StatusBadRequest} + handler := newHandler("access-key", transport) + + req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, manifestURL, nil) + proxyCtx := &goproxy.ProxyCtx{} + req = handleRequestAndClose(handler, req, proxyCtx) + assert.Nil(t, proxyCtx.RoundTripper, "no docker registry transport") + assertUnauthenticated(t, req, "secret key isn't sent") + }) + + t.Run("pre-generated token", func(t *testing.T) { + transport := &ecrPublicTokenTransport{status: http.StatusOK} + handler := newHandler("AWS", transport) + + req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, manifestURL, nil) + proxyCtx := &goproxy.ProxyCtx{} + req = handleRequestAndClose(handler, req, proxyCtx) + assertHasTokenAuth(t, req, "Bearer", base64.StdEncoding.EncodeToString([]byte("AWS:secret-key")), "has pre-generated bearer token") + assert.Empty(t, transport.hosts, "no token is fetched") + }) +} + func TestDockerRegistryHandlerPathScopedOIDCCredentialFallsBackToHost(t *testing.T) { const tokenURL = "https://token.actions.example.com" //nolint:gosec // test URL const jfrogTokenURL = "https://jfrog.example.com/access/api/v1/oidc/token" //nolint:gosec // test URL @@ -777,6 +841,30 @@ func (t *recordingECRTransport) RoundTrip(req *http.Request) (*http.Response, er }, nil } +// ecrPublicTokenTransport answers ECR Public GetAuthorizationToken requests +// with a token for AWS:fetched-password, or an error for a non-200 status. +type ecrPublicTokenTransport struct { + status int + hosts []string +} + +func (t *ecrPublicTokenTransport) RoundTrip(req *http.Request) (*http.Response, error) { + t.hosts = append(t.hosts, req.URL.Host) + body := `{"__type":"InvalidParameterException","message":"invalid"}` + if t.status == http.StatusOK { + token := base64.StdEncoding.EncodeToString([]byte("AWS:fetched-password")) + body = `{"authorizationData":{"authorizationToken":"` + token + `"}}` + } + header := make(http.Header) + header.Set("Content-Type", "application/x-amz-json-1.1") + return &http.Response{ + StatusCode: t.status, + Body: io.NopCloser(strings.NewReader(body)), + Header: header, + Request: req, + }, nil +} + type dockerChallengeTransport struct { t *testing.T paths []string diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/CHANGELOG.md b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/CHANGELOG.md new file mode 100644 index 0000000..9d3aa2d --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/CHANGELOG.md @@ -0,0 +1,855 @@ +# v1.47.0 (2026-09-09) + +* **Feature**: Stop registering the `retry.MetricsHeader` middleware in generated clients. The `Amz-Sdk-Request` header is now set by the retry middleware itself. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.46.0 (2026-09-04) + +* **Feature**: Stop registering the `spanRetryLoop` middleware in generated clients. The retry loop's tracing span is now opened by the retry middleware itself. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.45.0 (2026-08-31.2) + +* **Feature**: Stop registering the `SetCredentialSourceMiddleware` middleware in generated clients. Credential source user agent features are now set when the client's middleware stack is constructed. + +# v1.44.0 (2026-08-31) + +* **Feature**: Enable schema-based (de)serialization for this service. + +# v1.43.1 (2026-08-28) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.43.0 (2026-08-27) + +* **Feature**: Support connection read timeouts in the SDK. This is currently available on an opt-in basis by setting env `AWS_ENABLE_DEFAULT_SOCKET_TIMEOUT_2026=true`. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.42.0 (2026-08-26) + +* **Feature**: Stop registering the `ComputeContentLength` middleware in generated clients. `Content-Length` is now set when the request body is set via `SetStream`. +* **Dependency Update**: Update to smithy-go v1.28.0. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.41.8 (2026-08-25) + +* **Dependency Update**: Update to smithy-go v1.27.10. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.41.7 (2026-08-20) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.41.6 (2026-08-14) + +* **Dependency Update**: Update to smithy-go v1.27.8. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.41.5 (2026-08-10) + +* **Dependency Update**: Update to smithy-go v1.27.7. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.41.4 (2026-08-05) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.41.3 (2026-07-31.2) + +* **Dependency Update**: Updated to the latest SDK module versions +* **Dependency Update**: Upgrade to smithy-go v1.27.6 to fix various serde issues in HTTP binding services. + +# v1.41.2 (2026-07-29) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.41.1 (2026-07-28) + +* **Dependency Update**: Update to smithy-go v1.27.5. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.41.0 (2026-07-21) + +* **Feature**: Add an option to clients to disable clock skew +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.40.1 (2026-07-13) + +* No change notes available for this release. + +# v1.40.0 (2026-07-06) + +* **Feature**: Add request serialization snapshot tests. + +# v1.39.8 (2026-07-01) + +* **Bug Fix**: Bump smithy-go to 1.27.3, fix JSON encorder for document.Number, endpoint host label format validation and CBOR union serialization on new serde +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.39.7 (2026-06-29) + +* No change notes available for this release. + +# v1.39.6 (2026-06-08) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.39.5 (2026-06-04) + +* **Dependency Update**: Update to smithy-go v1.27.1 to fix several union-related deserialization bugs in schema-serde-enabled services. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.39.4 (2026-06-03) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.39.3 (2026-06-02) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.39.2 (2026-05-29) + +* **Dependency Update**: Update to smithy-go v1.26.0. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.39.1 (2026-05-28) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.39.0 (2026-05-27) + +* **Feature**: Adding new BDD representation of endpoint ruleset + +# v1.38.15 (2026-04-29) + +* **Dependency Update**: Update to smithy-go v1.25.1. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.38.14 (2026-04-17) + +* **Dependency Update**: Bump smithy-go to 1.25.0 to support endpointBdd trait +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.38.13 (2026-03-26) + +* **Bug Fix**: Fix a bug where a recorded clock skew could persist on the client even if the client and server clock ended up realigning. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.38.12 (2026-03-13) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.38.11 (2026-03-03) + +* **Dependency Update**: Bump minimum Go version to 1.24 +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.38.10 (2026-02-23) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.38.9 (2026-01-09) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.38.8 (2025-12-08) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.38.7 (2025-12-02) + +* **Dependency Update**: Updated to the latest SDK module versions +* **Dependency Update**: Upgrade to smithy-go v1.24.0. Notably this version of the library reduces the allocation footprint of the middleware system. We observe a ~10% reduction in allocations per SDK call with this change. + +# v1.38.6 (2025-11-25) + +* **Bug Fix**: Add error check for endpoint param binding during auth scheme resolution to fix panic reported in #3234 + +# v1.38.5 (2025-11-19.2) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.38.4 (2025-11-12) + +* **Bug Fix**: Further reduce allocation overhead when the metrics system isn't in-use. +* **Bug Fix**: Reduce allocation overhead when the client doesn't have any HTTP interceptors configured. +* **Bug Fix**: Remove blank trace spans towards the beginning of the request that added no additional information. This conveys a slight reduction in overall allocations. + +# v1.38.3 (2025-11-11) + +* **Bug Fix**: Return validation error if input region is not a valid host label. + +# v1.38.2 (2025-11-04) + +* **Dependency Update**: Updated to the latest SDK module versions +* **Dependency Update**: Upgrade to smithy-go v1.23.2 which should convey some passive reduction of overall allocations, especially when not using the metrics system. + +# v1.38.1 (2025-10-30) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.38.0 (2025-10-23) + +* **Feature**: Update endpoint ruleset parameters casing +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.37.7 (2025-10-16) + +* **Dependency Update**: Bump minimum Go version to 1.23. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.37.6 (2025-09-26) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.37.5 (2025-09-23) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.37.4 (2025-09-10) + +* No change notes available for this release. + +# v1.37.3 (2025-09-08) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.37.2 (2025-08-29) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.37.1 (2025-08-27) + +* **Dependency Update**: Update to smithy-go v1.23.0. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.37.0 (2025-08-21) + +* **Feature**: Remove incorrect endpoint tests +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.36.1 (2025-08-20) + +* **Bug Fix**: Remove unused deserialization code. + +# v1.36.0 (2025-08-11) + +* **Feature**: Add support for configuring per-service Options via callback on global config. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.35.0 (2025-08-04) + +* **Feature**: Support configurable auth scheme preferences in service clients via AWS_AUTH_SCHEME_PREFERENCE in the environment, auth_scheme_preference in the config file, and through in-code settings on LoadDefaultConfig and client constructor methods. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.34.1 (2025-07-30) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.34.0 (2025-07-28) + +* **Feature**: Add support for HTTP interceptors. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.33.3 (2025-07-19) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.33.2 (2025-06-17) + +* **Dependency Update**: Update to smithy-go v1.22.4. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.33.1 (2025-06-10) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.33.0 (2025-04-30) + +* **Feature**: Adds dualstack support for Amazon Elastic Container Registry Public (Amazon ECR Public). + +# v1.32.2 (2025-04-03) + +* No change notes available for this release. + +# v1.32.1 (2025-03-04.2) + +* **Bug Fix**: Add assurance test for operation order. + +# v1.32.0 (2025-02-27) + +* **Feature**: Track credential providers via User-Agent Feature ids +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.31.3 (2025-02-18) + +* **Bug Fix**: Bump go version to 1.22 +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.31.2 (2025-02-05) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.31.1 (2025-01-31) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.31.0 (2025-01-30) + +* **Feature**: Temporarily updating dualstack endpoint support +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.30.0 (2025-01-29) + +* **Feature**: Add support for Dualstack Endpoints + +# v1.29.5 (2025-01-24) + +* **Dependency Update**: Updated to the latest SDK module versions +* **Dependency Update**: Upgrade to smithy-go v1.22.2. + +# v1.29.4 (2025-01-17) + +* **Bug Fix**: Fix bug where credentials weren't refreshed during retry loop. + +# v1.29.3 (2025-01-15) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.29.2 (2025-01-09) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.29.1 (2025-01-03) + +* No change notes available for this release. + +# v1.29.0 (2024-12-28) + +* **Feature**: Restoring custom endpoint functionality for ECR Public + +# v1.28.1 (2024-12-26) + +* No change notes available for this release. + +# v1.28.0 (2024-12-23) + +* **Feature**: Add support for Dualstack endpoints + +# v1.27.8 (2024-12-19) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.27.7 (2024-12-02) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.27.6 (2024-11-18) + +* **Dependency Update**: Update to smithy-go v1.22.1. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.27.5 (2024-11-07) + +* **Bug Fix**: Adds case-insensitive handling of error message fields in service responses + +# v1.27.4 (2024-11-06) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.27.3 (2024-10-28) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.27.2 (2024-10-08) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.27.1 (2024-10-07) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.27.0 (2024-10-04) + +* **Feature**: Add support for HTTP client metrics. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.26.4 (2024-10-03) + +* No change notes available for this release. + +# v1.26.3 (2024-09-27) + +* No change notes available for this release. + +# v1.26.2 (2024-09-25) + +* No change notes available for this release. + +# v1.26.1 (2024-09-23) + +* No change notes available for this release. + +# v1.26.0 (2024-09-20) + +* **Feature**: Add tracing and metrics support to service clients. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.25.7 (2024-09-17) + +* **Bug Fix**: **BREAKFIX**: Only generate AccountIDEndpointMode config for services that use it. This is a compiler break, but removes no actual functionality, as no services currently use the account ID in endpoint resolution. + +# v1.25.6 (2024-09-04) + +* No change notes available for this release. + +# v1.25.5 (2024-09-03) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.25.4 (2024-08-15) + +* **Dependency Update**: Bump minimum Go version to 1.21. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.25.3 (2024-07-10.2) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.25.2 (2024-07-10) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.25.1 (2024-06-28) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.25.0 (2024-06-26) + +* **Feature**: Support list-of-string endpoint parameter. + +# v1.24.1 (2024-06-19) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.24.0 (2024-06-18) + +* **Feature**: Track usage of various AWS SDK features in user-agent string. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.23.11 (2024-06-17) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.23.10 (2024-06-07) + +* **Bug Fix**: Add clock skew correction on all service clients +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.23.9 (2024-06-03) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.23.8 (2024-05-23) + +* No change notes available for this release. + +# v1.23.7 (2024-05-16) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.23.6 (2024-05-15) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.23.5 (2024-05-08) + +* **Bug Fix**: GoDoc improvement + +# v1.23.4 (2024-03-29) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.23.3 (2024-03-18) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.23.2 (2024-03-07) + +* **Bug Fix**: Remove dependency on go-cmp. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.23.1 (2024-02-23) + +* **Bug Fix**: Move all common, SDK-side middleware stack ops into the service client module to prevent cross-module compatibility issues in the future. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.23.0 (2024-02-22) + +* **Feature**: Add middleware stack snapshot tests. + +# v1.22.3 (2024-02-21) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.22.2 (2024-02-20) + +* **Bug Fix**: When sourcing values for a service's `EndpointParameters`, the lack of a configured region (i.e. `options.Region == ""`) will now translate to a `nil` value for `EndpointParameters.Region` instead of a pointer to the empty string `""`. This will result in a much more explicit error when calling an operation instead of an obscure hostname lookup failure. + +# v1.22.1 (2024-02-15) + +* **Bug Fix**: Correct failure to determine the error type in awsJson services that could occur when errors were modeled with a non-string `code` field. + +# v1.22.0 (2024-02-13) + +* **Feature**: Bump minimum Go version to 1.20 per our language support policy. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.21.6 (2024-01-04) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.21.5 (2023-12-08) + +* **Bug Fix**: Reinstate presence of default Retryer in functional options, but still respect max attempts set therein. + +# v1.21.4 (2023-12-07) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.21.3 (2023-12-06) + +* **Bug Fix**: Restore pre-refactor auth behavior where all operations could technically be performed anonymously. + +# v1.21.2 (2023-12-01) + +* **Bug Fix**: Correct wrapping of errors in authentication workflow. +* **Bug Fix**: Correctly recognize cache-wrapped instances of AnonymousCredentials at client construction. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.21.1 (2023-11-30) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.21.0 (2023-11-29) + +* **Feature**: Expose Options() accessor on service clients. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.20.5 (2023-11-28.2) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.20.4 (2023-11-28) + +* **Bug Fix**: Respect setting RetryMaxAttempts in functional options at client construction. + +# v1.20.3 (2023-11-20) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.20.2 (2023-11-15) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.20.1 (2023-11-09) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.20.0 (2023-11-01) + +* **Feature**: Adds support for configured endpoints via environment variables and the AWS shared configuration file. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.19.0 (2023-10-31) + +* **Feature**: **BREAKING CHANGE**: Bump minimum go version to 1.19 per the revised [go version support policy](https://aws.amazon.com/blogs/developer/aws-sdk-for-go-aligns-with-go-release-policy-on-supported-runtimes/). +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.18.2 (2023-10-12) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.18.1 (2023-10-06) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.18.0 (2023-09-18) + +* **Announcement**: [BREAKFIX] Change in MaxResults datatype from value to pointer type in cognito-sync service. +* **Feature**: Adds several endpoint ruleset changes across all models: smaller rulesets, removed non-unique regional endpoints, fixes FIPS and DualStack endpoints, and make region not required in SDK::Endpoint. Additional breakfix to cognito-sync field. + +# v1.17.5 (2023-08-21) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.17.4 (2023-08-18) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.17.3 (2023-08-17) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.17.2 (2023-08-07) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.17.1 (2023-08-01) + +* No change notes available for this release. + +# v1.17.0 (2023-07-31) + +* **Feature**: Adds support for smithy-modeled endpoint resolution. A new rules-based endpoint resolution will be added to the SDK which will supercede and deprecate existing endpoint resolution. Specifically, EndpointResolver will be deprecated while BaseEndpoint and EndpointResolverV2 will take its place. For more information, please see the Endpoints section in our Developer Guide. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.16.6 (2023-07-28) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.16.5 (2023-07-13) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.16.4 (2023-06-15) + +* No change notes available for this release. + +# v1.16.3 (2023-06-13) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.16.2 (2023-05-04) + +* No change notes available for this release. + +# v1.16.1 (2023-04-24) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.16.0 (2023-04-11) + +* **Feature**: This release will allow using registry alias as registryId in BatchDeleteImage request. + +# v1.15.8 (2023-04-10) + +* No change notes available for this release. + +# v1.15.7 (2023-04-07) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.15.6 (2023-03-21) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.15.5 (2023-03-10) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.15.4 (2023-02-22) + +* **Bug Fix**: Prevent nil pointer dereference when retrieving error codes. + +# v1.15.3 (2023-02-20) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.15.2 (2023-02-15) + +* **Announcement**: When receiving an error response in restJson-based services, an incorrect error type may have been returned based on the content of the response. This has been fixed via PR #2012 tracked in issue #1910. +* **Bug Fix**: Correct error type parsing for restJson services. + +# v1.15.1 (2023-02-03) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.15.0 (2023-01-09) + +* **Feature**: This release for Amazon ECR Public makes several change to bring the SDK into sync with the API. + +# v1.14.0 (2023-01-05) + +* **Feature**: Add `ErrorCodeOverride` field to all error structs (aws/smithy-go#401). + +# v1.13.22 (2022-12-15) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.13.21 (2022-12-02) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.13.20 (2022-11-30) + +* No change notes available for this release. + +# v1.13.19 (2022-10-24) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.13.18 (2022-10-21) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.13.17 (2022-09-20) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.13.16 (2022-09-14) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.13.15 (2022-09-02) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.13.14 (2022-08-31) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.13.13 (2022-08-29) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.13.12 (2022-08-11) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.13.11 (2022-08-09) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.13.10 (2022-08-08) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.13.9 (2022-08-01) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.13.8 (2022-07-05) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.13.7 (2022-06-29) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.13.6 (2022-06-07) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.13.5 (2022-05-17) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.13.4 (2022-04-25) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.13.3 (2022-03-30) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.13.2 (2022-03-24) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.13.1 (2022-03-23) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.13.0 (2022-03-08) + +* **Feature**: Updated `github.com/aws/smithy-go` to latest version +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.12.0 (2022-02-24) + +* **Feature**: API client updated +* **Feature**: Adds RetryMaxAttempts and RetryMod to API client Options. This allows the API clients' default Retryer to be configured from the shared configuration files or environment variables. Adding a new Retry mode of `Adaptive`. `Adaptive` retry mode is an experimental mode, adding client rate limiting when throttles reponses are received from an API. See [retry.AdaptiveMode](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/aws/retry#AdaptiveMode) for more details, and configuration options. +* **Feature**: Updated `github.com/aws/smithy-go` to latest version +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.11.0 (2022-01-14) + +* **Feature**: Updated `github.com/aws/smithy-go` to latest version +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.10.0 (2022-01-07) + +* **Feature**: Updated `github.com/aws/smithy-go` to latest version +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.9.0 (2021-12-21) + +* **Feature**: API Paginators now support specifying the initial starting token, and support stopping on empty string tokens. + +# v1.8.2 (2021-12-02) + +* **Bug Fix**: Fixes a bug that prevented aws.EndpointResolverWithOptions from being used by the service client. ([#1514](https://github.com/aws/aws-sdk-go-v2/pull/1514)) +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.8.1 (2021-11-19) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.8.0 (2021-11-12) + +* **Feature**: Service clients now support custom endpoints that have an initial URI path defined. + +# v1.7.0 (2021-11-06) + +* **Feature**: The SDK now supports configuration of FIPS and DualStack endpoints using environment variables, shared configuration, or programmatically. +* **Feature**: Updated `github.com/aws/smithy-go` to latest version +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.6.0 (2021-10-21) + +* **Feature**: Updated to latest version +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.5.2 (2021-10-11) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.5.1 (2021-09-17) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.5.0 (2021-08-27) + +* **Feature**: Updated API model to latest revision. +* **Feature**: Updated `github.com/aws/smithy-go` to latest version +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.4.3 (2021-08-19) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.4.2 (2021-08-04) + +* **Dependency Update**: Updated `github.com/aws/smithy-go` to latest version. +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.4.1 (2021-07-15) + +* **Dependency Update**: Updated `github.com/aws/smithy-go` to latest version +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.4.0 (2021-06-25) + +* **Feature**: Updated `github.com/aws/smithy-go` to latest version +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.3.1 (2021-05-20) + +* **Dependency Update**: Updated to the latest SDK module versions + +# v1.3.0 (2021-05-14) + +* **Feature**: Constant has been added to modules to enable runtime version inspection for reporting. +* **Dependency Update**: Updated to the latest SDK module versions + diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/LICENSE.txt b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/LICENSE.txt new file mode 100644 index 0000000..d645695 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/LICENSE.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_client.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_client.go new file mode 100644 index 0000000..69f1eca --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_client.go @@ -0,0 +1,1018 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "errors" + "fmt" + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/aws/defaults" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/aws/retry" + "github.com/aws/aws-sdk-go-v2/aws/signer/v4" + awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http" + internalauth "github.com/aws/aws-sdk-go-v2/internal/auth" + internalauthsmithy "github.com/aws/aws-sdk-go-v2/internal/auth/smithy" + internalConfig "github.com/aws/aws-sdk-go-v2/internal/configsources" + "github.com/aws/aws-sdk-go-v2/internal/timeouts" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas" + smithy "github.com/aws/smithy-go" + smithydocument "github.com/aws/smithy-go/document" + "github.com/aws/smithy-go/logging" + "github.com/aws/smithy-go/metrics" + "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/tracing" + smithyhttp "github.com/aws/smithy-go/transport/http" + "github.com/aws/smithy-go/transport/http/protocol/awsjson" + "net" + "net/http" + "sync/atomic" + "time" +) + +const ServiceID = "ECR PUBLIC" +const ServiceAPIVersion = "2020-10-30" + +type operationMetrics struct { + Duration metrics.Float64Histogram + SerializeDuration metrics.Float64Histogram + ResolveIdentityDuration metrics.Float64Histogram + ResolveEndpointDuration metrics.Float64Histogram + SignRequestDuration metrics.Float64Histogram + DeserializeDuration metrics.Float64Histogram +} + +func (m *operationMetrics) histogramFor(name string) metrics.Float64Histogram { + switch name { + case "client.call.duration": + return m.Duration + case "client.call.serialization_duration": + return m.SerializeDuration + case "client.call.resolve_identity_duration": + return m.ResolveIdentityDuration + case "client.call.resolve_endpoint_duration": + return m.ResolveEndpointDuration + case "client.call.signing_duration": + return m.SignRequestDuration + case "client.call.deserialization_duration": + return m.DeserializeDuration + default: + panic("unrecognized operation metric") + } +} + +func timeOperationMetric[T any]( + ctx context.Context, metric string, fn func() (T, error), + opts ...metrics.RecordMetricOption, +) (T, error) { + mm := getOperationMetrics(ctx) + if mm == nil { // not using the metrics system + return fn() + } + + instr := mm.histogramFor(metric) + opts = append([]metrics.RecordMetricOption{withOperationMetadata(ctx)}, opts...) + + start := time.Now() + v, err := fn() + end := time.Now() + + elapsed := end.Sub(start) + instr.Record(ctx, float64(elapsed)/1e9, opts...) + return v, err +} + +func startMetricTimer(ctx context.Context, metric string, opts ...metrics.RecordMetricOption) func() { + mm := getOperationMetrics(ctx) + if mm == nil { // not using the metrics system + return func() {} + } + + instr := mm.histogramFor(metric) + opts = append([]metrics.RecordMetricOption{withOperationMetadata(ctx)}, opts...) + + var ended bool + start := time.Now() + return func() { + if ended { + return + } + ended = true + + end := time.Now() + + elapsed := end.Sub(start) + instr.Record(ctx, float64(elapsed)/1e9, opts...) + } +} + +func withOperationMetadata(ctx context.Context) metrics.RecordMetricOption { + return func(o *metrics.RecordMetricOptions) { + o.Properties.Set("rpc.service", middleware.GetServiceID(ctx)) + o.Properties.Set("rpc.method", middleware.GetOperationName(ctx)) + } +} + +type operationMetricsKey struct{} + +func withOperationMetrics(parent context.Context, mp metrics.MeterProvider) (context.Context, error) { + if _, ok := mp.(metrics.NopMeterProvider); ok { + // not using the metrics system - setting up the metrics context is a memory-intensive operation + // so we should skip it in this case + return parent, nil + } + + meter := mp.Meter("github.com/aws/aws-sdk-go-v2/service/ecrpublic") + om := &operationMetrics{} + + var err error + + om.Duration, err = operationMetricTimer(meter, "client.call.duration", + "Overall call duration (including retries and time to send or receive request and response body)") + if err != nil { + return nil, err + } + om.SerializeDuration, err = operationMetricTimer(meter, "client.call.serialization_duration", + "The time it takes to serialize a message body") + if err != nil { + return nil, err + } + om.ResolveIdentityDuration, err = operationMetricTimer(meter, "client.call.auth.resolve_identity_duration", + "The time taken to acquire an identity (AWS credentials, bearer token, etc) from an Identity Provider") + if err != nil { + return nil, err + } + om.ResolveEndpointDuration, err = operationMetricTimer(meter, "client.call.resolve_endpoint_duration", + "The time it takes to resolve an endpoint (endpoint resolver, not DNS) for the request") + if err != nil { + return nil, err + } + om.SignRequestDuration, err = operationMetricTimer(meter, "client.call.auth.signing_duration", + "The time it takes to sign a request") + if err != nil { + return nil, err + } + om.DeserializeDuration, err = operationMetricTimer(meter, "client.call.deserialization_duration", + "The time it takes to deserialize a message body") + if err != nil { + return nil, err + } + + return context.WithValue(parent, operationMetricsKey{}, om), nil +} + +func operationMetricTimer(m metrics.Meter, name, desc string) (metrics.Float64Histogram, error) { + return m.Float64Histogram(name, func(o *metrics.InstrumentOptions) { + o.UnitLabel = "s" + o.Description = desc + }) +} + +func getOperationMetrics(ctx context.Context) *operationMetrics { + if v := ctx.Value(operationMetricsKey{}); v != nil { + return v.(*operationMetrics) + } + return nil +} + +func operationTracer(p tracing.TracerProvider) tracing.Tracer { + return p.Tracer("github.com/aws/aws-sdk-go-v2/service/ecrpublic") +} + +// Client provides the API client to make operations call for Amazon Elastic +// Container Registry Public. +type Client struct { + options Options + + // Difference between the time reported by the server and the client + timeOffset *atomic.Int64 +} + +// New returns an initialized Client based on the functional options. Provide +// additional functional options to further configure the behavior of the client, +// such as changing the client's endpoint or adding custom middleware behavior. +func New(options Options, optFns ...func(*Options)) *Client { + options = options.Copy() + + resolveDefaultLogger(&options) + + setResolvedDefaultsMode(&options) + + resolveRetryer(&options) + + resolveHTTPClient(&options) + + resolveHTTPSignerV4(&options) + + resolveEndpointResolverV2(&options) + + resolveTracerProvider(&options) + + resolveMeterProvider(&options) + + resolveAuthSchemeResolver(&options) + + options.Protocol = awsjson.New11(schemas.SpencerFrontendService) + + for _, fn := range optFns { + fn(&options) + } + + finalizeRetryMaxAttempts(&options) + + ignoreAnonymousAuth(&options) + + wrapWithAnonymousAuth(&options) + + resolveAuthSchemes(&options) + + client := &Client{ + options: options, + } + + initializeTimeOffsetResolver(client) + + return client +} + +// Options returns a copy of the client configuration. +// +// Callers SHOULD NOT perform mutations on any inner structures within client +// config. Config overrides should instead be made on a per-operation basis through +// functional options. +func (c *Client) Options() Options { + return c.options.Copy() +} + +func (c *Client) invokeOperation( + ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error, +) ( + result interface{}, metadata middleware.Metadata, err error, +) { + ctx = middleware.ClearStackValues(ctx) + ctx = middleware.WithServiceID(ctx, ServiceID) + ctx = middleware.WithOperationName(ctx, opID) + + stack := middleware.NewStack(opID, smithyhttp.NewStackRequest) + options := c.options.Copy() + + for _, fn := range optFns { + fn(&options) + } + + finalizeOperationRetryMaxAttempts(&options, *c) + + finalizeClientEndpointResolverOptions(&options) + + ctx = setLoggerContext(ctx, options, opID) + + ctx = resolveServiceMetadata(ctx, options, opID) + + if err := c.addCommonMiddlewares(stack, options, opID); err != nil { + return nil, metadata, err + } + + for _, fn := range stackFns { + if err := fn(stack, options); err != nil { + return nil, metadata, err + } + } + + for _, fn := range options.APIOptions { + if err := fn(stack); err != nil { + return nil, metadata, err + } + } + + ctx, err = withOperationMetrics(ctx, options.MeterProvider) + if err != nil { + return nil, metadata, err + } + + tracer := operationTracer(options.TracerProvider) + spanName := fmt.Sprintf("%s.%s", ServiceID, opID) + + ctx = tracing.WithOperationTracer(ctx, tracer) + + ctx, span := tracer.StartSpan(ctx, spanName, func(o *tracing.SpanOptions) { + o.Kind = tracing.SpanKindClient + o.Properties.Set("rpc.system", "aws-api") + o.Properties.Set("rpc.method", opID) + o.Properties.Set("rpc.service", ServiceID) + }) + endTimer := startMetricTimer(ctx, "client.call.duration") + defer endTimer() + defer span.End() + + handler := smithyhttp.NewClientHandlerWithOptions(options.HTTPClient, func(o *smithyhttp.ClientHandler) { + o.Meter = options.MeterProvider.Meter("github.com/aws/aws-sdk-go-v2/service/ecrpublic") + }) + decorated := middleware.DecorateHandler(handler, stack) + result, metadata, err = decorated.Handle(ctx, params) + if err != nil { + span.SetProperty("exception.type", fmt.Sprintf("%T", err)) + span.SetProperty("exception.message", err.Error()) + + var aerr smithy.APIError + if errors.As(err, &aerr) { + span.SetProperty("api.error_code", aerr.ErrorCode()) + span.SetProperty("api.error_message", aerr.ErrorMessage()) + span.SetProperty("api.error_fault", aerr.ErrorFault().String()) + } + + err = &smithy.OperationError{ + ServiceID: ServiceID, + OperationName: opID, + Err: err, + } + } + + span.SetProperty("error", err != nil) + if err == nil { + span.SetStatus(tracing.SpanStatusOK) + } else { + span.SetStatus(tracing.SpanStatusError) + } + + return result, metadata, err +} + +type operationInputKey struct{} + +func setOperationInput(ctx context.Context, input interface{}) context.Context { + return middleware.WithStackValue(ctx, operationInputKey{}, input) +} + +func getOperationInput(ctx context.Context) interface{} { + return middleware.GetStackValue(ctx, operationInputKey{}) +} + +type setOperationInputMiddleware struct { +} + +func (*setOperationInputMiddleware) ID() string { + return "setOperationInput" +} + +func (m *setOperationInputMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + ctx = setOperationInput(ctx, in.Parameters) + return next.HandleSerialize(ctx, in) +} + +func addProtocolFinalizerMiddlewares(stack *middleware.Stack, options Options, operation string) error { + if err := stack.Finalize.Add(&resolveAuthSchemeMiddleware{operation: operation, options: options}, middleware.Before); err != nil { + return fmt.Errorf("add ResolveAuthScheme: %w", err) + } + if err := stack.Finalize.Insert(&getIdentityMiddleware{options: options}, "ResolveAuthScheme", middleware.After); err != nil { + return fmt.Errorf("add GetIdentity: %v", err) + } + if err := stack.Finalize.Insert(&resolveEndpointV2Middleware{options: options}, "GetIdentity", middleware.After); err != nil { + return fmt.Errorf("add ResolveEndpointV2: %v", err) + } + if err := stack.Finalize.Insert(&signRequestMiddleware{options: options}, "ResolveEndpointV2", middleware.After); err != nil { + return fmt.Errorf("add Signing: %w", err) + } + return nil +} + +func (c *Client) addCommonMiddlewares(stack *middleware.Stack, options Options, operation string) error { + if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil { + return err + } + if err := addProtocolFinalizerMiddlewares(stack, options, operation); err != nil { + return fmt.Errorf("add protocol finalizers: %v", err) + } + if err := addClientRequestID(stack); err != nil { + return err + } + if err := addRetry(stack, options, c); err != nil { + return err + } + if err := addRawResponseToMetadata(stack); err != nil { + return err + } + if err := addClientUserAgent(stack, options); err != nil { + return err + } + if err := addSetLegacyContextSigningOptionsMiddleware(stack); err != nil { + return err + } + if err := addUserAgentRetryMode(stack, options); err != nil { + return err + } + if err := addRecursionDetection(stack); err != nil { + return err + } + if err := addInterceptBeforeRetryLoop(stack, options); err != nil { + return err + } + if err := addInterceptAttempt(stack, options); err != nil { + return err + } + return nil +} +func resolveAuthSchemeResolver(options *Options) { + if options.AuthSchemeResolver == nil { + options.AuthSchemeResolver = &defaultAuthSchemeResolver{} + } +} + +func resolveAuthSchemes(options *Options) { + if options.AuthSchemes == nil { + options.AuthSchemes = []smithyhttp.AuthScheme{ + internalauth.NewHTTPAuthScheme("aws.auth#sigv4", &internalauthsmithy.V4SignerAdapter{ + Signer: options.HTTPSignerV4, + Logger: options.Logger, + LogSigning: options.ClientLogMode.IsSigning(), + }), + } + } +} + +type serializeRequestMiddleware struct { + options *Options + operationSchema *smithy.OperationSchema +} + +func (*serializeRequestMiddleware) ID() string { + return "OperationSerializer" +} + +func (m *serializeRequestMiddleware) HandleSerialize( + ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler, +) ( + middleware.SerializeOutput, middleware.Metadata, error, +) { + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return middleware.SerializeOutput{}, middleware.Metadata{}, fmt.Errorf("unexpected transport type %T", in.Request) + } + + input, ok := in.Parameters.(smithy.Serializable) + if !ok { + return middleware.SerializeOutput{}, middleware.Metadata{}, fmt.Errorf("input %T is not Serializable", in.Request) + } + + _, span := tracing.StartSpan(ctx, "OperationSerializer") + endTimer := startMetricTimer(ctx, "client.call.serialization_duration") + + err := m.options.Protocol.SerializeRequest(ctx, m.operationSchema, input, req) + + endTimer() + span.End() + + if err != nil { + return middleware.SerializeOutput{}, middleware.Metadata{}, err + } + + return next.HandleSerialize(ctx, in) +} + +type deserializeResponseMiddleware struct { + options *Options + operationSchema *smithy.OperationSchema + output smithy.Deserializable +} + +func (*deserializeResponseMiddleware) ID() string { + return "OperationDeserializer" +} + +func (m *deserializeResponseMiddleware) HandleDeserialize( + ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler, +) ( + middleware.DeserializeOutput, middleware.Metadata, error, +) { + out, md, err := next.HandleDeserialize(ctx, in) + if err != nil { + return out, md, err + } + + resp, ok := out.RawResponse.(*smithyhttp.Response) + if !ok { + return out, md, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} + } + + // Event streams close their own body in the event stream deserializer. + if !m.operationSchema.IsInputEventStream() && !m.operationSchema.IsOutputEventStream() { + _, isStreamingPayload := m.output.(smithy.StreamingOutput) + defer func() { + smithyhttp.CloseResponseBody(ctx, resp, isStreamingPayload, err) + }() + } + + _, span := tracing.StartSpan(ctx, "OperationDeserializer") + endTimer := startMetricTimer(ctx, "client.call.deserialization_duration") + + err = m.options.Protocol.DeserializeResponse(ctx, m.operationSchema, TypeRegistry, resp, m.output) + out.Result = m.output + + endTimer() + span.End() + + return out, md, err +} + +type noSmithyDocumentSerde = smithydocument.NoSerde + +func resolveDefaultLogger(o *Options) { + if o.Logger != nil { + return + } + o.Logger = logging.Nop{} +} + +func setLoggerContext(ctx context.Context, options Options, operation string) context.Context { + _ = operation + return middleware.SetLogger(ctx, options.Logger) +} + +func setResolvedDefaultsMode(o *Options) { + if len(o.resolvedDefaultsMode) > 0 { + return + } + + var mode aws.DefaultsMode + mode.SetFromString(string(o.DefaultsMode)) + + if mode == aws.DefaultsModeAuto { + mode = defaults.ResolveDefaultsModeAuto(o.Region, o.RuntimeEnvironment) + } + + o.resolvedDefaultsMode = mode +} + +// NewFromConfig returns a new client from the provided config. +func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client { + opts := Options{ + Region: cfg.Region, + DefaultsMode: cfg.DefaultsMode, + RuntimeEnvironment: cfg.RuntimeEnvironment, + HTTPClient: cfg.HTTPClient, + Credentials: cfg.Credentials, + APIOptions: cfg.APIOptions, + Logger: cfg.Logger, + ClientLogMode: cfg.ClientLogMode, + AppID: cfg.AppID, + DisableClockSkewCorrection: cfg.DisableClockSkewCorrection, + AuthSchemePreference: cfg.AuthSchemePreference, + } + resolveAWSRetryerProvider(cfg, &opts) + resolveAWSRetryMaxAttempts(cfg, &opts) + resolveAWSRetryMode(cfg, &opts) + resolveAWSEndpointResolver(cfg, &opts) + resolveInterceptors(cfg, &opts) + resolveUseDualStackEndpoint(cfg, &opts) + resolveUseFIPSEndpoint(cfg, &opts) + resolveBaseEndpoint(cfg, &opts) + return New(opts, func(o *Options) { + for _, opt := range cfg.ServiceOptions { + opt(ServiceID, o) + } + for _, opt := range optFns { + opt(o) + } + }) +} + +func resolveHTTPClient(o *Options) { + var buildable *awshttp.BuildableClient + + if o.HTTPClient != nil { + var ok bool + buildable, ok = o.HTTPClient.(*awshttp.BuildableClient) + if !ok { + return + } + } else { + buildable = awshttp.NewBuildableClient() + } + + modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode) + if err == nil { + buildable = buildable.WithDialerOptions(func(dialer *net.Dialer) { + if dialerTimeout, ok := modeConfig.GetConnectTimeout(); ok { + dialer.Timeout = dialerTimeout + } + }) + + buildable = buildable.WithTransportOptions(func(transport *http.Transport) { + if tlsHandshakeTimeout, ok := modeConfig.GetTLSNegotiationTimeout(); ok { + transport.TLSHandshakeTimeout = tlsHandshakeTimeout + } + }) + } + + if _, ok := buildable.GetReadTimeout(); !ok { + if timeout, ok := timeouts.GetServiceReadTimeout(ServiceID); ok { + buildable = buildable.WithReadTimeout(timeout) + } + } + + o.HTTPClient = buildable +} + +func resolveRetryer(o *Options) { + if o.Retryer != nil { + return + } + + if len(o.RetryMode) == 0 { + modeConfig, err := defaults.GetModeConfiguration(o.resolvedDefaultsMode) + if err == nil { + o.RetryMode = modeConfig.RetryMode + } + } + if len(o.RetryMode) == 0 { + o.RetryMode = aws.RetryModeStandard + } + + var standardOptions []func(*retry.StandardOptions) + if v := o.RetryMaxAttempts; v != 0 { + standardOptions = append(standardOptions, func(so *retry.StandardOptions) { + so.MaxAttempts = v + }) + } + + switch o.RetryMode { + case aws.RetryModeAdaptive: + var adaptiveOptions []func(*retry.AdaptiveModeOptions) + if len(standardOptions) != 0 { + adaptiveOptions = append(adaptiveOptions, func(ao *retry.AdaptiveModeOptions) { + ao.StandardOptions = append(ao.StandardOptions, standardOptions...) + }) + } + o.Retryer = retry.NewAdaptiveMode(adaptiveOptions...) + + default: + o.Retryer = retry.NewStandard(standardOptions...) + } +} + +func resolveAWSRetryerProvider(cfg aws.Config, o *Options) { + if cfg.Retryer == nil { + return + } + o.Retryer = cfg.Retryer() +} + +func resolveAWSRetryMode(cfg aws.Config, o *Options) { + if len(cfg.RetryMode) == 0 { + return + } + o.RetryMode = cfg.RetryMode +} +func resolveAWSRetryMaxAttempts(cfg aws.Config, o *Options) { + if cfg.RetryMaxAttempts == 0 { + return + } + o.RetryMaxAttempts = cfg.RetryMaxAttempts +} + +func finalizeRetryMaxAttempts(o *Options) { + if o.RetryMaxAttempts == 0 { + return + } + + o.Retryer = retry.AddWithMaxAttempts(o.Retryer, o.RetryMaxAttempts) +} + +func finalizeOperationRetryMaxAttempts(o *Options, client Client) { + if v := o.RetryMaxAttempts; v == 0 || v == client.options.RetryMaxAttempts { + return + } + + o.Retryer = retry.AddWithMaxAttempts(o.Retryer, o.RetryMaxAttempts) +} + +func resolveAWSEndpointResolver(cfg aws.Config, o *Options) { + if cfg.EndpointResolver == nil && cfg.EndpointResolverWithOptions == nil { + return + } + o.EndpointResolver = withEndpointResolver(cfg.EndpointResolver, cfg.EndpointResolverWithOptions) +} + +func resolveInterceptors(cfg aws.Config, o *Options) { + o.Interceptors = cfg.Interceptors.Copy() +} + +func addClientUserAgent(stack *middleware.Stack, options Options) error { + ua, err := getOrAddRequestUserAgent(stack) + if err != nil { + return err + } + + ua.AddSDKAgentKeyValue(awsmiddleware.APIMetadata, "ecrpublic", goModuleVersion) + if len(options.AppID) > 0 { + ua.AddSDKAgentKey(awsmiddleware.ApplicationIdentifier, options.AppID) + } + + return nil +} + +func getOrAddRequestUserAgent(stack *middleware.Stack) (*awsmiddleware.RequestUserAgent, error) { + id := (*awsmiddleware.RequestUserAgent)(nil).ID() + mw, ok := stack.Build.Get(id) + if !ok { + mw = awsmiddleware.NewRequestUserAgent() + if err := stack.Build.Add(mw, middleware.After); err != nil { + return nil, err + } + } + + ua, ok := mw.(*awsmiddleware.RequestUserAgent) + if !ok { + return nil, fmt.Errorf("%T for %s middleware did not match expected type", mw, id) + } + + return ua, nil +} + +type HTTPSignerV4 interface { + SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error +} + +func resolveHTTPSignerV4(o *Options) { + if o.HTTPSignerV4 != nil { + return + } + o.HTTPSignerV4 = newDefaultV4Signer(*o) +} + +func newDefaultV4Signer(o Options) *v4.Signer { + return v4.NewSigner(func(so *v4.SignerOptions) { + so.Logger = o.Logger + so.LogSigning = o.ClientLogMode.IsSigning() + }) +} + +func addClientRequestID(stack *middleware.Stack) error { + return stack.Build.Add(&awsmiddleware.ClientRequestID{}, middleware.After) +} + +func addRawResponseToMetadata(stack *middleware.Stack) error { + return stack.Deserialize.Add(&awsmiddleware.AddRawResponse{}, middleware.Before) +} + +func addRecordResponseTiming(stack *middleware.Stack, options Options) error { + return stack.Deserialize.Add(&awsmiddleware.RecordResponseTiming{ + DisableClockSkewCorrection: options.DisableClockSkewCorrection, + }, middleware.After) +} +func addStreamingEventsPayload(stack *middleware.Stack) error { + return stack.Finalize.Add(&v4.StreamingEventsPayload{}, middleware.Before) +} + +func addUnsignedPayload(stack *middleware.Stack) error { + return stack.Finalize.Insert(&v4.UnsignedPayload{}, "ResolveEndpointV2", middleware.After) +} + +func addComputePayloadSHA256(stack *middleware.Stack) error { + return stack.Finalize.Insert(&v4.ComputePayloadSHA256{}, "ResolveEndpointV2", middleware.After) +} + +func addContentSHA256Header(stack *middleware.Stack) error { + return stack.Finalize.Insert(&v4.ContentSHA256Header{}, (*v4.ComputePayloadSHA256)(nil).ID(), middleware.After) +} + +func addIsWaiterUserAgent(o *Options) { + o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error { + ua, err := getOrAddRequestUserAgent(stack) + if err != nil { + return err + } + + ua.AddUserAgentFeature(awsmiddleware.UserAgentFeatureWaiter) + return nil + }) +} + +func addIsPaginatorUserAgent(o *Options) { + o.APIOptions = append(o.APIOptions, func(stack *middleware.Stack) error { + ua, err := getOrAddRequestUserAgent(stack) + if err != nil { + return err + } + + ua.AddUserAgentFeature(awsmiddleware.UserAgentFeaturePaginator) + return nil + }) +} + +func addRetry(stack *middleware.Stack, o Options, c *Client) error { + attempt := retry.NewAttemptMiddleware(o.Retryer, smithyhttp.RequestCloner, func(m *retry.Attempt) { + m.LogAttempts = o.ClientLogMode.IsRetries() + m.OperationMeter = o.MeterProvider.Meter("github.com/aws/aws-sdk-go-v2/service/ecrpublic") + m.ClientSkew = c.timeOffset + m.DisableClockSkewCorrection = o.DisableClockSkewCorrection + }) + if err := stack.Finalize.Insert(attempt, "ResolveAuthScheme", middleware.Before); err != nil { + return err + } + return nil +} + +// resolves dual-stack endpoint configuration +func resolveUseDualStackEndpoint(cfg aws.Config, o *Options) error { + if len(cfg.ConfigSources) == 0 { + return nil + } + value, found, err := internalConfig.ResolveUseDualStackEndpoint(context.Background(), cfg.ConfigSources) + if err != nil { + return err + } + if found { + o.EndpointOptions.UseDualStackEndpoint = value + } + return nil +} + +// resolves FIPS endpoint configuration +func resolveUseFIPSEndpoint(cfg aws.Config, o *Options) error { + if len(cfg.ConfigSources) == 0 { + return nil + } + value, found, err := internalConfig.ResolveUseFIPSEndpoint(context.Background(), cfg.ConfigSources) + if err != nil { + return err + } + if found { + o.EndpointOptions.UseFIPSEndpoint = value + } + return nil +} + +func initializeTimeOffsetResolver(c *Client) { + c.timeOffset = new(atomic.Int64) +} + +func addUserAgentRetryMode(stack *middleware.Stack, options Options) error { + ua, err := getOrAddRequestUserAgent(stack) + if err != nil { + return err + } + + switch options.Retryer.(type) { + case *retry.Standard: + ua.AddUserAgentFeature(awsmiddleware.UserAgentFeatureRetryModeStandard) + case *retry.AdaptiveMode: + ua.AddUserAgentFeature(awsmiddleware.UserAgentFeatureRetryModeAdaptive) + } + return nil +} + +func addCredentialSource(stack *middleware.Stack, options Options) error { + ua, err := getOrAddRequestUserAgent(stack) + if err != nil { + return err + } + + asProviderSource, ok := options.Credentials.(aws.CredentialProviderSource) + if !ok { + return nil + } + + for _, source := range asProviderSource.ProviderSources() { + ua.AddCredentialsSource(source) + } + return nil +} + +func resolveTracerProvider(options *Options) { + if options.TracerProvider == nil { + options.TracerProvider = &tracing.NopTracerProvider{} + } +} + +func resolveMeterProvider(options *Options) { + if options.MeterProvider == nil { + options.MeterProvider = metrics.NopMeterProvider{} + } +} + +func resolveServiceMetadata(ctx context.Context, options Options, operation string) context.Context { + ctx = awsmiddleware.SetServiceID(ctx, ServiceID) + if options.Region != "" { + ctx = awsmiddleware.SetRegion(ctx, options.Region) + } + ctx = awsmiddleware.SetOperationName(ctx, operation) + if options.EndpointResolver != nil { + ctx = awsmiddleware.SetRequiresLegacyEndpoints(ctx, true) + } + return ctx +} + +func addRecursionDetection(stack *middleware.Stack) error { + return stack.Build.Add(&awsmiddleware.RecursionDetection{}, middleware.After) +} + +func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error { + return stack.Deserialize.Insert(&awsmiddleware.RequestIDRetriever{}, "OperationDeserializer", middleware.Before) + +} + +func addResponseErrorMiddleware(stack *middleware.Stack) error { + return stack.Deserialize.Insert(&awshttp.ResponseErrorWrapper{}, "RequestIDRetriever", middleware.Before) + +} + +func addRequestResponseLogging(stack *middleware.Stack, o Options) error { + return stack.Deserialize.Add(&smithyhttp.RequestResponseLogger{ + LogRequest: o.ClientLogMode.IsRequest(), + LogRequestWithBody: o.ClientLogMode.IsRequestWithBody(), + LogResponse: o.ClientLogMode.IsResponse(), + LogResponseWithBody: o.ClientLogMode.IsResponseWithBody(), + }, middleware.After) +} + +type disableHTTPSMiddleware struct { + DisableHTTPS bool +} + +func (*disableHTTPSMiddleware) ID() string { + return "disableHTTPS" +} + +func (m *disableHTTPSMiddleware) HandleFinalize(ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler) ( + out middleware.FinalizeOutput, metadata middleware.Metadata, err error, +) { + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + if m.DisableHTTPS && !smithyhttp.GetHostnameImmutable(ctx) { + req.URL.Scheme = "http" + } + + return next.HandleFinalize(ctx, in) +} + +func addDisableHTTPSMiddleware(stack *middleware.Stack, o Options) error { + return stack.Finalize.Insert(&disableHTTPSMiddleware{ + DisableHTTPS: o.EndpointOptions.DisableHTTPS, + }, "ResolveEndpointV2", middleware.After) +} + +func addInterceptBeforeRetryLoop(stack *middleware.Stack, opts Options) error { + return stack.Finalize.Insert(&smithyhttp.InterceptBeforeRetryLoop{ + Interceptors: opts.Interceptors.BeforeRetryLoop, + }, "Retry", middleware.Before) +} + +func addInterceptAttempt(stack *middleware.Stack, opts Options) error { + return stack.Finalize.Insert(&smithyhttp.InterceptAttempt{ + BeforeAttempt: opts.Interceptors.BeforeAttempt, + AfterAttempt: opts.Interceptors.AfterAttempt, + }, "Retry", middleware.After) +} + +func addInterceptors(stack *middleware.Stack, opts Options) error { + // middlewares are expensive, don't add all of these interceptor ones unless the caller + // actually has at least one interceptor configured + // + // at the moment it's all-or-nothing because some of the middlewares here are responsible for + // setting fields in the interceptor context for future ones + if len(opts.Interceptors.BeforeExecution) == 0 && + len(opts.Interceptors.BeforeSerialization) == 0 && len(opts.Interceptors.AfterSerialization) == 0 && + len(opts.Interceptors.BeforeRetryLoop) == 0 && + len(opts.Interceptors.BeforeAttempt) == 0 && + len(opts.Interceptors.BeforeSigning) == 0 && len(opts.Interceptors.AfterSigning) == 0 && + len(opts.Interceptors.BeforeTransmit) == 0 && len(opts.Interceptors.AfterTransmit) == 0 && + len(opts.Interceptors.BeforeDeserialization) == 0 && len(opts.Interceptors.AfterDeserialization) == 0 && + len(opts.Interceptors.AfterAttempt) == 0 && len(opts.Interceptors.AfterExecution) == 0 { + return nil + } + + return errors.Join( + stack.Initialize.Add(&smithyhttp.InterceptExecution{ + BeforeExecution: opts.Interceptors.BeforeExecution, + AfterExecution: opts.Interceptors.AfterExecution, + }, middleware.Before), + stack.Serialize.Insert(&smithyhttp.InterceptBeforeSerialization{ + Interceptors: opts.Interceptors.BeforeSerialization, + }, "OperationSerializer", middleware.Before), + stack.Serialize.Insert(&smithyhttp.InterceptAfterSerialization{ + Interceptors: opts.Interceptors.AfterSerialization, + }, "OperationSerializer", middleware.After), + stack.Finalize.Insert(&smithyhttp.InterceptBeforeSigning{ + Interceptors: opts.Interceptors.BeforeSigning, + }, "Signing", middleware.Before), + stack.Finalize.Insert(&smithyhttp.InterceptAfterSigning{ + Interceptors: opts.Interceptors.AfterSigning, + }, "Signing", middleware.After), + stack.Deserialize.Add(&smithyhttp.InterceptTransmit{ + BeforeTransmit: opts.Interceptors.BeforeTransmit, + AfterTransmit: opts.Interceptors.AfterTransmit, + }, middleware.After), + stack.Deserialize.Insert(&smithyhttp.InterceptBeforeDeserialization{ + Interceptors: opts.Interceptors.BeforeDeserialization, + }, "OperationDeserializer", middleware.After), // (deserialize stack is called in reverse) + stack.Deserialize.Insert(&smithyhttp.InterceptAfterDeserialization{ + Interceptors: opts.Interceptors.AfterDeserialization, + }, "OperationDeserializer", middleware.Before), + ) +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_BatchCheckLayerAvailability.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_BatchCheckLayerAvailability.go new file mode 100644 index 0000000..0191da4 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_BatchCheckLayerAvailability.go @@ -0,0 +1,147 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" +) + +// Checks the availability of one or more image layers that are within a +// repository in a public registry. When an image is pushed to a repository, each +// image layer is checked to verify if it has been uploaded before. If it has been +// uploaded, then the image layer is skipped. +// +// This operation is used by the Amazon ECR proxy and is not generally used by +// customers for pulling and pushing images. In most cases, you should use the +// docker CLI to pull, tag, and push images. +func (c *Client) BatchCheckLayerAvailability(ctx context.Context, params *BatchCheckLayerAvailabilityInput, optFns ...func(*Options)) (*BatchCheckLayerAvailabilityOutput, error) { + if params == nil { + params = &BatchCheckLayerAvailabilityInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "BatchCheckLayerAvailability", params, optFns, c.addOperationBatchCheckLayerAvailabilityMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*BatchCheckLayerAvailabilityOutput) + out.ResultMetadata = metadata + return out, nil +} + +type BatchCheckLayerAvailabilityInput struct { + + // The digests of the image layers to check. + // + // This member is required. + LayerDigests []string + + // The name of the repository that's associated with the image layers to check. + // + // This member is required. + RepositoryName *string + + // The Amazon Web Services account ID, or registry alias, associated with the + // public registry that contains the image layers to check. If you do not specify a + // registry, the default public registry is assumed. + RegistryId *string + + noSmithyDocumentSerde +} + +func (v *BatchCheckLayerAvailabilityInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.BatchCheckLayerAvailabilityRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *BatchCheckLayerAvailabilityInput) SerializeMembers(s smithy.ShapeSerializer) { + serializeBatchedOperationLayerDigestList(s, schemas.BatchCheckLayerAvailabilityRequest_layerDigests, v.LayerDigests) + if v.RegistryId != nil { + s.WriteString(schemas.BatchCheckLayerAvailabilityRequest_registryId, *v.RegistryId) + } + if v.RepositoryName != nil { + s.WriteString(schemas.BatchCheckLayerAvailabilityRequest_repositoryName, *v.RepositoryName) + } +} + +type BatchCheckLayerAvailabilityOutput struct { + + // Any failures associated with the call. + Failures []types.LayerFailure + + // A list of image layer objects that correspond to the image layer references in + // the request. + Layers []types.Layer + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *BatchCheckLayerAvailabilityOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.BatchCheckLayerAvailabilityResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *BatchCheckLayerAvailabilityOutput) SerializeMembers(s smithy.ShapeSerializer) { + serializeLayerFailureList(s, schemas.BatchCheckLayerAvailabilityResponse_failures, v.Failures) + serializeLayerList(s, schemas.BatchCheckLayerAvailabilityResponse_layers, v.Layers) +} +func (v *BatchCheckLayerAvailabilityOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.BatchCheckLayerAvailabilityResponse, func(s *smithy.Schema) error { + switch s { + case schemas.BatchCheckLayerAvailabilityResponse_failures: + return deserializeLayerFailureList(d, schemas.BatchCheckLayerAvailabilityResponse_failures, &v.Failures) + case schemas.BatchCheckLayerAvailabilityResponse_layers: + return deserializeLayerList(d, schemas.BatchCheckLayerAvailabilityResponse_layers, &v.Layers) + } + return nil + }) +} +func (c *Client) addOperationBatchCheckLayerAvailabilityMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.BatchCheckLayerAvailability, schemas.BatchCheckLayerAvailabilityRequest, schemas.BatchCheckLayerAvailabilityResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.BatchCheckLayerAvailability, schemas.BatchCheckLayerAvailabilityRequest, schemas.BatchCheckLayerAvailabilityResponse), output: &BatchCheckLayerAvailabilityOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpBatchCheckLayerAvailabilityValidationMiddleware(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_BatchDeleteImage.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_BatchDeleteImage.go new file mode 100644 index 0000000..a4f3efe --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_BatchDeleteImage.go @@ -0,0 +1,148 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" +) + +// Deletes a list of specified images that are within a repository in a public +// registry. Images are specified with either an imageTag or imageDigest . +// +// You can remove a tag from an image by specifying the image's tag in your +// request. When you remove the last tag from an image, the image is deleted from +// your repository. +// +// You can completely delete an image (and all of its tags) by specifying the +// digest of the image in your request. +func (c *Client) BatchDeleteImage(ctx context.Context, params *BatchDeleteImageInput, optFns ...func(*Options)) (*BatchDeleteImageOutput, error) { + if params == nil { + params = &BatchDeleteImageInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "BatchDeleteImage", params, optFns, c.addOperationBatchDeleteImageMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*BatchDeleteImageOutput) + out.ResultMetadata = metadata + return out, nil +} + +type BatchDeleteImageInput struct { + + // A list of image ID references that correspond to images to delete. The format + // of the imageIds reference is imageTag=tag or imageDigest=digest . + // + // This member is required. + ImageIds []types.ImageIdentifier + + // The repository in a public registry that contains the image to delete. + // + // This member is required. + RepositoryName *string + + // The Amazon Web Services account ID, or registry alias, that's associated with + // the registry that contains the image to delete. If you do not specify a + // registry, the default public registry is assumed. + RegistryId *string + + noSmithyDocumentSerde +} + +func (v *BatchDeleteImageInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.BatchDeleteImageRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *BatchDeleteImageInput) SerializeMembers(s smithy.ShapeSerializer) { + serializeImageIdentifierList(s, schemas.BatchDeleteImageRequest_imageIds, v.ImageIds) + if v.RegistryId != nil { + s.WriteString(schemas.BatchDeleteImageRequest_registryId, *v.RegistryId) + } + if v.RepositoryName != nil { + s.WriteString(schemas.BatchDeleteImageRequest_repositoryName, *v.RepositoryName) + } +} + +type BatchDeleteImageOutput struct { + + // Any failures associated with the call. + Failures []types.ImageFailure + + // The image IDs of the deleted images. + ImageIds []types.ImageIdentifier + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *BatchDeleteImageOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.BatchDeleteImageResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *BatchDeleteImageOutput) SerializeMembers(s smithy.ShapeSerializer) { + serializeImageFailureList(s, schemas.BatchDeleteImageResponse_failures, v.Failures) + serializeImageIdentifierList(s, schemas.BatchDeleteImageResponse_imageIds, v.ImageIds) +} +func (v *BatchDeleteImageOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.BatchDeleteImageResponse, func(s *smithy.Schema) error { + switch s { + case schemas.BatchDeleteImageResponse_failures: + return deserializeImageFailureList(d, schemas.BatchDeleteImageResponse_failures, &v.Failures) + case schemas.BatchDeleteImageResponse_imageIds: + return deserializeImageIdentifierList(d, schemas.BatchDeleteImageResponse_imageIds, &v.ImageIds) + } + return nil + }) +} +func (c *Client) addOperationBatchDeleteImageMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.BatchDeleteImage, schemas.BatchDeleteImageRequest, schemas.BatchDeleteImageResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.BatchDeleteImage, schemas.BatchDeleteImageRequest, schemas.BatchDeleteImageResponse), output: &BatchDeleteImageOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpBatchDeleteImageValidationMiddleware(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_CompleteLayerUpload.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_CompleteLayerUpload.go new file mode 100644 index 0000000..aa5c58a --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_CompleteLayerUpload.go @@ -0,0 +1,180 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" +) + +// Informs Amazon ECR that the image layer upload is complete for a specified +// public registry, repository name, and upload ID. You can optionally provide a +// sha256 digest of the image layer for data validation purposes. +// +// When an image is pushed, the CompleteLayerUpload API is called once for each +// new image layer to verify that the upload is complete. +// +// This operation is used by the Amazon ECR proxy and is not generally used by +// customers for pulling and pushing images. In most cases, you should use the +// docker CLI to pull, tag, and push images. +func (c *Client) CompleteLayerUpload(ctx context.Context, params *CompleteLayerUploadInput, optFns ...func(*Options)) (*CompleteLayerUploadOutput, error) { + if params == nil { + params = &CompleteLayerUploadInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "CompleteLayerUpload", params, optFns, c.addOperationCompleteLayerUploadMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*CompleteLayerUploadOutput) + out.ResultMetadata = metadata + return out, nil +} + +type CompleteLayerUploadInput struct { + + // The sha256 digest of the image layer. + // + // This member is required. + LayerDigests []string + + // The name of the repository in a public registry to associate with the image + // layer. + // + // This member is required. + RepositoryName *string + + // The upload ID from a previous InitiateLayerUpload operation to associate with the image layer. + // + // This member is required. + UploadId *string + + // The Amazon Web Services account ID, or registry alias, associated with the + // registry where layers are uploaded. If you do not specify a registry, the + // default public registry is assumed. + RegistryId *string + + noSmithyDocumentSerde +} + +func (v *CompleteLayerUploadInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.CompleteLayerUploadRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *CompleteLayerUploadInput) SerializeMembers(s smithy.ShapeSerializer) { + serializeLayerDigestList(s, schemas.CompleteLayerUploadRequest_layerDigests, v.LayerDigests) + if v.RegistryId != nil { + s.WriteString(schemas.CompleteLayerUploadRequest_registryId, *v.RegistryId) + } + if v.RepositoryName != nil { + s.WriteString(schemas.CompleteLayerUploadRequest_repositoryName, *v.RepositoryName) + } + if v.UploadId != nil { + s.WriteString(schemas.CompleteLayerUploadRequest_uploadId, *v.UploadId) + } +} + +type CompleteLayerUploadOutput struct { + + // The sha256 digest of the image layer. + LayerDigest *string + + // The public registry ID that's associated with the request. + RegistryId *string + + // The repository name that's associated with the request. + RepositoryName *string + + // The upload ID that's associated with the layer. + UploadId *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *CompleteLayerUploadOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.CompleteLayerUploadResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *CompleteLayerUploadOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.LayerDigest != nil { + s.WriteString(schemas.CompleteLayerUploadResponse_layerDigest, *v.LayerDigest) + } + if v.RegistryId != nil { + s.WriteString(schemas.CompleteLayerUploadResponse_registryId, *v.RegistryId) + } + if v.RepositoryName != nil { + s.WriteString(schemas.CompleteLayerUploadResponse_repositoryName, *v.RepositoryName) + } + if v.UploadId != nil { + s.WriteString(schemas.CompleteLayerUploadResponse_uploadId, *v.UploadId) + } +} +func (v *CompleteLayerUploadOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.CompleteLayerUploadResponse, func(s *smithy.Schema) error { + switch s { + case schemas.CompleteLayerUploadResponse_layerDigest: + v.LayerDigest = new(string) + return d.ReadString(schemas.CompleteLayerUploadResponse_layerDigest, v.LayerDigest) + case schemas.CompleteLayerUploadResponse_registryId: + v.RegistryId = new(string) + return d.ReadString(schemas.CompleteLayerUploadResponse_registryId, v.RegistryId) + case schemas.CompleteLayerUploadResponse_repositoryName: + v.RepositoryName = new(string) + return d.ReadString(schemas.CompleteLayerUploadResponse_repositoryName, v.RepositoryName) + case schemas.CompleteLayerUploadResponse_uploadId: + v.UploadId = new(string) + return d.ReadString(schemas.CompleteLayerUploadResponse_uploadId, v.UploadId) + } + return nil + }) +} +func (c *Client) addOperationCompleteLayerUploadMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.CompleteLayerUpload, schemas.CompleteLayerUploadRequest, schemas.CompleteLayerUploadResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.CompleteLayerUpload, schemas.CompleteLayerUploadRequest, schemas.CompleteLayerUploadResponse), output: &CompleteLayerUploadOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpCompleteLayerUploadValidationMiddleware(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_CreateRepository.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_CreateRepository.go new file mode 100644 index 0000000..d6994f8 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_CreateRepository.go @@ -0,0 +1,158 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" +) + +// Creates a repository in a public registry. For more information, see [Amazon ECR repositories] in the +// Amazon Elastic Container Registry User Guide. +// +// [Amazon ECR repositories]: https://docs.aws.amazon.com/AmazonECR/latest/userguide/Repositories.html +func (c *Client) CreateRepository(ctx context.Context, params *CreateRepositoryInput, optFns ...func(*Options)) (*CreateRepositoryOutput, error) { + if params == nil { + params = &CreateRepositoryInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "CreateRepository", params, optFns, c.addOperationCreateRepositoryMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*CreateRepositoryOutput) + out.ResultMetadata = metadata + return out, nil +} + +type CreateRepositoryInput struct { + + // The name to use for the repository. This appears publicly in the Amazon ECR + // Public Gallery. The repository name can be specified on its own (for example + // nginx-web-app ) or prepended with a namespace to group the repository into a + // category (for example project-a/nginx-web-app ). + // + // This member is required. + RepositoryName *string + + // The details about the repository that are publicly visible in the Amazon ECR + // Public Gallery. + CatalogData *types.RepositoryCatalogDataInput + + // The metadata that you apply to each repository to help categorize and organize + // your repositories. Each tag consists of a key and an optional value. You define + // both of them. Tag keys can have a maximum character length of 128 characters, + // and tag values can have a maximum length of 256 characters. + Tags []types.Tag + + noSmithyDocumentSerde +} + +func (v *CreateRepositoryInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.CreateRepositoryRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *CreateRepositoryInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.CatalogData != nil { + s.WriteStruct(schemas.CreateRepositoryRequest_catalogData) + v.CatalogData.SerializeMembers(s) + s.CloseStruct() + } + if v.RepositoryName != nil { + s.WriteString(schemas.CreateRepositoryRequest_repositoryName, *v.RepositoryName) + } + serializeTagList(s, schemas.CreateRepositoryRequest_tags, v.Tags) +} + +type CreateRepositoryOutput struct { + + // The catalog data for a repository. This data is publicly visible in the Amazon + // ECR Public Gallery. + CatalogData *types.RepositoryCatalogData + + // The repository that was created. + Repository *types.Repository + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *CreateRepositoryOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.CreateRepositoryResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *CreateRepositoryOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.CatalogData != nil { + s.WriteStruct(schemas.CreateRepositoryResponse_catalogData) + v.CatalogData.SerializeMembers(s) + s.CloseStruct() + } + if v.Repository != nil { + s.WriteStruct(schemas.CreateRepositoryResponse_repository) + v.Repository.SerializeMembers(s) + s.CloseStruct() + } +} +func (v *CreateRepositoryOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.CreateRepositoryResponse, func(s *smithy.Schema) error { + switch s { + case schemas.CreateRepositoryResponse_catalogData: + v.CatalogData = &types.RepositoryCatalogData{} + return v.CatalogData.Deserialize(d) + case schemas.CreateRepositoryResponse_repository: + v.Repository = &types.Repository{} + return v.Repository.Deserialize(d) + } + return nil + }) +} +func (c *Client) addOperationCreateRepositoryMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.CreateRepository, schemas.CreateRepositoryRequest, schemas.CreateRepositoryResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.CreateRepository, schemas.CreateRepositoryRequest, schemas.CreateRepositoryResponse), output: &CreateRepositoryOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpCreateRepositoryValidationMiddleware(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_DeleteRepository.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_DeleteRepository.go new file mode 100644 index 0000000..0cd63eb --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_DeleteRepository.go @@ -0,0 +1,142 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" +) + +// Deletes a repository in a public registry. If the repository contains images, +// you must either manually delete all images in the repository or use the force +// option. This option deletes all images on your behalf before deleting the +// repository. +func (c *Client) DeleteRepository(ctx context.Context, params *DeleteRepositoryInput, optFns ...func(*Options)) (*DeleteRepositoryOutput, error) { + if params == nil { + params = &DeleteRepositoryInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DeleteRepository", params, optFns, c.addOperationDeleteRepositoryMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DeleteRepositoryOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DeleteRepositoryInput struct { + + // The name of the repository to delete. + // + // This member is required. + RepositoryName *string + + // The force option can be used to delete a repository that contains images. If + // the force option is not used, the repository must be empty prior to deletion. + Force bool + + // The Amazon Web Services account ID that's associated with the public registry + // that contains the repository to delete. If you do not specify a registry, the + // default public registry is assumed. + RegistryId *string + + noSmithyDocumentSerde +} + +func (v *DeleteRepositoryInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DeleteRepositoryRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DeleteRepositoryInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.Force != false { + s.WriteBool(schemas.DeleteRepositoryRequest_force, v.Force) + } + if v.RegistryId != nil { + s.WriteString(schemas.DeleteRepositoryRequest_registryId, *v.RegistryId) + } + if v.RepositoryName != nil { + s.WriteString(schemas.DeleteRepositoryRequest_repositoryName, *v.RepositoryName) + } +} + +type DeleteRepositoryOutput struct { + + // The repository that was deleted. + Repository *types.Repository + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *DeleteRepositoryOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DeleteRepositoryResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DeleteRepositoryOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.Repository != nil { + s.WriteStruct(schemas.DeleteRepositoryResponse_repository) + v.Repository.SerializeMembers(s) + s.CloseStruct() + } +} +func (v *DeleteRepositoryOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.DeleteRepositoryResponse, func(s *smithy.Schema) error { + switch s { + case schemas.DeleteRepositoryResponse_repository: + v.Repository = &types.Repository{} + return v.Repository.Deserialize(d) + } + return nil + }) +} +func (c *Client) addOperationDeleteRepositoryMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DeleteRepository, schemas.DeleteRepositoryRequest, schemas.DeleteRepositoryResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DeleteRepository, schemas.DeleteRepositoryRequest, schemas.DeleteRepositoryResponse), output: &DeleteRepositoryOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpDeleteRepositoryValidationMiddleware(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_DeleteRepositoryPolicy.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_DeleteRepositoryPolicy.go new file mode 100644 index 0000000..88a517f --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_DeleteRepositoryPolicy.go @@ -0,0 +1,148 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" +) + +// Deletes the repository policy that's associated with the specified repository. +func (c *Client) DeleteRepositoryPolicy(ctx context.Context, params *DeleteRepositoryPolicyInput, optFns ...func(*Options)) (*DeleteRepositoryPolicyOutput, error) { + if params == nil { + params = &DeleteRepositoryPolicyInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DeleteRepositoryPolicy", params, optFns, c.addOperationDeleteRepositoryPolicyMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DeleteRepositoryPolicyOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DeleteRepositoryPolicyInput struct { + + // The name of the repository that's associated with the repository policy to + // delete. + // + // This member is required. + RepositoryName *string + + // The Amazon Web Services account ID that's associated with the public registry + // that contains the repository policy to delete. If you do not specify a registry, + // the default public registry is assumed. + RegistryId *string + + noSmithyDocumentSerde +} + +func (v *DeleteRepositoryPolicyInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DeleteRepositoryPolicyRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DeleteRepositoryPolicyInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.RegistryId != nil { + s.WriteString(schemas.DeleteRepositoryPolicyRequest_registryId, *v.RegistryId) + } + if v.RepositoryName != nil { + s.WriteString(schemas.DeleteRepositoryPolicyRequest_repositoryName, *v.RepositoryName) + } +} + +type DeleteRepositoryPolicyOutput struct { + + // The JSON repository policy that was deleted from the repository. + PolicyText *string + + // The registry ID that's associated with the request. + RegistryId *string + + // The repository name that's associated with the request. + RepositoryName *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *DeleteRepositoryPolicyOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DeleteRepositoryPolicyResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DeleteRepositoryPolicyOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.PolicyText != nil { + s.WriteString(schemas.DeleteRepositoryPolicyResponse_policyText, *v.PolicyText) + } + if v.RegistryId != nil { + s.WriteString(schemas.DeleteRepositoryPolicyResponse_registryId, *v.RegistryId) + } + if v.RepositoryName != nil { + s.WriteString(schemas.DeleteRepositoryPolicyResponse_repositoryName, *v.RepositoryName) + } +} +func (v *DeleteRepositoryPolicyOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.DeleteRepositoryPolicyResponse, func(s *smithy.Schema) error { + switch s { + case schemas.DeleteRepositoryPolicyResponse_policyText: + v.PolicyText = new(string) + return d.ReadString(schemas.DeleteRepositoryPolicyResponse_policyText, v.PolicyText) + case schemas.DeleteRepositoryPolicyResponse_registryId: + v.RegistryId = new(string) + return d.ReadString(schemas.DeleteRepositoryPolicyResponse_registryId, v.RegistryId) + case schemas.DeleteRepositoryPolicyResponse_repositoryName: + v.RepositoryName = new(string) + return d.ReadString(schemas.DeleteRepositoryPolicyResponse_repositoryName, v.RepositoryName) + } + return nil + }) +} +func (c *Client) addOperationDeleteRepositoryPolicyMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DeleteRepositoryPolicy, schemas.DeleteRepositoryPolicyRequest, schemas.DeleteRepositoryPolicyResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DeleteRepositoryPolicy, schemas.DeleteRepositoryPolicyRequest, schemas.DeleteRepositoryPolicyResponse), output: &DeleteRepositoryPolicyOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpDeleteRepositoryPolicyValidationMiddleware(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_DescribeImageTags.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_DescribeImageTags.go new file mode 100644 index 0000000..85d0082 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_DescribeImageTags.go @@ -0,0 +1,263 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "fmt" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" +) + +// Returns the image tag details for a repository in a public registry. +func (c *Client) DescribeImageTags(ctx context.Context, params *DescribeImageTagsInput, optFns ...func(*Options)) (*DescribeImageTagsOutput, error) { + if params == nil { + params = &DescribeImageTagsInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DescribeImageTags", params, optFns, c.addOperationDescribeImageTagsMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DescribeImageTagsOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DescribeImageTagsInput struct { + + // The name of the repository that contains the image tag details to describe. + // + // This member is required. + RepositoryName *string + + // The maximum number of repository results that's returned by DescribeImageTags + // in paginated output. When this parameter is used, DescribeImageTags only + // returns maxResults results in a single page along with a nextToken response + // element. You can see the remaining results of the initial request by sending + // another DescribeImageTags request with the returned nextToken value. This value + // can be between 1 and 1000. If this parameter isn't used, then DescribeImageTags + // returns up to 100 results and a nextToken value, if applicable. If you specify + // images with imageIds , you can't use this option. + MaxResults *int32 + + // The nextToken value that's returned from a previous paginated DescribeImageTags + // request where maxResults was used and the results exceeded the value of that + // parameter. Pagination continues from the end of the previous results that + // returned the nextToken value. If there are no more results to return, this + // value is null . If you specify images with imageIds , you can't use this option. + NextToken *string + + // The Amazon Web Services account ID that's associated with the public registry + // that contains the repository where images are described. If you do not specify a + // registry, the default public registry is assumed. + RegistryId *string + + noSmithyDocumentSerde +} + +func (v *DescribeImageTagsInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DescribeImageTagsRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DescribeImageTagsInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.MaxResults != nil { + s.WriteInt32(schemas.DescribeImageTagsRequest_maxResults, *v.MaxResults) + } + if v.NextToken != nil { + s.WriteString(schemas.DescribeImageTagsRequest_nextToken, *v.NextToken) + } + if v.RegistryId != nil { + s.WriteString(schemas.DescribeImageTagsRequest_registryId, *v.RegistryId) + } + if v.RepositoryName != nil { + s.WriteString(schemas.DescribeImageTagsRequest_repositoryName, *v.RepositoryName) + } +} + +type DescribeImageTagsOutput struct { + + // The image tag details for the images in the requested repository. + ImageTagDetails []types.ImageTagDetail + + // The nextToken value to include in a future DescribeImageTags request. When the + // results of a DescribeImageTags request exceed maxResults , you can use this + // value to retrieve the next page of results. If there are no more results to + // return, this value is null . + NextToken *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *DescribeImageTagsOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DescribeImageTagsResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DescribeImageTagsOutput) SerializeMembers(s smithy.ShapeSerializer) { + serializeImageTagDetailList(s, schemas.DescribeImageTagsResponse_imageTagDetails, v.ImageTagDetails) + if v.NextToken != nil { + s.WriteString(schemas.DescribeImageTagsResponse_nextToken, *v.NextToken) + } +} +func (v *DescribeImageTagsOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.DescribeImageTagsResponse, func(s *smithy.Schema) error { + switch s { + case schemas.DescribeImageTagsResponse_imageTagDetails: + return deserializeImageTagDetailList(d, schemas.DescribeImageTagsResponse_imageTagDetails, &v.ImageTagDetails) + case schemas.DescribeImageTagsResponse_nextToken: + v.NextToken = new(string) + return d.ReadString(schemas.DescribeImageTagsResponse_nextToken, v.NextToken) + } + return nil + }) +} +func (c *Client) addOperationDescribeImageTagsMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DescribeImageTags, schemas.DescribeImageTagsRequest, schemas.DescribeImageTagsResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DescribeImageTags, schemas.DescribeImageTagsRequest, schemas.DescribeImageTagsResponse), output: &DescribeImageTagsOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpDescribeImageTagsValidationMiddleware(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +// DescribeImageTagsPaginatorOptions is the paginator options for DescribeImageTags +type DescribeImageTagsPaginatorOptions struct { + // The maximum number of repository results that's returned by DescribeImageTags + // in paginated output. When this parameter is used, DescribeImageTags only + // returns maxResults results in a single page along with a nextToken response + // element. You can see the remaining results of the initial request by sending + // another DescribeImageTags request with the returned nextToken value. This value + // can be between 1 and 1000. If this parameter isn't used, then DescribeImageTags + // returns up to 100 results and a nextToken value, if applicable. If you specify + // images with imageIds , you can't use this option. + Limit int32 + + // Set to true if pagination should stop if the service returns a pagination token + // that matches the most recent token provided to the service. + StopOnDuplicateToken bool +} + +// DescribeImageTagsPaginator is a paginator for DescribeImageTags +type DescribeImageTagsPaginator struct { + options DescribeImageTagsPaginatorOptions + client DescribeImageTagsAPIClient + params *DescribeImageTagsInput + nextToken *string + firstPage bool +} + +// NewDescribeImageTagsPaginator returns a new DescribeImageTagsPaginator +func NewDescribeImageTagsPaginator(client DescribeImageTagsAPIClient, params *DescribeImageTagsInput, optFns ...func(*DescribeImageTagsPaginatorOptions)) *DescribeImageTagsPaginator { + if params == nil { + params = &DescribeImageTagsInput{} + } + + options := DescribeImageTagsPaginatorOptions{} + if params.MaxResults != nil { + options.Limit = *params.MaxResults + } + + for _, fn := range optFns { + fn(&options) + } + + return &DescribeImageTagsPaginator{ + options: options, + client: client, + params: params, + firstPage: true, + nextToken: params.NextToken, + } +} + +// HasMorePages returns a boolean indicating whether more pages are available +func (p *DescribeImageTagsPaginator) HasMorePages() bool { + return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0) +} + +// NextPage retrieves the next DescribeImageTags page. +func (p *DescribeImageTagsPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeImageTagsOutput, error) { + if !p.HasMorePages() { + return nil, fmt.Errorf("no more pages available") + } + + params := *p.params + params.NextToken = p.nextToken + + var limit *int32 + if p.options.Limit > 0 { + limit = &p.options.Limit + } + params.MaxResults = limit + + optFns = append([]func(*Options){ + addIsPaginatorUserAgent, + }, optFns...) + result, err := p.client.DescribeImageTags(ctx, ¶ms, optFns...) + if err != nil { + return nil, err + } + p.firstPage = false + + prevToken := p.nextToken + p.nextToken = result.NextToken + + if p.options.StopOnDuplicateToken && + prevToken != nil && + p.nextToken != nil && + *prevToken == *p.nextToken { + p.nextToken = nil + } + + return result, nil +} + +// DescribeImageTagsAPIClient is a client that implements the DescribeImageTags +// operation. +type DescribeImageTagsAPIClient interface { + DescribeImageTags(context.Context, *DescribeImageTagsInput, ...func(*Options)) (*DescribeImageTagsOutput, error) +} + +var _ DescribeImageTagsAPIClient = (*Client)(nil) diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_DescribeImages.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_DescribeImages.go new file mode 100644 index 0000000..d57a111 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_DescribeImages.go @@ -0,0 +1,273 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "fmt" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" +) + +// Returns metadata that's related to the images in a repository in a public +// registry. +// +// Beginning with Docker version 1.9, the Docker client compresses image layers +// before pushing them to a V2 Docker registry. The output of the docker images +// command shows the uncompressed image size. Therefore, it might return a larger +// image size than the image sizes that are returned by DescribeImages. +func (c *Client) DescribeImages(ctx context.Context, params *DescribeImagesInput, optFns ...func(*Options)) (*DescribeImagesOutput, error) { + if params == nil { + params = &DescribeImagesInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DescribeImages", params, optFns, c.addOperationDescribeImagesMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DescribeImagesOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DescribeImagesInput struct { + + // The repository that contains the images to describe. + // + // This member is required. + RepositoryName *string + + // The list of image IDs for the requested repository. + ImageIds []types.ImageIdentifier + + // The maximum number of repository results that's returned by DescribeImages in + // paginated output. When this parameter is used, DescribeImages only returns + // maxResults results in a single page along with a nextToken response element. + // You can see the remaining results of the initial request by sending another + // DescribeImages request with the returned nextToken value. This value can be + // between 1 and 1000. If this parameter isn't used, then DescribeImages returns + // up to 100 results and a nextToken value, if applicable. If you specify images + // with imageIds , you can't use this option. + MaxResults *int32 + + // The nextToken value that's returned from a previous paginated DescribeImages + // request where maxResults was used and the results exceeded the value of that + // parameter. Pagination continues from the end of the previous results that + // returned the nextToken value. If there are no more results to return, this + // value is null . If you specify images with imageIds , you can't use this option. + NextToken *string + + // The Amazon Web Services account ID that's associated with the public registry + // that contains the repository where images are described. If you do not specify a + // registry, the default public registry is assumed. + RegistryId *string + + noSmithyDocumentSerde +} + +func (v *DescribeImagesInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DescribeImagesRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DescribeImagesInput) SerializeMembers(s smithy.ShapeSerializer) { + serializeImageIdentifierList(s, schemas.DescribeImagesRequest_imageIds, v.ImageIds) + if v.MaxResults != nil { + s.WriteInt32(schemas.DescribeImagesRequest_maxResults, *v.MaxResults) + } + if v.NextToken != nil { + s.WriteString(schemas.DescribeImagesRequest_nextToken, *v.NextToken) + } + if v.RegistryId != nil { + s.WriteString(schemas.DescribeImagesRequest_registryId, *v.RegistryId) + } + if v.RepositoryName != nil { + s.WriteString(schemas.DescribeImagesRequest_repositoryName, *v.RepositoryName) + } +} + +type DescribeImagesOutput struct { + + // A list of ImageDetail objects that contain data about the image. + ImageDetails []types.ImageDetail + + // The nextToken value to include in a future DescribeImages request. When the + // results of a DescribeImages request exceed maxResults , you can use this value + // to retrieve the next page of results. If there are no more results to return, + // this value is null . + NextToken *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *DescribeImagesOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DescribeImagesResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DescribeImagesOutput) SerializeMembers(s smithy.ShapeSerializer) { + serializeImageDetailList(s, schemas.DescribeImagesResponse_imageDetails, v.ImageDetails) + if v.NextToken != nil { + s.WriteString(schemas.DescribeImagesResponse_nextToken, *v.NextToken) + } +} +func (v *DescribeImagesOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.DescribeImagesResponse, func(s *smithy.Schema) error { + switch s { + case schemas.DescribeImagesResponse_imageDetails: + return deserializeImageDetailList(d, schemas.DescribeImagesResponse_imageDetails, &v.ImageDetails) + case schemas.DescribeImagesResponse_nextToken: + v.NextToken = new(string) + return d.ReadString(schemas.DescribeImagesResponse_nextToken, v.NextToken) + } + return nil + }) +} +func (c *Client) addOperationDescribeImagesMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DescribeImages, schemas.DescribeImagesRequest, schemas.DescribeImagesResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DescribeImages, schemas.DescribeImagesRequest, schemas.DescribeImagesResponse), output: &DescribeImagesOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpDescribeImagesValidationMiddleware(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +// DescribeImagesPaginatorOptions is the paginator options for DescribeImages +type DescribeImagesPaginatorOptions struct { + // The maximum number of repository results that's returned by DescribeImages in + // paginated output. When this parameter is used, DescribeImages only returns + // maxResults results in a single page along with a nextToken response element. + // You can see the remaining results of the initial request by sending another + // DescribeImages request with the returned nextToken value. This value can be + // between 1 and 1000. If this parameter isn't used, then DescribeImages returns + // up to 100 results and a nextToken value, if applicable. If you specify images + // with imageIds , you can't use this option. + Limit int32 + + // Set to true if pagination should stop if the service returns a pagination token + // that matches the most recent token provided to the service. + StopOnDuplicateToken bool +} + +// DescribeImagesPaginator is a paginator for DescribeImages +type DescribeImagesPaginator struct { + options DescribeImagesPaginatorOptions + client DescribeImagesAPIClient + params *DescribeImagesInput + nextToken *string + firstPage bool +} + +// NewDescribeImagesPaginator returns a new DescribeImagesPaginator +func NewDescribeImagesPaginator(client DescribeImagesAPIClient, params *DescribeImagesInput, optFns ...func(*DescribeImagesPaginatorOptions)) *DescribeImagesPaginator { + if params == nil { + params = &DescribeImagesInput{} + } + + options := DescribeImagesPaginatorOptions{} + if params.MaxResults != nil { + options.Limit = *params.MaxResults + } + + for _, fn := range optFns { + fn(&options) + } + + return &DescribeImagesPaginator{ + options: options, + client: client, + params: params, + firstPage: true, + nextToken: params.NextToken, + } +} + +// HasMorePages returns a boolean indicating whether more pages are available +func (p *DescribeImagesPaginator) HasMorePages() bool { + return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0) +} + +// NextPage retrieves the next DescribeImages page. +func (p *DescribeImagesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeImagesOutput, error) { + if !p.HasMorePages() { + return nil, fmt.Errorf("no more pages available") + } + + params := *p.params + params.NextToken = p.nextToken + + var limit *int32 + if p.options.Limit > 0 { + limit = &p.options.Limit + } + params.MaxResults = limit + + optFns = append([]func(*Options){ + addIsPaginatorUserAgent, + }, optFns...) + result, err := p.client.DescribeImages(ctx, ¶ms, optFns...) + if err != nil { + return nil, err + } + p.firstPage = false + + prevToken := p.nextToken + p.nextToken = result.NextToken + + if p.options.StopOnDuplicateToken && + prevToken != nil && + p.nextToken != nil && + *prevToken == *p.nextToken { + p.nextToken = nil + } + + return result, nil +} + +// DescribeImagesAPIClient is a client that implements the DescribeImages +// operation. +type DescribeImagesAPIClient interface { + DescribeImages(context.Context, *DescribeImagesInput, ...func(*Options)) (*DescribeImagesOutput, error) +} + +var _ DescribeImagesAPIClient = (*Client)(nil) diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_DescribeRegistries.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_DescribeRegistries.go new file mode 100644 index 0000000..3f9e026 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_DescribeRegistries.go @@ -0,0 +1,250 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "fmt" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" +) + +// Returns details for a public registry. +func (c *Client) DescribeRegistries(ctx context.Context, params *DescribeRegistriesInput, optFns ...func(*Options)) (*DescribeRegistriesOutput, error) { + if params == nil { + params = &DescribeRegistriesInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DescribeRegistries", params, optFns, c.addOperationDescribeRegistriesMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DescribeRegistriesOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DescribeRegistriesInput struct { + + // The maximum number of repository results that's returned by DescribeRegistries + // in paginated output. When this parameter is used, DescribeRegistries only + // returns maxResults results in a single page along with a nextToken response + // element. The remaining results of the initial request can be seen by sending + // another DescribeRegistries request with the returned nextToken value. This + // value can be between 1 and 1000. If this parameter isn't used, then + // DescribeRegistries returns up to 100 results and a nextToken value, if + // applicable. + MaxResults *int32 + + // The nextToken value that's returned from a previous paginated DescribeRegistries + // request where maxResults was used and the results exceeded the value of that + // parameter. Pagination continues from the end of the previous results that + // returned the nextToken value. If there are no more results to return, this + // value is null . + // + // This token should be treated as an opaque identifier that is only used to + // retrieve the next items in a list and not for other programmatic purposes. + NextToken *string + + noSmithyDocumentSerde +} + +func (v *DescribeRegistriesInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DescribeRegistriesRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DescribeRegistriesInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.MaxResults != nil { + s.WriteInt32(schemas.DescribeRegistriesRequest_maxResults, *v.MaxResults) + } + if v.NextToken != nil { + s.WriteString(schemas.DescribeRegistriesRequest_nextToken, *v.NextToken) + } +} + +type DescribeRegistriesOutput struct { + + // An object that contains the details for a public registry. + // + // This member is required. + Registries []types.Registry + + // The nextToken value to include in a future DescribeRepositories request. If the + // results of a DescribeRepositories request exceed maxResults , you can use this + // value to retrieve the next page of results. If there are no more results, this + // value is null . + NextToken *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *DescribeRegistriesOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DescribeRegistriesResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DescribeRegistriesOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.NextToken != nil { + s.WriteString(schemas.DescribeRegistriesResponse_nextToken, *v.NextToken) + } + serializeRegistryList(s, schemas.DescribeRegistriesResponse_registries, v.Registries) +} +func (v *DescribeRegistriesOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.DescribeRegistriesResponse, func(s *smithy.Schema) error { + switch s { + case schemas.DescribeRegistriesResponse_nextToken: + v.NextToken = new(string) + return d.ReadString(schemas.DescribeRegistriesResponse_nextToken, v.NextToken) + case schemas.DescribeRegistriesResponse_registries: + return deserializeRegistryList(d, schemas.DescribeRegistriesResponse_registries, &v.Registries) + } + return nil + }) +} +func (c *Client) addOperationDescribeRegistriesMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DescribeRegistries, schemas.DescribeRegistriesRequest, schemas.DescribeRegistriesResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DescribeRegistries, schemas.DescribeRegistriesRequest, schemas.DescribeRegistriesResponse), output: &DescribeRegistriesOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +// DescribeRegistriesPaginatorOptions is the paginator options for +// DescribeRegistries +type DescribeRegistriesPaginatorOptions struct { + // The maximum number of repository results that's returned by DescribeRegistries + // in paginated output. When this parameter is used, DescribeRegistries only + // returns maxResults results in a single page along with a nextToken response + // element. The remaining results of the initial request can be seen by sending + // another DescribeRegistries request with the returned nextToken value. This + // value can be between 1 and 1000. If this parameter isn't used, then + // DescribeRegistries returns up to 100 results and a nextToken value, if + // applicable. + Limit int32 + + // Set to true if pagination should stop if the service returns a pagination token + // that matches the most recent token provided to the service. + StopOnDuplicateToken bool +} + +// DescribeRegistriesPaginator is a paginator for DescribeRegistries +type DescribeRegistriesPaginator struct { + options DescribeRegistriesPaginatorOptions + client DescribeRegistriesAPIClient + params *DescribeRegistriesInput + nextToken *string + firstPage bool +} + +// NewDescribeRegistriesPaginator returns a new DescribeRegistriesPaginator +func NewDescribeRegistriesPaginator(client DescribeRegistriesAPIClient, params *DescribeRegistriesInput, optFns ...func(*DescribeRegistriesPaginatorOptions)) *DescribeRegistriesPaginator { + if params == nil { + params = &DescribeRegistriesInput{} + } + + options := DescribeRegistriesPaginatorOptions{} + if params.MaxResults != nil { + options.Limit = *params.MaxResults + } + + for _, fn := range optFns { + fn(&options) + } + + return &DescribeRegistriesPaginator{ + options: options, + client: client, + params: params, + firstPage: true, + nextToken: params.NextToken, + } +} + +// HasMorePages returns a boolean indicating whether more pages are available +func (p *DescribeRegistriesPaginator) HasMorePages() bool { + return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0) +} + +// NextPage retrieves the next DescribeRegistries page. +func (p *DescribeRegistriesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeRegistriesOutput, error) { + if !p.HasMorePages() { + return nil, fmt.Errorf("no more pages available") + } + + params := *p.params + params.NextToken = p.nextToken + + var limit *int32 + if p.options.Limit > 0 { + limit = &p.options.Limit + } + params.MaxResults = limit + + optFns = append([]func(*Options){ + addIsPaginatorUserAgent, + }, optFns...) + result, err := p.client.DescribeRegistries(ctx, ¶ms, optFns...) + if err != nil { + return nil, err + } + p.firstPage = false + + prevToken := p.nextToken + p.nextToken = result.NextToken + + if p.options.StopOnDuplicateToken && + prevToken != nil && + p.nextToken != nil && + *prevToken == *p.nextToken { + p.nextToken = nil + } + + return result, nil +} + +// DescribeRegistriesAPIClient is a client that implements the DescribeRegistries +// operation. +type DescribeRegistriesAPIClient interface { + DescribeRegistries(context.Context, *DescribeRegistriesInput, ...func(*Options)) (*DescribeRegistriesOutput, error) +} + +var _ DescribeRegistriesAPIClient = (*Client)(nil) diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_DescribeRepositories.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_DescribeRepositories.go new file mode 100644 index 0000000..726661d --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_DescribeRepositories.go @@ -0,0 +1,264 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "fmt" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" +) + +// Describes repositories that are in a public registry. +func (c *Client) DescribeRepositories(ctx context.Context, params *DescribeRepositoriesInput, optFns ...func(*Options)) (*DescribeRepositoriesOutput, error) { + if params == nil { + params = &DescribeRepositoriesInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "DescribeRepositories", params, optFns, c.addOperationDescribeRepositoriesMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*DescribeRepositoriesOutput) + out.ResultMetadata = metadata + return out, nil +} + +type DescribeRepositoriesInput struct { + + // The maximum number of repository results that's returned by DescribeRepositories + // in paginated output. When this parameter is used, DescribeRepositories only + // returns maxResults results in a single page along with a nextToken response + // element. You can see the remaining results of the initial request by sending + // another DescribeRepositories request with the returned nextToken value. This + // value can be between 1 and 1000. If this parameter isn't used, then + // DescribeRepositories returns up to 100 results and a nextToken value, if + // applicable. If you specify repositories with repositoryNames , you can't use + // this option. + MaxResults *int32 + + // The nextToken value that's returned from a previous paginated + // DescribeRepositories request where maxResults was used and the results exceeded + // the value of that parameter. Pagination continues from the end of the previous + // results that returned the nextToken value. If there are no more results to + // return, this value is null . If you specify repositories with repositoryNames , + // you can't use this option. + // + // This token should be treated as an opaque identifier that is only used to + // retrieve the next items in a list and not for other programmatic purposes. + NextToken *string + + // The Amazon Web Services account ID that's associated with the registry that + // contains the repositories to be described. If you do not specify a registry, the + // default public registry is assumed. + RegistryId *string + + // A list of repositories to describe. If this parameter is omitted, then all + // repositories in a registry are described. + RepositoryNames []string + + noSmithyDocumentSerde +} + +func (v *DescribeRepositoriesInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DescribeRepositoriesRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DescribeRepositoriesInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.MaxResults != nil { + s.WriteInt32(schemas.DescribeRepositoriesRequest_maxResults, *v.MaxResults) + } + if v.NextToken != nil { + s.WriteString(schemas.DescribeRepositoriesRequest_nextToken, *v.NextToken) + } + if v.RegistryId != nil { + s.WriteString(schemas.DescribeRepositoriesRequest_registryId, *v.RegistryId) + } + serializeRepositoryNameList(s, schemas.DescribeRepositoriesRequest_repositoryNames, v.RepositoryNames) +} + +type DescribeRepositoriesOutput struct { + + // The nextToken value to include in a future DescribeRepositories request. When + // the results of a DescribeRepositories request exceed maxResults , this value can + // be used to retrieve the next page of results. If there are no more results to + // return, this value is null . + NextToken *string + + // A list of repository objects corresponding to valid repositories. + Repositories []types.Repository + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *DescribeRepositoriesOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.DescribeRepositoriesResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *DescribeRepositoriesOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.NextToken != nil { + s.WriteString(schemas.DescribeRepositoriesResponse_nextToken, *v.NextToken) + } + serializeRepositoryList(s, schemas.DescribeRepositoriesResponse_repositories, v.Repositories) +} +func (v *DescribeRepositoriesOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.DescribeRepositoriesResponse, func(s *smithy.Schema) error { + switch s { + case schemas.DescribeRepositoriesResponse_nextToken: + v.NextToken = new(string) + return d.ReadString(schemas.DescribeRepositoriesResponse_nextToken, v.NextToken) + case schemas.DescribeRepositoriesResponse_repositories: + return deserializeRepositoryList(d, schemas.DescribeRepositoriesResponse_repositories, &v.Repositories) + } + return nil + }) +} +func (c *Client) addOperationDescribeRepositoriesMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DescribeRepositories, schemas.DescribeRepositoriesRequest, schemas.DescribeRepositoriesResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.DescribeRepositories, schemas.DescribeRepositoriesRequest, schemas.DescribeRepositoriesResponse), output: &DescribeRepositoriesOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} + +// DescribeRepositoriesPaginatorOptions is the paginator options for +// DescribeRepositories +type DescribeRepositoriesPaginatorOptions struct { + // The maximum number of repository results that's returned by DescribeRepositories + // in paginated output. When this parameter is used, DescribeRepositories only + // returns maxResults results in a single page along with a nextToken response + // element. You can see the remaining results of the initial request by sending + // another DescribeRepositories request with the returned nextToken value. This + // value can be between 1 and 1000. If this parameter isn't used, then + // DescribeRepositories returns up to 100 results and a nextToken value, if + // applicable. If you specify repositories with repositoryNames , you can't use + // this option. + Limit int32 + + // Set to true if pagination should stop if the service returns a pagination token + // that matches the most recent token provided to the service. + StopOnDuplicateToken bool +} + +// DescribeRepositoriesPaginator is a paginator for DescribeRepositories +type DescribeRepositoriesPaginator struct { + options DescribeRepositoriesPaginatorOptions + client DescribeRepositoriesAPIClient + params *DescribeRepositoriesInput + nextToken *string + firstPage bool +} + +// NewDescribeRepositoriesPaginator returns a new DescribeRepositoriesPaginator +func NewDescribeRepositoriesPaginator(client DescribeRepositoriesAPIClient, params *DescribeRepositoriesInput, optFns ...func(*DescribeRepositoriesPaginatorOptions)) *DescribeRepositoriesPaginator { + if params == nil { + params = &DescribeRepositoriesInput{} + } + + options := DescribeRepositoriesPaginatorOptions{} + if params.MaxResults != nil { + options.Limit = *params.MaxResults + } + + for _, fn := range optFns { + fn(&options) + } + + return &DescribeRepositoriesPaginator{ + options: options, + client: client, + params: params, + firstPage: true, + nextToken: params.NextToken, + } +} + +// HasMorePages returns a boolean indicating whether more pages are available +func (p *DescribeRepositoriesPaginator) HasMorePages() bool { + return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0) +} + +// NextPage retrieves the next DescribeRepositories page. +func (p *DescribeRepositoriesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeRepositoriesOutput, error) { + if !p.HasMorePages() { + return nil, fmt.Errorf("no more pages available") + } + + params := *p.params + params.NextToken = p.nextToken + + var limit *int32 + if p.options.Limit > 0 { + limit = &p.options.Limit + } + params.MaxResults = limit + + optFns = append([]func(*Options){ + addIsPaginatorUserAgent, + }, optFns...) + result, err := p.client.DescribeRepositories(ctx, ¶ms, optFns...) + if err != nil { + return nil, err + } + p.firstPage = false + + prevToken := p.nextToken + p.nextToken = result.NextToken + + if p.options.StopOnDuplicateToken && + prevToken != nil && + p.nextToken != nil && + *prevToken == *p.nextToken { + p.nextToken = nil + } + + return result, nil +} + +// DescribeRepositoriesAPIClient is a client that implements the +// DescribeRepositories operation. +type DescribeRepositoriesAPIClient interface { + DescribeRepositories(context.Context, *DescribeRepositoriesInput, ...func(*Options)) (*DescribeRepositoriesOutput, error) +} + +var _ DescribeRepositoriesAPIClient = (*Client)(nil) diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_GetAuthorizationToken.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_GetAuthorizationToken.go new file mode 100644 index 0000000..a614868 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_GetAuthorizationToken.go @@ -0,0 +1,116 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" +) + +// Retrieves an authorization token. An authorization token represents your IAM +// authentication credentials. You can use it to access any Amazon ECR registry +// that your IAM principal has access to. The authorization token is valid for 12 +// hours. This API requires the ecr-public:GetAuthorizationToken and +// sts:GetServiceBearerToken permissions. +func (c *Client) GetAuthorizationToken(ctx context.Context, params *GetAuthorizationTokenInput, optFns ...func(*Options)) (*GetAuthorizationTokenOutput, error) { + if params == nil { + params = &GetAuthorizationTokenInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "GetAuthorizationToken", params, optFns, c.addOperationGetAuthorizationTokenMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*GetAuthorizationTokenOutput) + out.ResultMetadata = metadata + return out, nil +} + +type GetAuthorizationTokenInput struct { + noSmithyDocumentSerde +} + +func (v *GetAuthorizationTokenInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.GetAuthorizationTokenRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *GetAuthorizationTokenInput) SerializeMembers(s smithy.ShapeSerializer) { +} + +type GetAuthorizationTokenOutput struct { + + // An authorization token data object that corresponds to a public registry. + AuthorizationData *types.AuthorizationData + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *GetAuthorizationTokenOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.GetAuthorizationTokenResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *GetAuthorizationTokenOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.AuthorizationData != nil { + s.WriteStruct(schemas.GetAuthorizationTokenResponse_authorizationData) + v.AuthorizationData.SerializeMembers(s) + s.CloseStruct() + } +} +func (v *GetAuthorizationTokenOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.GetAuthorizationTokenResponse, func(s *smithy.Schema) error { + switch s { + case schemas.GetAuthorizationTokenResponse_authorizationData: + v.AuthorizationData = &types.AuthorizationData{} + return v.AuthorizationData.Deserialize(d) + } + return nil + }) +} +func (c *Client) addOperationGetAuthorizationTokenMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.GetAuthorizationToken, schemas.GetAuthorizationTokenRequest, schemas.GetAuthorizationTokenResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.GetAuthorizationToken, schemas.GetAuthorizationTokenRequest, schemas.GetAuthorizationTokenResponse), output: &GetAuthorizationTokenOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_GetRegistryCatalogData.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_GetRegistryCatalogData.go new file mode 100644 index 0000000..f86bfdc --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_GetRegistryCatalogData.go @@ -0,0 +1,114 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" +) + +// Retrieves catalog metadata for a public registry. +func (c *Client) GetRegistryCatalogData(ctx context.Context, params *GetRegistryCatalogDataInput, optFns ...func(*Options)) (*GetRegistryCatalogDataOutput, error) { + if params == nil { + params = &GetRegistryCatalogDataInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "GetRegistryCatalogData", params, optFns, c.addOperationGetRegistryCatalogDataMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*GetRegistryCatalogDataOutput) + out.ResultMetadata = metadata + return out, nil +} + +type GetRegistryCatalogDataInput struct { + noSmithyDocumentSerde +} + +func (v *GetRegistryCatalogDataInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.GetRegistryCatalogDataRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *GetRegistryCatalogDataInput) SerializeMembers(s smithy.ShapeSerializer) { +} + +type GetRegistryCatalogDataOutput struct { + + // The catalog metadata for the public registry. + // + // This member is required. + RegistryCatalogData *types.RegistryCatalogData + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *GetRegistryCatalogDataOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.GetRegistryCatalogDataResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *GetRegistryCatalogDataOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.RegistryCatalogData != nil { + s.WriteStruct(schemas.GetRegistryCatalogDataResponse_registryCatalogData) + v.RegistryCatalogData.SerializeMembers(s) + s.CloseStruct() + } +} +func (v *GetRegistryCatalogDataOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.GetRegistryCatalogDataResponse, func(s *smithy.Schema) error { + switch s { + case schemas.GetRegistryCatalogDataResponse_registryCatalogData: + v.RegistryCatalogData = &types.RegistryCatalogData{} + return v.RegistryCatalogData.Deserialize(d) + } + return nil + }) +} +func (c *Client) addOperationGetRegistryCatalogDataMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.GetRegistryCatalogData, schemas.GetRegistryCatalogDataRequest, schemas.GetRegistryCatalogDataResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.GetRegistryCatalogData, schemas.GetRegistryCatalogDataRequest, schemas.GetRegistryCatalogDataResponse), output: &GetRegistryCatalogDataOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_GetRepositoryCatalogData.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_GetRepositoryCatalogData.go new file mode 100644 index 0000000..b587115 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_GetRepositoryCatalogData.go @@ -0,0 +1,133 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" +) + +// Retrieve catalog metadata for a repository in a public registry. This metadata +// is displayed publicly in the Amazon ECR Public Gallery. +func (c *Client) GetRepositoryCatalogData(ctx context.Context, params *GetRepositoryCatalogDataInput, optFns ...func(*Options)) (*GetRepositoryCatalogDataOutput, error) { + if params == nil { + params = &GetRepositoryCatalogDataInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "GetRepositoryCatalogData", params, optFns, c.addOperationGetRepositoryCatalogDataMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*GetRepositoryCatalogDataOutput) + out.ResultMetadata = metadata + return out, nil +} + +type GetRepositoryCatalogDataInput struct { + + // The name of the repository to retrieve the catalog metadata for. + // + // This member is required. + RepositoryName *string + + // The Amazon Web Services account ID that's associated with the registry that + // contains the repositories to be described. If you do not specify a registry, the + // default public registry is assumed. + RegistryId *string + + noSmithyDocumentSerde +} + +func (v *GetRepositoryCatalogDataInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.GetRepositoryCatalogDataRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *GetRepositoryCatalogDataInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.RegistryId != nil { + s.WriteString(schemas.GetRepositoryCatalogDataRequest_registryId, *v.RegistryId) + } + if v.RepositoryName != nil { + s.WriteString(schemas.GetRepositoryCatalogDataRequest_repositoryName, *v.RepositoryName) + } +} + +type GetRepositoryCatalogDataOutput struct { + + // The catalog metadata for the repository. + CatalogData *types.RepositoryCatalogData + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *GetRepositoryCatalogDataOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.GetRepositoryCatalogDataResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *GetRepositoryCatalogDataOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.CatalogData != nil { + s.WriteStruct(schemas.GetRepositoryCatalogDataResponse_catalogData) + v.CatalogData.SerializeMembers(s) + s.CloseStruct() + } +} +func (v *GetRepositoryCatalogDataOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.GetRepositoryCatalogDataResponse, func(s *smithy.Schema) error { + switch s { + case schemas.GetRepositoryCatalogDataResponse_catalogData: + v.CatalogData = &types.RepositoryCatalogData{} + return v.CatalogData.Deserialize(d) + } + return nil + }) +} +func (c *Client) addOperationGetRepositoryCatalogDataMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.GetRepositoryCatalogData, schemas.GetRepositoryCatalogDataRequest, schemas.GetRepositoryCatalogDataResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.GetRepositoryCatalogData, schemas.GetRepositoryCatalogDataRequest, schemas.GetRepositoryCatalogDataResponse), output: &GetRepositoryCatalogDataOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpGetRepositoryCatalogDataValidationMiddleware(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_GetRepositoryPolicy.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_GetRepositoryPolicy.go new file mode 100644 index 0000000..37365f2 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_GetRepositoryPolicy.go @@ -0,0 +1,148 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" +) + +// Retrieves the repository policy for the specified repository. +func (c *Client) GetRepositoryPolicy(ctx context.Context, params *GetRepositoryPolicyInput, optFns ...func(*Options)) (*GetRepositoryPolicyOutput, error) { + if params == nil { + params = &GetRepositoryPolicyInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "GetRepositoryPolicy", params, optFns, c.addOperationGetRepositoryPolicyMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*GetRepositoryPolicyOutput) + out.ResultMetadata = metadata + return out, nil +} + +type GetRepositoryPolicyInput struct { + + // The name of the repository with the policy to retrieve. + // + // This member is required. + RepositoryName *string + + // The Amazon Web Services account ID that's associated with the public registry + // that contains the repository. If you do not specify a registry, the default + // public registry is assumed. + RegistryId *string + + noSmithyDocumentSerde +} + +func (v *GetRepositoryPolicyInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.GetRepositoryPolicyRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *GetRepositoryPolicyInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.RegistryId != nil { + s.WriteString(schemas.GetRepositoryPolicyRequest_registryId, *v.RegistryId) + } + if v.RepositoryName != nil { + s.WriteString(schemas.GetRepositoryPolicyRequest_repositoryName, *v.RepositoryName) + } +} + +type GetRepositoryPolicyOutput struct { + + // The repository policy text that's associated with the repository. The policy + // text will be in JSON format. + PolicyText *string + + // The registry ID that's associated with the request. + RegistryId *string + + // The repository name that's associated with the request. + RepositoryName *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *GetRepositoryPolicyOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.GetRepositoryPolicyResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *GetRepositoryPolicyOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.PolicyText != nil { + s.WriteString(schemas.GetRepositoryPolicyResponse_policyText, *v.PolicyText) + } + if v.RegistryId != nil { + s.WriteString(schemas.GetRepositoryPolicyResponse_registryId, *v.RegistryId) + } + if v.RepositoryName != nil { + s.WriteString(schemas.GetRepositoryPolicyResponse_repositoryName, *v.RepositoryName) + } +} +func (v *GetRepositoryPolicyOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.GetRepositoryPolicyResponse, func(s *smithy.Schema) error { + switch s { + case schemas.GetRepositoryPolicyResponse_policyText: + v.PolicyText = new(string) + return d.ReadString(schemas.GetRepositoryPolicyResponse_policyText, v.PolicyText) + case schemas.GetRepositoryPolicyResponse_registryId: + v.RegistryId = new(string) + return d.ReadString(schemas.GetRepositoryPolicyResponse_registryId, v.RegistryId) + case schemas.GetRepositoryPolicyResponse_repositoryName: + v.RepositoryName = new(string) + return d.ReadString(schemas.GetRepositoryPolicyResponse_repositoryName, v.RepositoryName) + } + return nil + }) +} +func (c *Client) addOperationGetRepositoryPolicyMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.GetRepositoryPolicy, schemas.GetRepositoryPolicyRequest, schemas.GetRepositoryPolicyResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.GetRepositoryPolicy, schemas.GetRepositoryPolicyRequest, schemas.GetRepositoryPolicyResponse), output: &GetRepositoryPolicyOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpGetRepositoryPolicyValidationMiddleware(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_InitiateLayerUpload.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_InitiateLayerUpload.go new file mode 100644 index 0000000..aaaa901 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_InitiateLayerUpload.go @@ -0,0 +1,147 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" +) + +// Notifies Amazon ECR that you intend to upload an image layer. +// +// When an image is pushed, the InitiateLayerUpload API is called once for each +// image layer that hasn't already been uploaded. Whether an image layer uploads is +// determined by the BatchCheckLayerAvailability API action. +// +// This operation is used by the Amazon ECR proxy and is not generally used by +// customers for pulling and pushing images. In most cases, you should use the +// docker CLI to pull, tag, and push images. +func (c *Client) InitiateLayerUpload(ctx context.Context, params *InitiateLayerUploadInput, optFns ...func(*Options)) (*InitiateLayerUploadOutput, error) { + if params == nil { + params = &InitiateLayerUploadInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "InitiateLayerUpload", params, optFns, c.addOperationInitiateLayerUploadMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*InitiateLayerUploadOutput) + out.ResultMetadata = metadata + return out, nil +} + +type InitiateLayerUploadInput struct { + + // The name of the repository that you want to upload layers to. + // + // This member is required. + RepositoryName *string + + // The Amazon Web Services account ID, or registry alias, that's associated with + // the registry to which you intend to upload layers. If you do not specify a + // registry, the default public registry is assumed. + RegistryId *string + + noSmithyDocumentSerde +} + +func (v *InitiateLayerUploadInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.InitiateLayerUploadRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *InitiateLayerUploadInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.RegistryId != nil { + s.WriteString(schemas.InitiateLayerUploadRequest_registryId, *v.RegistryId) + } + if v.RepositoryName != nil { + s.WriteString(schemas.InitiateLayerUploadRequest_repositoryName, *v.RepositoryName) + } +} + +type InitiateLayerUploadOutput struct { + + // The size, in bytes, that Amazon ECR expects future layer part uploads to be. + PartSize *int64 + + // The upload ID for the layer upload. This parameter is passed to further UploadLayerPart and CompleteLayerUpload + // operations. + UploadId *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *InitiateLayerUploadOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.InitiateLayerUploadResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *InitiateLayerUploadOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.PartSize != nil { + s.WriteInt64(schemas.InitiateLayerUploadResponse_partSize, *v.PartSize) + } + if v.UploadId != nil { + s.WriteString(schemas.InitiateLayerUploadResponse_uploadId, *v.UploadId) + } +} +func (v *InitiateLayerUploadOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.InitiateLayerUploadResponse, func(s *smithy.Schema) error { + switch s { + case schemas.InitiateLayerUploadResponse_partSize: + v.PartSize = new(int64) + return d.ReadInt64(schemas.InitiateLayerUploadResponse_partSize, v.PartSize) + case schemas.InitiateLayerUploadResponse_uploadId: + v.UploadId = new(string) + return d.ReadString(schemas.InitiateLayerUploadResponse_uploadId, v.UploadId) + } + return nil + }) +} +func (c *Client) addOperationInitiateLayerUploadMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.InitiateLayerUpload, schemas.InitiateLayerUploadRequest, schemas.InitiateLayerUploadResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.InitiateLayerUpload, schemas.InitiateLayerUploadRequest, schemas.InitiateLayerUploadResponse), output: &InitiateLayerUploadOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpInitiateLayerUploadValidationMiddleware(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_ListTagsForResource.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_ListTagsForResource.go new file mode 100644 index 0000000..7149d3e --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_ListTagsForResource.go @@ -0,0 +1,120 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" +) + +// List the tags for an Amazon ECR Public resource. +func (c *Client) ListTagsForResource(ctx context.Context, params *ListTagsForResourceInput, optFns ...func(*Options)) (*ListTagsForResourceOutput, error) { + if params == nil { + params = &ListTagsForResourceInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "ListTagsForResource", params, optFns, c.addOperationListTagsForResourceMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*ListTagsForResourceOutput) + out.ResultMetadata = metadata + return out, nil +} + +type ListTagsForResourceInput struct { + + // The Amazon Resource Name (ARN) that identifies the resource to list the tags + // for. Currently, the supported resource is an Amazon ECR Public repository. + // + // This member is required. + ResourceArn *string + + noSmithyDocumentSerde +} + +func (v *ListTagsForResourceInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ListTagsForResourceRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ListTagsForResourceInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.ResourceArn != nil { + s.WriteString(schemas.ListTagsForResourceRequest_resourceArn, *v.ResourceArn) + } +} + +type ListTagsForResourceOutput struct { + + // The tags for the resource. + Tags []types.Tag + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *ListTagsForResourceOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ListTagsForResourceResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ListTagsForResourceOutput) SerializeMembers(s smithy.ShapeSerializer) { + serializeTagList(s, schemas.ListTagsForResourceResponse_tags, v.Tags) +} +func (v *ListTagsForResourceOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ListTagsForResourceResponse, func(s *smithy.Schema) error { + switch s { + case schemas.ListTagsForResourceResponse_tags: + return deserializeTagList(d, schemas.ListTagsForResourceResponse_tags, &v.Tags) + } + return nil + }) +} +func (c *Client) addOperationListTagsForResourceMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.ListTagsForResource, schemas.ListTagsForResourceRequest, schemas.ListTagsForResourceResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.ListTagsForResource, schemas.ListTagsForResourceRequest, schemas.ListTagsForResourceResponse), output: &ListTagsForResourceOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpListTagsForResourceValidationMiddleware(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_PutImage.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_PutImage.go new file mode 100644 index 0000000..daaeb5f --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_PutImage.go @@ -0,0 +1,171 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" +) + +// Creates or updates the image manifest and tags that are associated with an +// image. +// +// When an image is pushed and all new image layers have been uploaded, the +// PutImage API is called once to create or update the image manifest and the tags +// that are associated with the image. +// +// This operation is used by the Amazon ECR proxy and is not generally used by +// customers for pulling and pushing images. In most cases, you should use the +// docker CLI to pull, tag, and push images. +func (c *Client) PutImage(ctx context.Context, params *PutImageInput, optFns ...func(*Options)) (*PutImageOutput, error) { + if params == nil { + params = &PutImageInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "PutImage", params, optFns, c.addOperationPutImageMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*PutImageOutput) + out.ResultMetadata = metadata + return out, nil +} + +type PutImageInput struct { + + // The image manifest that corresponds to the image to be uploaded. + // + // This member is required. + ImageManifest *string + + // The name of the repository where the image is put. + // + // This member is required. + RepositoryName *string + + // The image digest of the image manifest that corresponds to the image. + ImageDigest *string + + // The media type of the image manifest. If you push an image manifest that + // doesn't contain the mediaType field, you must specify the imageManifestMediaType + // in the request. + ImageManifestMediaType *string + + // The tag to associate with the image. This parameter is required for images that + // use the Docker Image Manifest V2 Schema 2 or Open Container Initiative (OCI) + // formats. + ImageTag *string + + // The Amazon Web Services account ID, or registry alias, that's associated with + // the public registry that contains the repository where the image is put. If you + // do not specify a registry, the default public registry is assumed. + RegistryId *string + + noSmithyDocumentSerde +} + +func (v *PutImageInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.PutImageRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *PutImageInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.ImageDigest != nil { + s.WriteString(schemas.PutImageRequest_imageDigest, *v.ImageDigest) + } + if v.ImageManifest != nil { + s.WriteString(schemas.PutImageRequest_imageManifest, *v.ImageManifest) + } + if v.ImageManifestMediaType != nil { + s.WriteString(schemas.PutImageRequest_imageManifestMediaType, *v.ImageManifestMediaType) + } + if v.ImageTag != nil { + s.WriteString(schemas.PutImageRequest_imageTag, *v.ImageTag) + } + if v.RegistryId != nil { + s.WriteString(schemas.PutImageRequest_registryId, *v.RegistryId) + } + if v.RepositoryName != nil { + s.WriteString(schemas.PutImageRequest_repositoryName, *v.RepositoryName) + } +} + +type PutImageOutput struct { + + // Details of the image uploaded. + Image *types.Image + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *PutImageOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.PutImageResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *PutImageOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.Image != nil { + s.WriteStruct(schemas.PutImageResponse_image) + v.Image.SerializeMembers(s) + s.CloseStruct() + } +} +func (v *PutImageOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.PutImageResponse, func(s *smithy.Schema) error { + switch s { + case schemas.PutImageResponse_image: + v.Image = &types.Image{} + return v.Image.Deserialize(d) + } + return nil + }) +} +func (c *Client) addOperationPutImageMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.PutImage, schemas.PutImageRequest, schemas.PutImageResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.PutImage, schemas.PutImageRequest, schemas.PutImageResponse), output: &PutImageOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpPutImageValidationMiddleware(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_PutRegistryCatalogData.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_PutRegistryCatalogData.go new file mode 100644 index 0000000..b9e7e9f --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_PutRegistryCatalogData.go @@ -0,0 +1,125 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" +) + +// Create or update the catalog data for a public registry. +func (c *Client) PutRegistryCatalogData(ctx context.Context, params *PutRegistryCatalogDataInput, optFns ...func(*Options)) (*PutRegistryCatalogDataOutput, error) { + if params == nil { + params = &PutRegistryCatalogDataInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "PutRegistryCatalogData", params, optFns, c.addOperationPutRegistryCatalogDataMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*PutRegistryCatalogDataOutput) + out.ResultMetadata = metadata + return out, nil +} + +type PutRegistryCatalogDataInput struct { + + // The display name for a public registry. The display name is shown as the + // repository author in the Amazon ECR Public Gallery. + // + // The registry display name is only publicly visible in the Amazon ECR Public + // Gallery for verified accounts. + DisplayName *string + + noSmithyDocumentSerde +} + +func (v *PutRegistryCatalogDataInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.PutRegistryCatalogDataRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *PutRegistryCatalogDataInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.DisplayName != nil { + s.WriteString(schemas.PutRegistryCatalogDataRequest_displayName, *v.DisplayName) + } +} + +type PutRegistryCatalogDataOutput struct { + + // The catalog data for the public registry. + // + // This member is required. + RegistryCatalogData *types.RegistryCatalogData + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *PutRegistryCatalogDataOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.PutRegistryCatalogDataResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *PutRegistryCatalogDataOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.RegistryCatalogData != nil { + s.WriteStruct(schemas.PutRegistryCatalogDataResponse_registryCatalogData) + v.RegistryCatalogData.SerializeMembers(s) + s.CloseStruct() + } +} +func (v *PutRegistryCatalogDataOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.PutRegistryCatalogDataResponse, func(s *smithy.Schema) error { + switch s { + case schemas.PutRegistryCatalogDataResponse_registryCatalogData: + v.RegistryCatalogData = &types.RegistryCatalogData{} + return v.RegistryCatalogData.Deserialize(d) + } + return nil + }) +} +func (c *Client) addOperationPutRegistryCatalogDataMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.PutRegistryCatalogData, schemas.PutRegistryCatalogDataRequest, schemas.PutRegistryCatalogDataResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.PutRegistryCatalogData, schemas.PutRegistryCatalogDataRequest, schemas.PutRegistryCatalogDataResponse), output: &PutRegistryCatalogDataOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_PutRepositoryCatalogData.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_PutRepositoryCatalogData.go new file mode 100644 index 0000000..3ed2cb2 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_PutRepositoryCatalogData.go @@ -0,0 +1,143 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" +) + +// Creates or updates the catalog data for a repository in a public registry. +func (c *Client) PutRepositoryCatalogData(ctx context.Context, params *PutRepositoryCatalogDataInput, optFns ...func(*Options)) (*PutRepositoryCatalogDataOutput, error) { + if params == nil { + params = &PutRepositoryCatalogDataInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "PutRepositoryCatalogData", params, optFns, c.addOperationPutRepositoryCatalogDataMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*PutRepositoryCatalogDataOutput) + out.ResultMetadata = metadata + return out, nil +} + +type PutRepositoryCatalogDataInput struct { + + // An object containing the catalog data for a repository. This data is publicly + // visible in the Amazon ECR Public Gallery. + // + // This member is required. + CatalogData *types.RepositoryCatalogDataInput + + // The name of the repository to create or update the catalog data for. + // + // This member is required. + RepositoryName *string + + // The Amazon Web Services account ID that's associated with the public registry + // the repository is in. If you do not specify a registry, the default public + // registry is assumed. + RegistryId *string + + noSmithyDocumentSerde +} + +func (v *PutRepositoryCatalogDataInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.PutRepositoryCatalogDataRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *PutRepositoryCatalogDataInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.CatalogData != nil { + s.WriteStruct(schemas.PutRepositoryCatalogDataRequest_catalogData) + v.CatalogData.SerializeMembers(s) + s.CloseStruct() + } + if v.RegistryId != nil { + s.WriteString(schemas.PutRepositoryCatalogDataRequest_registryId, *v.RegistryId) + } + if v.RepositoryName != nil { + s.WriteString(schemas.PutRepositoryCatalogDataRequest_repositoryName, *v.RepositoryName) + } +} + +type PutRepositoryCatalogDataOutput struct { + + // The catalog data for the repository. + CatalogData *types.RepositoryCatalogData + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *PutRepositoryCatalogDataOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.PutRepositoryCatalogDataResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *PutRepositoryCatalogDataOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.CatalogData != nil { + s.WriteStruct(schemas.PutRepositoryCatalogDataResponse_catalogData) + v.CatalogData.SerializeMembers(s) + s.CloseStruct() + } +} +func (v *PutRepositoryCatalogDataOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.PutRepositoryCatalogDataResponse, func(s *smithy.Schema) error { + switch s { + case schemas.PutRepositoryCatalogDataResponse_catalogData: + v.CatalogData = &types.RepositoryCatalogData{} + return v.CatalogData.Deserialize(d) + } + return nil + }) +} +func (c *Client) addOperationPutRepositoryCatalogDataMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.PutRepositoryCatalogData, schemas.PutRepositoryCatalogDataRequest, schemas.PutRepositoryCatalogDataResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.PutRepositoryCatalogData, schemas.PutRepositoryCatalogDataRequest, schemas.PutRepositoryCatalogDataResponse), output: &PutRepositoryCatalogDataOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpPutRepositoryCatalogDataValidationMiddleware(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_SetRepositoryPolicy.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_SetRepositoryPolicy.go new file mode 100644 index 0000000..ebbed64 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_SetRepositoryPolicy.go @@ -0,0 +1,170 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" +) + +// Applies a repository policy to the specified public repository to control +// access permissions. For more information, see [Amazon ECR Repository Policies]in the Amazon Elastic Container +// Registry User Guide. +// +// [Amazon ECR Repository Policies]: https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-policies.html +func (c *Client) SetRepositoryPolicy(ctx context.Context, params *SetRepositoryPolicyInput, optFns ...func(*Options)) (*SetRepositoryPolicyOutput, error) { + if params == nil { + params = &SetRepositoryPolicyInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "SetRepositoryPolicy", params, optFns, c.addOperationSetRepositoryPolicyMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*SetRepositoryPolicyOutput) + out.ResultMetadata = metadata + return out, nil +} + +type SetRepositoryPolicyInput struct { + + // The JSON repository policy text to apply to the repository. For more + // information, see [Amazon ECR Repository Policies]in the Amazon Elastic Container Registry User Guide. + // + // [Amazon ECR Repository Policies]: https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-policy-examples.html + // + // This member is required. + PolicyText *string + + // The name of the repository to receive the policy. + // + // This member is required. + RepositoryName *string + + // If the policy that you want to set on a repository policy would prevent you + // from setting another policy in the future, you must force the SetRepositoryPolicyoperation. This + // prevents accidental repository lockouts. + Force bool + + // The Amazon Web Services account ID that's associated with the registry that + // contains the repository. If you do not specify a registry, the default public + // registry is assumed. + RegistryId *string + + noSmithyDocumentSerde +} + +func (v *SetRepositoryPolicyInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.SetRepositoryPolicyRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *SetRepositoryPolicyInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.Force != false { + s.WriteBool(schemas.SetRepositoryPolicyRequest_force, v.Force) + } + if v.PolicyText != nil { + s.WriteString(schemas.SetRepositoryPolicyRequest_policyText, *v.PolicyText) + } + if v.RegistryId != nil { + s.WriteString(schemas.SetRepositoryPolicyRequest_registryId, *v.RegistryId) + } + if v.RepositoryName != nil { + s.WriteString(schemas.SetRepositoryPolicyRequest_repositoryName, *v.RepositoryName) + } +} + +type SetRepositoryPolicyOutput struct { + + // The JSON repository policy text that's applied to the repository. + PolicyText *string + + // The registry ID that's associated with the request. + RegistryId *string + + // The repository name that's associated with the request. + RepositoryName *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *SetRepositoryPolicyOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.SetRepositoryPolicyResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *SetRepositoryPolicyOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.PolicyText != nil { + s.WriteString(schemas.SetRepositoryPolicyResponse_policyText, *v.PolicyText) + } + if v.RegistryId != nil { + s.WriteString(schemas.SetRepositoryPolicyResponse_registryId, *v.RegistryId) + } + if v.RepositoryName != nil { + s.WriteString(schemas.SetRepositoryPolicyResponse_repositoryName, *v.RepositoryName) + } +} +func (v *SetRepositoryPolicyOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.SetRepositoryPolicyResponse, func(s *smithy.Schema) error { + switch s { + case schemas.SetRepositoryPolicyResponse_policyText: + v.PolicyText = new(string) + return d.ReadString(schemas.SetRepositoryPolicyResponse_policyText, v.PolicyText) + case schemas.SetRepositoryPolicyResponse_registryId: + v.RegistryId = new(string) + return d.ReadString(schemas.SetRepositoryPolicyResponse_registryId, v.RegistryId) + case schemas.SetRepositoryPolicyResponse_repositoryName: + v.RepositoryName = new(string) + return d.ReadString(schemas.SetRepositoryPolicyResponse_repositoryName, v.RepositoryName) + } + return nil + }) +} +func (c *Client) addOperationSetRepositoryPolicyMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.SetRepositoryPolicy, schemas.SetRepositoryPolicyRequest, schemas.SetRepositoryPolicyResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.SetRepositoryPolicy, schemas.SetRepositoryPolicyRequest, schemas.SetRepositoryPolicyResponse), output: &SetRepositoryPolicyOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpSetRepositoryPolicyValidationMiddleware(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_TagResource.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_TagResource.go new file mode 100644 index 0000000..f241636 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_TagResource.go @@ -0,0 +1,124 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/types" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" +) + +// Associates the specified tags to a resource with the specified resourceArn . If +// existing tags on a resource aren't specified in the request parameters, they +// aren't changed. When a resource is deleted, the tags associated with that +// resource are also deleted. +func (c *Client) TagResource(ctx context.Context, params *TagResourceInput, optFns ...func(*Options)) (*TagResourceOutput, error) { + if params == nil { + params = &TagResourceInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "TagResource", params, optFns, c.addOperationTagResourceMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*TagResourceOutput) + out.ResultMetadata = metadata + return out, nil +} + +type TagResourceInput struct { + + // The Amazon Resource Name (ARN) of the resource to add tags to. Currently, the + // supported resource is an Amazon ECR Public repository. + // + // This member is required. + ResourceArn *string + + // The tags to add to the resource. A tag is an array of key-value pairs. Tag keys + // can have a maximum character length of 128 characters, and tag values can have a + // maximum length of 256 characters. + // + // This member is required. + Tags []types.Tag + + noSmithyDocumentSerde +} + +func (v *TagResourceInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.TagResourceRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *TagResourceInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.ResourceArn != nil { + s.WriteString(schemas.TagResourceRequest_resourceArn, *v.ResourceArn) + } + serializeTagList(s, schemas.TagResourceRequest_tags, v.Tags) +} + +type TagResourceOutput struct { + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *TagResourceOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.TagResourceResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *TagResourceOutput) SerializeMembers(s smithy.ShapeSerializer) { +} +func (v *TagResourceOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.TagResourceResponse, func(s *smithy.Schema) error { + switch s { + } + return nil + }) +} +func (c *Client) addOperationTagResourceMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.TagResource, schemas.TagResourceRequest, schemas.TagResourceResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.TagResource, schemas.TagResourceRequest, schemas.TagResourceResponse), output: &TagResourceOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpTagResourceValidationMiddleware(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_UntagResource.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_UntagResource.go new file mode 100644 index 0000000..4301862 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_UntagResource.go @@ -0,0 +1,118 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" +) + +// Deletes specified tags from a resource. +func (c *Client) UntagResource(ctx context.Context, params *UntagResourceInput, optFns ...func(*Options)) (*UntagResourceOutput, error) { + if params == nil { + params = &UntagResourceInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "UntagResource", params, optFns, c.addOperationUntagResourceMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*UntagResourceOutput) + out.ResultMetadata = metadata + return out, nil +} + +type UntagResourceInput struct { + + // The Amazon Resource Name (ARN) of the resource to delete tags from. Currently, + // the supported resource is an Amazon ECR Public repository. + // + // This member is required. + ResourceArn *string + + // The keys of the tags to be removed. + // + // This member is required. + TagKeys []string + + noSmithyDocumentSerde +} + +func (v *UntagResourceInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.UntagResourceRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *UntagResourceInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.ResourceArn != nil { + s.WriteString(schemas.UntagResourceRequest_resourceArn, *v.ResourceArn) + } + serializeTagKeyList(s, schemas.UntagResourceRequest_tagKeys, v.TagKeys) +} + +type UntagResourceOutput struct { + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *UntagResourceOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.UntagResourceResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *UntagResourceOutput) SerializeMembers(s smithy.ShapeSerializer) { +} +func (v *UntagResourceOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.UntagResourceResponse, func(s *smithy.Schema) error { + switch s { + } + return nil + }) +} +func (c *Client) addOperationUntagResourceMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.UntagResource, schemas.UntagResourceRequest, schemas.UntagResourceResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.UntagResource, schemas.UntagResourceRequest, schemas.UntagResourceResponse), output: &UntagResourceOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpUntagResourceValidationMiddleware(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_UploadLayerPart.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_UploadLayerPart.go new file mode 100644 index 0000000..23c0fc9 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/api_op_UploadLayerPart.go @@ -0,0 +1,197 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" +) + +// Uploads an image layer part to Amazon ECR. +// +// When an image is pushed, each new image layer is uploaded in parts. The maximum +// size of each image layer part can be 20971520 bytes (about 20MB). The +// UploadLayerPart API is called once for each new image layer part. +// +// This operation is used by the Amazon ECR proxy and is not generally used by +// customers for pulling and pushing images. In most cases, you should use the +// docker CLI to pull, tag, and push images. +func (c *Client) UploadLayerPart(ctx context.Context, params *UploadLayerPartInput, optFns ...func(*Options)) (*UploadLayerPartOutput, error) { + if params == nil { + params = &UploadLayerPartInput{} + } + + result, metadata, err := c.invokeOperation(ctx, "UploadLayerPart", params, optFns, c.addOperationUploadLayerPartMiddlewares) + if err != nil { + return nil, err + } + + out := result.(*UploadLayerPartOutput) + out.ResultMetadata = metadata + return out, nil +} + +type UploadLayerPartInput struct { + + // The base64-encoded layer part payload. + // + // This member is required. + LayerPartBlob []byte + + // The position of the first byte of the layer part witin the overall image layer. + // + // This member is required. + PartFirstByte *int64 + + // The position of the last byte of the layer part within the overall image layer. + // + // This member is required. + PartLastByte *int64 + + // The name of the repository that you're uploading layer parts to. + // + // This member is required. + RepositoryName *string + + // The upload ID from a previous InitiateLayerUpload operation to associate with the layer part + // upload. + // + // This member is required. + UploadId *string + + // The Amazon Web Services account ID, or registry alias, that's associated with + // the registry that you're uploading layer parts to. If you do not specify a + // registry, the default public registry is assumed. + RegistryId *string + + noSmithyDocumentSerde +} + +func (v *UploadLayerPartInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.UploadLayerPartRequest) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *UploadLayerPartInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.LayerPartBlob != nil { + s.WriteBlob(schemas.UploadLayerPartRequest_layerPartBlob, v.LayerPartBlob) + } + if v.PartFirstByte != nil { + s.WriteInt64(schemas.UploadLayerPartRequest_partFirstByte, *v.PartFirstByte) + } + if v.PartLastByte != nil { + s.WriteInt64(schemas.UploadLayerPartRequest_partLastByte, *v.PartLastByte) + } + if v.RegistryId != nil { + s.WriteString(schemas.UploadLayerPartRequest_registryId, *v.RegistryId) + } + if v.RepositoryName != nil { + s.WriteString(schemas.UploadLayerPartRequest_repositoryName, *v.RepositoryName) + } + if v.UploadId != nil { + s.WriteString(schemas.UploadLayerPartRequest_uploadId, *v.UploadId) + } +} + +type UploadLayerPartOutput struct { + + // The integer value of the last byte that's received in the request. + LastByteReceived *int64 + + // The registry ID that's associated with the request. + RegistryId *string + + // The repository name that's associated with the request. + RepositoryName *string + + // The upload ID that's associated with the request. + UploadId *string + + // Metadata pertaining to the operation's result. + ResultMetadata middleware.Metadata + + noSmithyDocumentSerde +} + +func (v *UploadLayerPartOutput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.UploadLayerPartResponse) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *UploadLayerPartOutput) SerializeMembers(s smithy.ShapeSerializer) { + if v.LastByteReceived != nil { + s.WriteInt64(schemas.UploadLayerPartResponse_lastByteReceived, *v.LastByteReceived) + } + if v.RegistryId != nil { + s.WriteString(schemas.UploadLayerPartResponse_registryId, *v.RegistryId) + } + if v.RepositoryName != nil { + s.WriteString(schemas.UploadLayerPartResponse_repositoryName, *v.RepositoryName) + } + if v.UploadId != nil { + s.WriteString(schemas.UploadLayerPartResponse_uploadId, *v.UploadId) + } +} +func (v *UploadLayerPartOutput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.UploadLayerPartResponse, func(s *smithy.Schema) error { + switch s { + case schemas.UploadLayerPartResponse_lastByteReceived: + v.LastByteReceived = new(int64) + return d.ReadInt64(schemas.UploadLayerPartResponse_lastByteReceived, v.LastByteReceived) + case schemas.UploadLayerPartResponse_registryId: + v.RegistryId = new(string) + return d.ReadString(schemas.UploadLayerPartResponse_registryId, v.RegistryId) + case schemas.UploadLayerPartResponse_repositoryName: + v.RepositoryName = new(string) + return d.ReadString(schemas.UploadLayerPartResponse_repositoryName, v.RepositoryName) + case schemas.UploadLayerPartResponse_uploadId: + v.UploadId = new(string) + return d.ReadString(schemas.UploadLayerPartResponse_uploadId, v.UploadId) + } + return nil + }) +} +func (c *Client) addOperationUploadLayerPartMiddlewares(stack *middleware.Stack, options Options) (err error) { + if err := stack.Serialize.Add(&serializeRequestMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.UploadLayerPart, schemas.UploadLayerPartRequest, schemas.UploadLayerPartResponse)}, middleware.After); err != nil { + return err + } + if err := stack.Deserialize.Add(&deserializeResponseMiddleware{options: &options, operationSchema: smithy.NewOperationSchema(schemas.UploadLayerPart, schemas.UploadLayerPartRequest, schemas.UploadLayerPartResponse), output: &UploadLayerPartOutput{}}, middleware.After); err != nil { + return err + } + + if err = addResolveEndpointMiddleware(stack, options); err != nil { + return err + } + if err = addComputePayloadSHA256(stack); err != nil { + return err + } + if err = addRecordResponseTiming(stack, options); err != nil { + return err + } + if err = addCredentialSource(stack, options); err != nil { + return err + } + if err = addOpUploadLayerPartValidationMiddleware(stack); err != nil { + return err + } + if err = addRequestIDRetrieverMiddleware(stack); err != nil { + return err + } + if err = addResponseErrorMiddleware(stack); err != nil { + return err + } + if err = addRequestResponseLogging(stack, options); err != nil { + return err + } + if err = addDisableHTTPSMiddleware(stack, options); err != nil { + return err + } + if err = addInterceptors(stack, options); err != nil { + return err + } + return nil +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/auth.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/auth.go new file mode 100644 index 0000000..5570fc5 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/auth.go @@ -0,0 +1,355 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + smithy "github.com/aws/smithy-go" + smithyauth "github.com/aws/smithy-go/auth" + "github.com/aws/smithy-go/metrics" + "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/tracing" + smithyhttp "github.com/aws/smithy-go/transport/http" + "slices" + "strings" +) + +func bindAuthParamsRegion(_ interface{}, params *AuthResolverParameters, _ interface{}, options Options) error { + params.Region = options.Region + return nil +} + +type setLegacyContextSigningOptionsMiddleware struct { +} + +func (*setLegacyContextSigningOptionsMiddleware) ID() string { + return "setLegacyContextSigningOptions" +} + +func (m *setLegacyContextSigningOptionsMiddleware) HandleFinalize(ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler) ( + out middleware.FinalizeOutput, metadata middleware.Metadata, err error, +) { + rscheme := getResolvedAuthScheme(ctx) + schemeID := rscheme.Scheme.SchemeID() + + if sn := awsmiddleware.GetSigningName(ctx); sn != "" { + if schemeID == "aws.auth#sigv4" { + smithyhttp.SetSigV4SigningName(&rscheme.SignerProperties, sn) + } else if schemeID == "aws.auth#sigv4a" { + smithyhttp.SetSigV4ASigningName(&rscheme.SignerProperties, sn) + } + } + + if sr := awsmiddleware.GetSigningRegion(ctx); sr != "" { + if schemeID == "aws.auth#sigv4" { + smithyhttp.SetSigV4SigningRegion(&rscheme.SignerProperties, sr) + } else if schemeID == "aws.auth#sigv4a" { + smithyhttp.SetSigV4ASigningRegions(&rscheme.SignerProperties, []string{sr}) + } + } + + return next.HandleFinalize(ctx, in) +} + +func addSetLegacyContextSigningOptionsMiddleware(stack *middleware.Stack) error { + return stack.Finalize.Insert(&setLegacyContextSigningOptionsMiddleware{}, "Signing", middleware.Before) +} + +type withAnonymous struct { + resolver AuthSchemeResolver +} + +var _ AuthSchemeResolver = (*withAnonymous)(nil) + +func (v *withAnonymous) ResolveAuthSchemes(ctx context.Context, params *AuthResolverParameters) ([]*smithyauth.Option, error) { + opts, err := v.resolver.ResolveAuthSchemes(ctx, params) + if err != nil { + return nil, err + } + + opts = append(opts, &smithyauth.Option{ + SchemeID: smithyauth.SchemeIDAnonymous, + }) + return opts, nil +} + +func wrapWithAnonymousAuth(options *Options) { + if _, ok := options.AuthSchemeResolver.(*defaultAuthSchemeResolver); !ok { + return + } + + options.AuthSchemeResolver = &withAnonymous{ + resolver: options.AuthSchemeResolver, + } +} + +// AuthResolverParameters contains the set of inputs necessary for auth scheme +// resolution. +type AuthResolverParameters struct { + // The name of the operation being invoked. + Operation string + + // The region in which the operation is being invoked. + Region string +} + +func bindAuthResolverParams(ctx context.Context, operation string, input interface{}, options Options) (*AuthResolverParameters, error) { + params := &AuthResolverParameters{ + Operation: operation, + } + + if err := bindAuthParamsRegion(ctx, params, input, options); err != nil { + return nil, err + } + + return params, nil +} + +// AuthSchemeResolver returns a set of possible authentication options for an +// operation. +type AuthSchemeResolver interface { + ResolveAuthSchemes(context.Context, *AuthResolverParameters) ([]*smithyauth.Option, error) +} + +type defaultAuthSchemeResolver struct{} + +var _ AuthSchemeResolver = (*defaultAuthSchemeResolver)(nil) + +func (*defaultAuthSchemeResolver) ResolveAuthSchemes(ctx context.Context, params *AuthResolverParameters) ([]*smithyauth.Option, error) { + if overrides, ok := operationAuthOptions[params.Operation]; ok { + return overrides(params), nil + } + return serviceAuthOptions(params), nil +} + +var operationAuthOptions = map[string]func(*AuthResolverParameters) []*smithyauth.Option{} + +func serviceAuthOptions(params *AuthResolverParameters) []*smithyauth.Option { + return []*smithyauth.Option{ + { + SchemeID: smithyauth.SchemeIDSigV4, + SignerProperties: func() smithy.Properties { + var props smithy.Properties + smithyhttp.SetSigV4SigningName(&props, "ecr-public") + smithyhttp.SetSigV4SigningRegion(&props, params.Region) + return props + }(), + }, + } +} + +type resolveAuthSchemeMiddleware struct { + operation string + options Options +} + +func (*resolveAuthSchemeMiddleware) ID() string { + return "ResolveAuthScheme" +} + +func (m *resolveAuthSchemeMiddleware) HandleFinalize(ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler) ( + out middleware.FinalizeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "ResolveAuthScheme") + defer span.End() + + params, err := bindAuthResolverParams(ctx, m.operation, getOperationInput(ctx), m.options) + if err != nil { + return out, metadata, fmt.Errorf("bind auth scheme params: %w", err) + } + options, err := m.options.AuthSchemeResolver.ResolveAuthSchemes(ctx, params) + if err != nil { + return out, metadata, fmt.Errorf("resolve auth scheme: %w", err) + } + + scheme, ok := m.selectScheme(options) + if !ok { + return out, metadata, fmt.Errorf("could not select an auth scheme") + } + + ctx = setResolvedAuthScheme(ctx, scheme) + + span.SetProperty("auth.scheme_id", scheme.Scheme.SchemeID()) + span.End() + return next.HandleFinalize(ctx, in) +} + +func (m *resolveAuthSchemeMiddleware) selectScheme(options []*smithyauth.Option) (*resolvedAuthScheme, bool) { + sorted := sortAuthOptions(options, m.options.AuthSchemePreference) + for _, option := range sorted { + if option.SchemeID == smithyauth.SchemeIDAnonymous { + return newResolvedAuthScheme(smithyhttp.NewAnonymousScheme(), option), true + } + + for _, scheme := range m.options.AuthSchemes { + if !matchSchemeID(scheme.SchemeID(), option.SchemeID) { + continue + } + + if scheme.IdentityResolver(m.options) != nil { + return newResolvedAuthScheme(scheme, option), true + } + } + } + + return nil, false +} + +func matchSchemeID(registered, option string) bool { + if registered == option { + return true + } + if i := strings.LastIndex(registered, "#"); i != -1 { + return registered[i+1:] == option + } + return false +} + +func sortAuthOptions(options []*smithyauth.Option, preferred []string) []*smithyauth.Option { + byPriority := make([]*smithyauth.Option, 0, len(options)) + for _, prefName := range preferred { + for _, option := range options { + optName := option.SchemeID + if parts := strings.Split(option.SchemeID, "#"); len(parts) == 2 { + optName = parts[1] + } + if prefName == optName { + byPriority = append(byPriority, option) + } + } + } + for _, option := range options { + if !slices.ContainsFunc(byPriority, func(o *smithyauth.Option) bool { + return o.SchemeID == option.SchemeID + }) { + byPriority = append(byPriority, option) + } + } + return byPriority +} + +type resolvedAuthSchemeKey struct{} + +type resolvedAuthScheme struct { + Scheme smithyhttp.AuthScheme + IdentityProperties smithy.Properties + SignerProperties smithy.Properties +} + +func newResolvedAuthScheme(scheme smithyhttp.AuthScheme, option *smithyauth.Option) *resolvedAuthScheme { + return &resolvedAuthScheme{ + Scheme: scheme, + IdentityProperties: option.IdentityProperties, + SignerProperties: option.SignerProperties, + } +} + +func setResolvedAuthScheme(ctx context.Context, scheme *resolvedAuthScheme) context.Context { + return middleware.WithStackValue(ctx, resolvedAuthSchemeKey{}, scheme) +} + +func getResolvedAuthScheme(ctx context.Context) *resolvedAuthScheme { + v, _ := middleware.GetStackValue(ctx, resolvedAuthSchemeKey{}).(*resolvedAuthScheme) + return v +} + +type getIdentityMiddleware struct { + options Options +} + +func (*getIdentityMiddleware) ID() string { + return "GetIdentity" +} + +func (m *getIdentityMiddleware) HandleFinalize(ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler) ( + out middleware.FinalizeOutput, metadata middleware.Metadata, err error, +) { + innerCtx, span := tracing.StartSpan(ctx, "GetIdentity") + defer span.End() + + rscheme := getResolvedAuthScheme(innerCtx) + if rscheme == nil { + return out, metadata, fmt.Errorf("no resolved auth scheme") + } + + resolver := rscheme.Scheme.IdentityResolver(m.options) + if resolver == nil { + return out, metadata, fmt.Errorf("no identity resolver") + } + + identity, err := timeOperationMetric(ctx, "client.call.resolve_identity_duration", + func() (smithyauth.Identity, error) { + return resolver.GetIdentity(innerCtx, rscheme.IdentityProperties) + }, + func(o *metrics.RecordMetricOptions) { + o.Properties.Set("auth.scheme_id", rscheme.Scheme.SchemeID()) + }) + if err != nil { + return out, metadata, fmt.Errorf("get identity: %w", err) + } + + ctx = setIdentity(ctx, identity) + + span.End() + return next.HandleFinalize(ctx, in) +} + +type identityKey struct{} + +func setIdentity(ctx context.Context, identity smithyauth.Identity) context.Context { + return middleware.WithStackValue(ctx, identityKey{}, identity) +} + +func getIdentity(ctx context.Context) smithyauth.Identity { + v, _ := middleware.GetStackValue(ctx, identityKey{}).(smithyauth.Identity) + return v +} + +type signRequestMiddleware struct { + options Options +} + +func (*signRequestMiddleware) ID() string { + return "Signing" +} + +func (m *signRequestMiddleware) HandleFinalize(ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler) ( + out middleware.FinalizeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "SignRequest") + defer span.End() + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unexpected transport type %T", in.Request) + } + + rscheme := getResolvedAuthScheme(ctx) + if rscheme == nil { + return out, metadata, fmt.Errorf("no resolved auth scheme") + } + + identity := getIdentity(ctx) + if identity == nil { + return out, metadata, fmt.Errorf("no identity") + } + + signer := rscheme.Scheme.Signer() + if signer == nil { + return out, metadata, fmt.Errorf("no signer") + } + + _, err = timeOperationMetric(ctx, "client.call.signing_duration", func() (any, error) { + return nil, signer.SignRequest(ctx, req, identity, rscheme.SignerProperties) + }, func(o *metrics.RecordMetricOptions) { + o.Properties.Set("auth.scheme_id", rscheme.Scheme.SchemeID()) + }) + if err != nil { + return out, metadata, fmt.Errorf("sign request: %w", err) + } + + span.End() + return next.HandleFinalize(ctx, in) +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/common_serde.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/common_serde.go new file mode 100644 index 0000000..c6fcab0 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/common_serde.go @@ -0,0 +1,453 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/types" + smithy "github.com/aws/smithy-go" +) + +func serializeArchitectureList(s smithy.ShapeSerializer, schema *smithy.Schema, v []string) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeBatchedOperationLayerDigestList(s smithy.ShapeSerializer, schema *smithy.Schema, v []string) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeImageDetailList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.ImageDetail) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeImageFailureList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.ImageFailure) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeImageIdentifierList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.ImageIdentifier) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeImageTagDetailList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.ImageTagDetail) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeImageTagList(s smithy.ShapeSerializer, schema *smithy.Schema, v []string) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeLayerDigestList(s smithy.ShapeSerializer, schema *smithy.Schema, v []string) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeLayerFailureList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.LayerFailure) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeLayerList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.Layer) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeOperatingSystemList(s smithy.ShapeSerializer, schema *smithy.Schema, v []string) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeRegistryAliasList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.RegistryAlias) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeRegistryList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.Registry) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeRepositoryList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.Repository) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeRepositoryNameList(s smithy.ShapeSerializer, schema *smithy.Schema, v []string) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeTagKeyList(s smithy.ShapeSerializer, schema *smithy.Schema, v []string) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeTagList(s smithy.ShapeSerializer, schema *smithy.Schema, v []types.Tag) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func deserializeArchitectureList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]string) error { + *v = make([]string, 0) + var vv string + return smithy.ReadList(d, s, func() error { + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeBatchedOperationLayerDigestList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]string) error { + *v = make([]string, 0) + var vv string + return smithy.ReadList(d, s, func() error { + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeImageDetailList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.ImageDetail) error { + *v = make([]types.ImageDetail, 0) + var vv types.ImageDetail + return smithy.ReadList(d, s, func() error { + vv = types.ImageDetail{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeImageFailureList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.ImageFailure) error { + *v = make([]types.ImageFailure, 0) + var vv types.ImageFailure + return smithy.ReadList(d, s, func() error { + vv = types.ImageFailure{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeImageIdentifierList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.ImageIdentifier) error { + *v = make([]types.ImageIdentifier, 0) + var vv types.ImageIdentifier + return smithy.ReadList(d, s, func() error { + vv = types.ImageIdentifier{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeImageTagDetailList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.ImageTagDetail) error { + *v = make([]types.ImageTagDetail, 0) + var vv types.ImageTagDetail + return smithy.ReadList(d, s, func() error { + vv = types.ImageTagDetail{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeImageTagList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]string) error { + *v = make([]string, 0) + var vv string + return smithy.ReadList(d, s, func() error { + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeLayerDigestList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]string) error { + *v = make([]string, 0) + var vv string + return smithy.ReadList(d, s, func() error { + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeLayerFailureList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.LayerFailure) error { + *v = make([]types.LayerFailure, 0) + var vv types.LayerFailure + return smithy.ReadList(d, s, func() error { + vv = types.LayerFailure{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeLayerList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.Layer) error { + *v = make([]types.Layer, 0) + var vv types.Layer + return smithy.ReadList(d, s, func() error { + vv = types.Layer{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeOperatingSystemList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]string) error { + *v = make([]string, 0) + var vv string + return smithy.ReadList(d, s, func() error { + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeRegistryAliasList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.RegistryAlias) error { + *v = make([]types.RegistryAlias, 0) + var vv types.RegistryAlias + return smithy.ReadList(d, s, func() error { + vv = types.RegistryAlias{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeRegistryList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.Registry) error { + *v = make([]types.Registry, 0) + var vv types.Registry + return smithy.ReadList(d, s, func() error { + vv = types.Registry{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeRepositoryList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.Repository) error { + *v = make([]types.Repository, 0) + var vv types.Repository + return smithy.ReadList(d, s, func() error { + vv = types.Repository{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeRepositoryNameList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]string) error { + *v = make([]string, 0) + var vv string + return smithy.ReadList(d, s, func() error { + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeTagKeyList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]string) error { + *v = make([]string, 0) + var vv string + return smithy.ReadList(d, s, func() error { + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeTagList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]types.Tag) error { + *v = make([]types.Tag, 0) + var vv types.Tag + return smithy.ReadList(d, s, func() error { + vv = types.Tag{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/doc.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/doc.go new file mode 100644 index 0000000..0b5c510 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/doc.go @@ -0,0 +1,17 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +// Package ecrpublic provides the API client, operations, and parameter types for +// Amazon Elastic Container Registry Public. +// +// # Amazon Elastic Container Registry Public +// +// Amazon Elastic Container Registry Public (Amazon ECR Public) is a managed +// container image registry service. Amazon ECR provides both public and private +// registries to host your container images. You can use the Docker CLI or your +// preferred client to push, pull, and manage images. Amazon ECR provides a secure, +// scalable, and reliable registry for your Docker or Open Container Initiative +// (OCI) images. Amazon ECR supports public repositories with this API. For +// information about the Amazon ECR API for private repositories, see [Amazon Elastic Container Registry API Reference]. +// +// [Amazon Elastic Container Registry API Reference]: https://docs.aws.amazon.com/AmazonECR/latest/APIReference/Welcome.html +package ecrpublic diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/endpoints.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/endpoints.go new file mode 100644 index 0000000..d47a881 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/endpoints.go @@ -0,0 +1,570 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "errors" + "fmt" + "github.com/aws/aws-sdk-go-v2/aws" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + internalConfig "github.com/aws/aws-sdk-go-v2/internal/configsources" + "github.com/aws/aws-sdk-go-v2/internal/endpoints" + "github.com/aws/aws-sdk-go-v2/internal/endpoints/awsrulesfn" + internalendpoints "github.com/aws/aws-sdk-go-v2/service/ecrpublic/internal/endpoints" + smithyauth "github.com/aws/smithy-go/auth" + smithyendpoints "github.com/aws/smithy-go/endpoints" + "github.com/aws/smithy-go/endpoints/private/bdd" + "github.com/aws/smithy-go/endpoints/private/rulesfn" + "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/ptr" + "github.com/aws/smithy-go/tracing" + smithyhttp "github.com/aws/smithy-go/transport/http" + "net/http" + "net/url" + "os" + "strings" +) + +// EndpointResolverOptions is the service endpoint resolver options +type EndpointResolverOptions = internalendpoints.Options + +// EndpointResolver interface for resolving service endpoints. +type EndpointResolver interface { + ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error) +} + +var _ EndpointResolver = &internalendpoints.Resolver{} + +// NewDefaultEndpointResolver constructs a new service endpoint resolver +func NewDefaultEndpointResolver() *internalendpoints.Resolver { + return internalendpoints.New() +} + +// EndpointResolverFunc is a helper utility that wraps a function so it satisfies +// the EndpointResolver interface. This is useful when you want to add additional +// endpoint resolving logic, or stub out specific endpoints with custom values. +type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error) + +func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error) { + return fn(region, options) +} + +// EndpointResolverFromURL returns an EndpointResolver configured using the +// provided endpoint url. By default, the resolved endpoint resolver uses the +// client region as signing region, and the endpoint source is set to +// EndpointSourceCustom.You can provide functional options to configure endpoint +// values for the resolved endpoint. +func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver { + e := aws.Endpoint{URL: url, Source: aws.EndpointSourceCustom} + for _, fn := range optFns { + fn(&e) + } + + return EndpointResolverFunc( + func(region string, options EndpointResolverOptions) (aws.Endpoint, error) { + if len(e.SigningRegion) == 0 { + e.SigningRegion = region + } + return e, nil + }, + ) +} + +type ResolveEndpoint struct { + Resolver EndpointResolver + Options EndpointResolverOptions +} + +func (*ResolveEndpoint) ID() string { + return "ResolveEndpoint" +} + +func (m *ResolveEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( + out middleware.SerializeOutput, metadata middleware.Metadata, err error, +) { + if !awsmiddleware.GetRequiresLegacyEndpoints(ctx) { + return next.HandleSerialize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + if m.Resolver == nil { + return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil") + } + + eo := m.Options + eo.Logger = middleware.GetLogger(ctx) + + var endpoint aws.Endpoint + endpoint, err = m.Resolver.ResolveEndpoint(awsmiddleware.GetRegion(ctx), eo) + if err != nil { + nf := (&aws.EndpointNotFoundError{}) + if errors.As(err, &nf) { + ctx = awsmiddleware.SetRequiresLegacyEndpoints(ctx, false) + return next.HandleSerialize(ctx, in) + } + return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err) + } + + req.URL, err = url.Parse(endpoint.URL) + if err != nil { + return out, metadata, fmt.Errorf("failed to parse endpoint URL: %w", err) + } + + if len(awsmiddleware.GetSigningName(ctx)) == 0 { + signingName := endpoint.SigningName + if len(signingName) == 0 { + signingName = "ecr-public" + } + ctx = awsmiddleware.SetSigningName(ctx, signingName) + } + ctx = awsmiddleware.SetEndpointSource(ctx, endpoint.Source) + ctx = smithyhttp.SetHostnameImmutable(ctx, endpoint.HostnameImmutable) + ctx = awsmiddleware.SetSigningRegion(ctx, endpoint.SigningRegion) + ctx = awsmiddleware.SetPartitionID(ctx, endpoint.PartitionID) + return next.HandleSerialize(ctx, in) +} +func addResolveEndpointMiddleware(stack *middleware.Stack, o Options) error { + return stack.Serialize.Insert(&ResolveEndpoint{ + Resolver: o.EndpointResolver, + Options: o.EndpointOptions, + }, "OperationSerializer", middleware.Before) +} + +func removeResolveEndpointMiddleware(stack *middleware.Stack) error { + _, err := stack.Serialize.Remove((&ResolveEndpoint{}).ID()) + return err +} + +type wrappedEndpointResolver struct { + awsResolver aws.EndpointResolverWithOptions +} + +func (w *wrappedEndpointResolver) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error) { + return w.awsResolver.ResolveEndpoint(ServiceID, region, options) +} + +type awsEndpointResolverAdaptor func(service, region string) (aws.Endpoint, error) + +func (a awsEndpointResolverAdaptor) ResolveEndpoint(service, region string, options ...interface{}) (aws.Endpoint, error) { + return a(service, region) +} + +var _ aws.EndpointResolverWithOptions = awsEndpointResolverAdaptor(nil) + +// withEndpointResolver returns an aws.EndpointResolverWithOptions that first delegates endpoint resolution to the awsResolver. +// If awsResolver returns aws.EndpointNotFoundError error, the v1 resolver middleware will swallow the error, +// and set an appropriate context flag such that fallback will occur when EndpointResolverV2 is invoked +// via its middleware. +// +// If another error (besides aws.EndpointNotFoundError) is returned, then that error will be propagated. +func withEndpointResolver(awsResolver aws.EndpointResolver, awsResolverWithOptions aws.EndpointResolverWithOptions) EndpointResolver { + var resolver aws.EndpointResolverWithOptions + + if awsResolverWithOptions != nil { + resolver = awsResolverWithOptions + } else if awsResolver != nil { + resolver = awsEndpointResolverAdaptor(awsResolver.ResolveEndpoint) + } + + return &wrappedEndpointResolver{ + awsResolver: resolver, + } +} + +func finalizeClientEndpointResolverOptions(options *Options) { + options.EndpointOptions.LogDeprecated = options.ClientLogMode.IsDeprecatedUsage() + + if len(options.EndpointOptions.ResolvedRegion) == 0 { + const fipsInfix = "-fips-" + const fipsPrefix = "fips-" + const fipsSuffix = "-fips" + + if strings.Contains(options.Region, fipsInfix) || + strings.Contains(options.Region, fipsPrefix) || + strings.Contains(options.Region, fipsSuffix) { + options.EndpointOptions.ResolvedRegion = strings.ReplaceAll(strings.ReplaceAll(strings.ReplaceAll( + options.Region, fipsInfix, "-"), fipsPrefix, ""), fipsSuffix, "") + options.EndpointOptions.UseFIPSEndpoint = aws.FIPSEndpointStateEnabled + } + } + +} + +func resolveEndpointResolverV2(options *Options) { + if options.EndpointResolverV2 == nil { + options.EndpointResolverV2 = NewDefaultEndpointResolverV2() + } +} + +func resolveBaseEndpoint(cfg aws.Config, o *Options) { + if cfg.BaseEndpoint != nil { + o.BaseEndpoint = cfg.BaseEndpoint + } + + _, g := os.LookupEnv("AWS_ENDPOINT_URL") + _, s := os.LookupEnv("AWS_ENDPOINT_URL_ECR_PUBLIC") + + if g && !s { + return + } + + value, found, err := internalConfig.ResolveServiceBaseEndpoint(context.Background(), "ECR PUBLIC", cfg.ConfigSources) + if found && err == nil { + o.BaseEndpoint = &value + } +} + +func bindRegion(region string) (*string, error) { + if region == "" { + return nil, nil + } + if !rulesfn.IsValidHostLabel(region, true) { + return nil, fmt.Errorf("invalid input region %s", region) + } + + return aws.String(endpoints.MapFIPSRegion(region)), nil +} + +var _ = rulesfn.StringSlice(nil) + +// EndpointParameters provides the parameters that influence how endpoints are +// resolved. +type EndpointParameters struct { + // The AWS region used to dispatch the request. + // + // Parameter is + // required. + // + // AWS::Region + Region *string + + // When true, use the dual-stack endpoint. If the configured endpoint does not + // support dual-stack, dispatching the request MAY return an error. + // + // Defaults to + // false if no value is provided. + // + // AWS::UseDualStack + UseDualStack *bool + + // When true, send this request to the FIPS-compliant regional endpoint. If the + // configured endpoint does not have a FIPS compliant endpoint, dispatching the + // request will return an error. + // + // Defaults to false if no value is + // provided. + // + // AWS::UseFIPS + UseFIPS *bool + + // Override the endpoint used to send this request + // + // Parameter is + // required. + // + // SDK::Endpoint + Endpoint *string +} + +// ValidateRequired validates required parameters are set. +func (p EndpointParameters) ValidateRequired() error { + if p.UseDualStack == nil { + return fmt.Errorf("parameter UseDualStack is required") + } + + if p.UseFIPS == nil { + return fmt.Errorf("parameter UseFIPS is required") + } + + return nil +} + +// WithDefaults returns a shallow copy of EndpointParameterswith default values +// applied to members where applicable. +func (p EndpointParameters) WithDefaults() EndpointParameters { + if p.UseDualStack == nil { + p.UseDualStack = ptr.Bool(false) + } + + if p.UseFIPS == nil { + p.UseFIPS = ptr.Bool(false) + } + return p +} + +const bddRoot int32 = 2 + +var bddNodes = [42]int32{ + -1, 1, -1, 0, 13, 3, 1, 4, 100000012, 2, 5, 100000012, 3, 9, 6, 4, 7, 100000011, 5, 8, 100000010, 7, 100000008, 100000009, 4, 11, 10, 6, 100000006, 100000007, 5, 12, 100000005, 6, 100000004, 100000005, 3, 100000001, 14, 4, 100000002, 100000003} + +type conditionContext struct { + PartitionResult *awsrulesfn.PartitionConfig +} + +func evalCondition(idx int, params *EndpointParameters, c *conditionContext) bool { + switch idx { + case 0: + return params.Endpoint != nil + case 1: + return params.Region != nil + case 2: + if v := awsrulesfn.GetPartition(*params.Region); v != nil { + c.PartitionResult = v + return true + } + return false + case 3: + return *params.UseFIPS == true + case 4: + return *params.UseDualStack == true + case 5: + return c.PartitionResult.SupportsDualStack == true + case 6: + return c.PartitionResult.SupportsFIPS == true + case 7: + return c.PartitionResult.Name == "aws" + } + return false +} + +func resolveResult(idx int32, params *EndpointParameters, c *conditionContext) (smithyendpoints.Endpoint, error) { + switch idx { + case 0: + return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint resolution failed: no matching rule") + case 1: + return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: FIPS and custom endpoint are not supported") + case 2: + return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: Dualstack and custom endpoint are not supported") + case 3: + uriString := *params.Endpoint + uri, err := url.Parse(uriString) + if err != nil { + return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString) + } + return smithyendpoints.Endpoint{ + URI: *uri, + Headers: http.Header{}, + }, nil + case 4: + uriString := func() string { + var out strings.Builder + out.WriteString("https://api.ecr-public-fips.") + out.WriteString(*params.Region) + out.WriteString(".") + out.WriteString(c.PartitionResult.DualStackDnsSuffix) + return out.String() + }() + uri, err := url.Parse(uriString) + if err != nil { + return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString) + } + return smithyendpoints.Endpoint{ + URI: *uri, + Headers: http.Header{}, + }, nil + case 5: + return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "FIPS and DualStack are enabled, but this partition does not support one or both") + case 6: + uriString := func() string { + var out strings.Builder + out.WriteString("https://api.ecr-public-fips.") + out.WriteString(*params.Region) + out.WriteString(".") + out.WriteString(c.PartitionResult.DnsSuffix) + return out.String() + }() + uri, err := url.Parse(uriString) + if err != nil { + return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString) + } + return smithyendpoints.Endpoint{ + URI: *uri, + Headers: http.Header{}, + }, nil + case 7: + return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "FIPS is enabled but this partition does not support FIPS") + case 8: + uriString := func() string { + var out strings.Builder + out.WriteString("https://ecr-public.") + out.WriteString(*params.Region) + out.WriteString(".api.aws") + return out.String() + }() + uri, err := url.Parse(uriString) + if err != nil { + return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString) + } + return smithyendpoints.Endpoint{ + URI: *uri, + Headers: http.Header{}, + }, nil + case 9: + uriString := func() string { + var out strings.Builder + out.WriteString("https://api.ecr-public.") + out.WriteString(*params.Region) + out.WriteString(".") + out.WriteString(c.PartitionResult.DualStackDnsSuffix) + return out.String() + }() + uri, err := url.Parse(uriString) + if err != nil { + return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString) + } + return smithyendpoints.Endpoint{ + URI: *uri, + Headers: http.Header{}, + }, nil + case 10: + return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "DualStack is enabled but this partition does not support DualStack") + case 11: + uriString := func() string { + var out strings.Builder + out.WriteString("https://api.ecr-public.") + out.WriteString(*params.Region) + out.WriteString(".") + out.WriteString(c.PartitionResult.DnsSuffix) + return out.String() + }() + uri, err := url.Parse(uriString) + if err != nil { + return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString) + } + return smithyendpoints.Endpoint{ + URI: *uri, + Headers: http.Header{}, + }, nil + case 12: + return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: Missing Region") + } + return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, invalid result index: %d", idx) +} + +// EndpointResolverV2 provides the interface for resolving service endpoints. +type EndpointResolverV2 interface { + ResolveEndpoint(ctx context.Context, params EndpointParameters) ( + smithyendpoints.Endpoint, error, + ) +} + +// resolver provides the implementation for resolving endpoints. +type resolver struct{} + +func NewDefaultEndpointResolverV2() EndpointResolverV2 { + return &resolver{} +} + +// ResolveEndpoint attempts to resolve the endpoint with the provided options, +// returning the endpoint if found. Otherwise an error is returned. +func (r *resolver) ResolveEndpoint( + ctx context.Context, params EndpointParameters, +) ( + endpoint smithyendpoints.Endpoint, err error, +) { + params = params.WithDefaults() + if err = params.ValidateRequired(); err != nil { + return endpoint, fmt.Errorf("endpoint parameters are not valid, %w", err) + } + + c := &conditionContext{} + ref := bdd.Evaluate(bddNodes[:], bddRoot, func(idx int) bool { + return evalCondition(idx, ¶ms, c) + }) + return resolveResult(ref, ¶ms, c) +} + +type endpointParamsBinder interface { + bindEndpointParams(*EndpointParameters) +} + +func bindEndpointParams(ctx context.Context, input interface{}, options Options) (*EndpointParameters, error) { + params := &EndpointParameters{} + + region, err := bindRegion(options.Region) + if err != nil { + return nil, err + } + params.Region = region + + params.UseDualStack = aws.Bool(options.EndpointOptions.UseDualStackEndpoint == aws.DualStackEndpointStateEnabled) + params.UseFIPS = aws.Bool(options.EndpointOptions.UseFIPSEndpoint == aws.FIPSEndpointStateEnabled) + params.Endpoint = options.BaseEndpoint + + if b, ok := input.(endpointParamsBinder); ok { + b.bindEndpointParams(params) + } + + return params, nil +} + +type resolveEndpointV2Middleware struct { + options Options +} + +func (*resolveEndpointV2Middleware) ID() string { + return "ResolveEndpointV2" +} + +func (m *resolveEndpointV2Middleware) HandleFinalize(ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler) ( + out middleware.FinalizeOutput, metadata middleware.Metadata, err error, +) { + _, span := tracing.StartSpan(ctx, "ResolveEndpoint") + defer span.End() + + if awsmiddleware.GetRequiresLegacyEndpoints(ctx) { + return next.HandleFinalize(ctx, in) + } + + req, ok := in.Request.(*smithyhttp.Request) + if !ok { + return out, metadata, fmt.Errorf("unknown transport type %T", in.Request) + } + + if m.options.EndpointResolverV2 == nil { + return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil") + } + + params, err := bindEndpointParams(ctx, getOperationInput(ctx), m.options) + if err != nil { + return out, metadata, fmt.Errorf("failed to bind endpoint params, %w", err) + } + endpt, err := timeOperationMetric(ctx, "client.call.resolve_endpoint_duration", + func() (smithyendpoints.Endpoint, error) { + return m.options.EndpointResolverV2.ResolveEndpoint(ctx, *params) + }) + if err != nil { + return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err) + } + + span.SetProperty("client.call.resolved_endpoint", endpt.URI.String()) + + if endpt.URI.RawPath == "" && req.URL.RawPath != "" { + endpt.URI.RawPath = endpt.URI.Path + } + req.URL.Scheme = endpt.URI.Scheme + req.URL.Host = endpt.URI.Host + req.URL.Path = smithyhttp.JoinPath(endpt.URI.Path, req.URL.Path) + req.URL.RawPath = smithyhttp.JoinPath(endpt.URI.RawPath, req.URL.RawPath) + for k := range endpt.Headers { + req.Header.Set(k, endpt.Headers.Get(k)) + } + + rscheme := getResolvedAuthScheme(ctx) + if rscheme == nil { + return out, metadata, fmt.Errorf("no resolved auth scheme") + } + + opts, _ := smithyauth.GetAuthOptions(&endpt.Properties) + for _, o := range opts { + rscheme.SignerProperties.SetAll(&o.SignerProperties) + } + + span.End() + return next.HandleFinalize(ctx, in) +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/generated.json b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/generated.json new file mode 100644 index 0000000..1332aad --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/generated.json @@ -0,0 +1,60 @@ +{ + "dependencies": { + "github.com/aws/aws-sdk-go-v2": "v1.4.0", + "github.com/aws/aws-sdk-go-v2/internal/configsources": "v0.0.0-00010101000000-000000000000", + "github.com/aws/aws-sdk-go-v2/internal/endpoints/v2": "v2.0.0-00010101000000-000000000000", + "github.com/aws/smithy-go": "v1.4.0" + }, + "files": [ + "api_client.go", + "api_client_test.go", + "api_op_BatchCheckLayerAvailability.go", + "api_op_BatchDeleteImage.go", + "api_op_CompleteLayerUpload.go", + "api_op_CreateRepository.go", + "api_op_DeleteRepository.go", + "api_op_DeleteRepositoryPolicy.go", + "api_op_DescribeImageTags.go", + "api_op_DescribeImages.go", + "api_op_DescribeRegistries.go", + "api_op_DescribeRepositories.go", + "api_op_GetAuthorizationToken.go", + "api_op_GetRegistryCatalogData.go", + "api_op_GetRepositoryCatalogData.go", + "api_op_GetRepositoryPolicy.go", + "api_op_InitiateLayerUpload.go", + "api_op_ListTagsForResource.go", + "api_op_PutImage.go", + "api_op_PutRegistryCatalogData.go", + "api_op_PutRepositoryCatalogData.go", + "api_op_SetRepositoryPolicy.go", + "api_op_TagResource.go", + "api_op_UntagResource.go", + "api_op_UploadLayerPart.go", + "auth.go", + "common_serde.go", + "doc.go", + "endpoints.go", + "endpoints_config_test.go", + "endpoints_test.go", + "generated.json", + "internal/endpoints/endpoints.go", + "internal/endpoints/endpoints_test.go", + "options.go", + "request_snapshot_test.go", + "response_snapshot_test.go", + "response_snapshot_update_test.go", + "schemas/schemas.go", + "snapshot_test.go", + "sra_operation_order_test.go", + "type_registry.go", + "types/common_serde.go", + "types/enums.go", + "types/errors.go", + "types/types.go", + "validators.go" + ], + "go": "1.24", + "module": "github.com/aws/aws-sdk-go-v2/service/ecrpublic", + "unstable": false +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/go_module_metadata.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/go_module_metadata.go new file mode 100644 index 0000000..9de6024 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/go_module_metadata.go @@ -0,0 +1,6 @@ +// Code generated by internal/repotools/cmd/updatemodulemeta DO NOT EDIT. + +package ecrpublic + +// goModuleVersion is the tagged release for this module +const goModuleVersion = "1.47.0" diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/internal/endpoints/endpoints.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/internal/endpoints/endpoints.go new file mode 100644 index 0000000..b8f9933 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/internal/endpoints/endpoints.go @@ -0,0 +1,360 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package endpoints + +import ( + "github.com/aws/aws-sdk-go-v2/aws" + endpoints "github.com/aws/aws-sdk-go-v2/internal/endpoints/v2" + "github.com/aws/smithy-go/logging" + "regexp" +) + +// Options is the endpoint resolver configuration options +type Options struct { + // Logger is a logging implementation that log events should be sent to. + Logger logging.Logger + + // LogDeprecated indicates that deprecated endpoints should be logged to the + // provided logger. + LogDeprecated bool + + // ResolvedRegion is used to override the region to be resolved, rather then the + // using the value passed to the ResolveEndpoint method. This value is used by the + // SDK to translate regions like fips-us-east-1 or us-east-1-fips to an alternative + // name. You must not set this value directly in your application. + ResolvedRegion string + + // DisableHTTPS informs the resolver to return an endpoint that does not use the + // HTTPS scheme. + DisableHTTPS bool + + // UseDualStackEndpoint specifies the resolver must resolve a dual-stack endpoint. + UseDualStackEndpoint aws.DualStackEndpointState + + // UseFIPSEndpoint specifies the resolver must resolve a FIPS endpoint. + UseFIPSEndpoint aws.FIPSEndpointState +} + +func (o Options) GetResolvedRegion() string { + return o.ResolvedRegion +} + +func (o Options) GetDisableHTTPS() bool { + return o.DisableHTTPS +} + +func (o Options) GetUseDualStackEndpoint() aws.DualStackEndpointState { + return o.UseDualStackEndpoint +} + +func (o Options) GetUseFIPSEndpoint() aws.FIPSEndpointState { + return o.UseFIPSEndpoint +} + +func transformToSharedOptions(options Options) endpoints.Options { + return endpoints.Options{ + Logger: options.Logger, + LogDeprecated: options.LogDeprecated, + ResolvedRegion: options.ResolvedRegion, + DisableHTTPS: options.DisableHTTPS, + UseDualStackEndpoint: options.UseDualStackEndpoint, + UseFIPSEndpoint: options.UseFIPSEndpoint, + } +} + +// Resolver ECR PUBLIC endpoint resolver +type Resolver struct { + partitions endpoints.Partitions +} + +// ResolveEndpoint resolves the service endpoint for the given region and options +func (r *Resolver) ResolveEndpoint(region string, options Options) (endpoint aws.Endpoint, err error) { + if len(region) == 0 { + return endpoint, &aws.MissingRegionError{} + } + + opt := transformToSharedOptions(options) + return r.partitions.ResolveEndpoint(region, opt) +} + +// New returns a new Resolver +func New() *Resolver { + return &Resolver{ + partitions: defaultPartitions, + } +} + +var partitionRegexp = struct { + Aws *regexp.Regexp + AwsCn *regexp.Regexp + AwsEusc *regexp.Regexp + AwsIso *regexp.Regexp + AwsIsoB *regexp.Regexp + AwsIsoE *regexp.Regexp + AwsIsoF *regexp.Regexp + AwsUsGov *regexp.Regexp +}{ + + Aws: regexp.MustCompile("^(us|eu|ap|sa|ca|me|af|il|mx)\\-\\w+\\-\\d+$"), + AwsCn: regexp.MustCompile("^cn\\-\\w+\\-\\d+$"), + AwsEusc: regexp.MustCompile("^eusc\\-(de)\\-\\w+\\-\\d+$"), + AwsIso: regexp.MustCompile("^us\\-iso\\-\\w+\\-\\d+$"), + AwsIsoB: regexp.MustCompile("^us\\-isob\\-\\w+\\-\\d+$"), + AwsIsoE: regexp.MustCompile("^eu\\-isoe\\-\\w+\\-\\d+$"), + AwsIsoF: regexp.MustCompile("^us\\-isof\\-\\w+\\-\\d+$"), + AwsUsGov: regexp.MustCompile("^us\\-gov\\-\\w+\\-\\d+$"), +} + +var defaultPartitions = endpoints.Partitions{ + { + ID: "aws", + Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{ + { + Variant: endpoints.DualStackVariant, + }: { + Hostname: "api.ecr-public.{region}.api.aws", + Protocols: []string{"https"}, + SignatureVersions: []string{"v4"}, + }, + { + Variant: endpoints.FIPSVariant, + }: { + Hostname: "api.ecr-public-fips.{region}.amazonaws.com", + Protocols: []string{"https"}, + SignatureVersions: []string{"v4"}, + }, + { + Variant: endpoints.FIPSVariant | endpoints.DualStackVariant, + }: { + Hostname: "api.ecr-public-fips.{region}.api.aws", + Protocols: []string{"https"}, + SignatureVersions: []string{"v4"}, + }, + { + Variant: 0, + }: { + Hostname: "api.ecr-public.{region}.amazonaws.com", + Protocols: []string{"https"}, + SignatureVersions: []string{"v4"}, + }, + }, + RegionRegex: partitionRegexp.Aws, + IsRegionalized: true, + Endpoints: endpoints.Endpoints{ + endpoints.EndpointKey{ + Region: "us-east-1", + }: endpoints.Endpoint{ + Hostname: "api.ecr-public.us-east-1.amazonaws.com", + CredentialScope: endpoints.CredentialScope{ + Region: "us-east-1", + }, + }, + endpoints.EndpointKey{ + Region: "us-east-1", + Variant: endpoints.DualStackVariant, + }: { + Hostname: "ecr-public.us-east-1.api.aws", + CredentialScope: endpoints.CredentialScope{ + Region: "us-east-1", + }, + }, + endpoints.EndpointKey{ + Region: "us-west-2", + }: endpoints.Endpoint{ + Hostname: "api.ecr-public.us-west-2.amazonaws.com", + CredentialScope: endpoints.CredentialScope{ + Region: "us-west-2", + }, + }, + }, + }, + { + ID: "aws-cn", + Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{ + { + Variant: endpoints.DualStackVariant, + }: { + Hostname: "api.ecr-public.{region}.api.amazonwebservices.com.cn", + Protocols: []string{"https"}, + SignatureVersions: []string{"v4"}, + }, + { + Variant: endpoints.FIPSVariant, + }: { + Hostname: "api.ecr-public-fips.{region}.amazonaws.com.cn", + Protocols: []string{"https"}, + SignatureVersions: []string{"v4"}, + }, + { + Variant: endpoints.FIPSVariant | endpoints.DualStackVariant, + }: { + Hostname: "api.ecr-public-fips.{region}.api.amazonwebservices.com.cn", + Protocols: []string{"https"}, + SignatureVersions: []string{"v4"}, + }, + { + Variant: 0, + }: { + Hostname: "api.ecr-public.{region}.amazonaws.com.cn", + Protocols: []string{"https"}, + SignatureVersions: []string{"v4"}, + }, + }, + RegionRegex: partitionRegexp.AwsCn, + IsRegionalized: true, + }, + { + ID: "aws-eusc", + Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{ + { + Variant: endpoints.DualStackVariant, + }: { + Hostname: "api.ecr-public.{region}.api.amazonwebservices.eu", + Protocols: []string{"https"}, + SignatureVersions: []string{"v4"}, + }, + { + Variant: endpoints.FIPSVariant, + }: { + Hostname: "api.ecr-public-fips.{region}.amazonaws.eu", + Protocols: []string{"https"}, + SignatureVersions: []string{"v4"}, + }, + { + Variant: endpoints.FIPSVariant | endpoints.DualStackVariant, + }: { + Hostname: "api.ecr-public-fips.{region}.api.amazonwebservices.eu", + Protocols: []string{"https"}, + SignatureVersions: []string{"v4"}, + }, + { + Variant: 0, + }: { + Hostname: "api.ecr-public.{region}.amazonaws.eu", + Protocols: []string{"https"}, + SignatureVersions: []string{"v4"}, + }, + }, + RegionRegex: partitionRegexp.AwsEusc, + IsRegionalized: true, + }, + { + ID: "aws-iso", + Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{ + { + Variant: endpoints.FIPSVariant, + }: { + Hostname: "api.ecr-public-fips.{region}.c2s.ic.gov", + Protocols: []string{"https"}, + SignatureVersions: []string{"v4"}, + }, + { + Variant: 0, + }: { + Hostname: "api.ecr-public.{region}.c2s.ic.gov", + Protocols: []string{"https"}, + SignatureVersions: []string{"v4"}, + }, + }, + RegionRegex: partitionRegexp.AwsIso, + IsRegionalized: true, + }, + { + ID: "aws-iso-b", + Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{ + { + Variant: endpoints.FIPSVariant, + }: { + Hostname: "api.ecr-public-fips.{region}.sc2s.sgov.gov", + Protocols: []string{"https"}, + SignatureVersions: []string{"v4"}, + }, + { + Variant: 0, + }: { + Hostname: "api.ecr-public.{region}.sc2s.sgov.gov", + Protocols: []string{"https"}, + SignatureVersions: []string{"v4"}, + }, + }, + RegionRegex: partitionRegexp.AwsIsoB, + IsRegionalized: true, + }, + { + ID: "aws-iso-e", + Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{ + { + Variant: endpoints.FIPSVariant, + }: { + Hostname: "api.ecr-public-fips.{region}.cloud.adc-e.uk", + Protocols: []string{"https"}, + SignatureVersions: []string{"v4"}, + }, + { + Variant: 0, + }: { + Hostname: "api.ecr-public.{region}.cloud.adc-e.uk", + Protocols: []string{"https"}, + SignatureVersions: []string{"v4"}, + }, + }, + RegionRegex: partitionRegexp.AwsIsoE, + IsRegionalized: true, + }, + { + ID: "aws-iso-f", + Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{ + { + Variant: endpoints.FIPSVariant, + }: { + Hostname: "api.ecr-public-fips.{region}.csp.hci.ic.gov", + Protocols: []string{"https"}, + SignatureVersions: []string{"v4"}, + }, + { + Variant: 0, + }: { + Hostname: "api.ecr-public.{region}.csp.hci.ic.gov", + Protocols: []string{"https"}, + SignatureVersions: []string{"v4"}, + }, + }, + RegionRegex: partitionRegexp.AwsIsoF, + IsRegionalized: true, + }, + { + ID: "aws-us-gov", + Defaults: map[endpoints.DefaultKey]endpoints.Endpoint{ + { + Variant: endpoints.DualStackVariant, + }: { + Hostname: "api.ecr-public.{region}.api.aws", + Protocols: []string{"https"}, + SignatureVersions: []string{"v4"}, + }, + { + Variant: endpoints.FIPSVariant, + }: { + Hostname: "api.ecr-public-fips.{region}.amazonaws.com", + Protocols: []string{"https"}, + SignatureVersions: []string{"v4"}, + }, + { + Variant: endpoints.FIPSVariant | endpoints.DualStackVariant, + }: { + Hostname: "api.ecr-public-fips.{region}.api.aws", + Protocols: []string{"https"}, + SignatureVersions: []string{"v4"}, + }, + { + Variant: 0, + }: { + Hostname: "api.ecr-public.{region}.amazonaws.com", + Protocols: []string{"https"}, + SignatureVersions: []string{"v4"}, + }, + }, + RegionRegex: partitionRegexp.AwsUsGov, + IsRegionalized: true, + }, +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/options.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/options.go new file mode 100644 index 0000000..de3d78c --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/options.go @@ -0,0 +1,245 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "github.com/aws/aws-sdk-go-v2/aws" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + internalauthsmithy "github.com/aws/aws-sdk-go-v2/internal/auth/smithy" + smithyauth "github.com/aws/smithy-go/auth" + "github.com/aws/smithy-go/logging" + "github.com/aws/smithy-go/metrics" + "github.com/aws/smithy-go/middleware" + "github.com/aws/smithy-go/tracing" + smithyhttp "github.com/aws/smithy-go/transport/http" + "net/http" +) + +type HTTPClient interface { + Do(*http.Request) (*http.Response, error) +} + +type Options struct { + // Set of options to modify how an operation is invoked. These apply to all + // operations invoked for this client. Use functional options on operation call to + // modify this list for per operation behavior. + APIOptions []func(*middleware.Stack) error + + // The optional application specific identifier appended to the User-Agent header. + AppID string + + // This endpoint will be given as input to an EndpointResolverV2. It is used for + // providing a custom base endpoint that is subject to modifications by the + // processing EndpointResolverV2. + BaseEndpoint *string + + // Configures the events that will be sent to the configured logger. + ClientLogMode aws.ClientLogMode + + // The credentials object to use when signing requests. + Credentials aws.CredentialsProvider + + // The configuration DefaultsMode that the SDK should use when constructing the + // clients initial default settings. + DefaultsMode aws.DefaultsMode + + // Disables SDK clock skew correction. When set, the SDK will not adjust request + // signing timestamps to compensate for clock drift between the client and the + // service. + DisableClockSkewCorrection bool + + // The endpoint options to be used when attempting to resolve an endpoint. + EndpointOptions EndpointResolverOptions + + // The service endpoint resolver. + // + // Deprecated: Deprecated: EndpointResolver and WithEndpointResolver. Providing a + // value for this field will likely prevent you from using any endpoint-related + // service features released after the introduction of EndpointResolverV2 and + // BaseEndpoint. + // + // To migrate an EndpointResolver implementation that uses a custom endpoint, set + // the client option BaseEndpoint instead. + EndpointResolver EndpointResolver + + // Resolves the endpoint used for a particular service operation. + EndpointResolverV2 EndpointResolverV2 + + // Signature Version 4 (SigV4) Signer + HTTPSignerV4 HTTPSignerV4 + + // The logger writer interface to write logging messages to. + Logger logging.Logger + + // The client meter provider. + MeterProvider metrics.MeterProvider + + // The region to send requests to. (Required) + Region string + + // RetryMaxAttempts specifies the maximum number attempts an API client will call + // an operation that fails with a retryable error. A value of 0 is ignored, and + // will not be used to configure the API client created default retryer, or modify + // per operation call's retry max attempts. + // + // If specified in an operation call's functional options with a value that is + // different than the constructed client's Options, the Client's Retryer will be + // wrapped to use the operation's specific RetryMaxAttempts value. + RetryMaxAttempts int + + // RetryMode specifies the retry mode the API client will be created with, if + // Retryer option is not also specified. + // + // When creating a new API Clients this member will only be used if the Retryer + // Options member is nil. This value will be ignored if Retryer is not nil. + // + // Currently does not support per operation call overrides, may in the future. + RetryMode aws.RetryMode + + // Retryer guides how HTTP requests should be retried in case of recoverable + // failures. When nil the API client will use a default retryer. The kind of + // default retry created by the API client can be changed with the RetryMode + // option. + Retryer aws.Retryer + + // The RuntimeEnvironment configuration, only populated if the DefaultsMode is set + // to DefaultsModeAuto and is initialized using config.LoadDefaultConfig . You + // should not populate this structure programmatically, or rely on the values here + // within your applications. + RuntimeEnvironment aws.RuntimeEnvironment + + // The client tracer provider. + TracerProvider tracing.TracerProvider + + // The initial DefaultsMode used when the client options were constructed. If the + // DefaultsMode was set to aws.DefaultsModeAuto this will store what the resolved + // value was at that point in time. + // + // Currently does not support per operation call overrides, may in the future. + resolvedDefaultsMode aws.DefaultsMode + + Protocol smithyhttp.ClientProtocol + + // The HTTP client to invoke API calls with. Defaults to client's default HTTP + // implementation if nil. + HTTPClient HTTPClient + + // Client registry of operation interceptors. + Interceptors smithyhttp.InterceptorRegistry + + // The auth scheme resolver which determines how to authenticate for each + // operation. + AuthSchemeResolver AuthSchemeResolver + + // The list of auth schemes supported by the client. + AuthSchemes []smithyhttp.AuthScheme + + // Priority list of preferred auth scheme names (e.g. sigv4a). + AuthSchemePreference []string +} + +// Copy creates a clone where the APIOptions list is deep copied. +func (o Options) Copy() Options { + to := o + to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions)) + copy(to.APIOptions, o.APIOptions) + to.Interceptors = o.Interceptors.Copy() + + return to +} + +func (o Options) GetIdentityResolver(schemeID string) smithyauth.IdentityResolver { + if schemeID == "aws.auth#sigv4" { + return getSigV4IdentityResolver(o) + } + if schemeID == "smithy.api#noAuth" { + return &smithyauth.AnonymousIdentityResolver{} + } + return nil +} + +// WithAPIOptions returns a functional option for setting the Client's APIOptions +// option. +func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options) { + return func(o *Options) { + o.APIOptions = append(o.APIOptions, optFns...) + } +} + +// Deprecated: EndpointResolver and WithEndpointResolver. Providing a value for +// this field will likely prevent you from using any endpoint-related service +// features released after the introduction of EndpointResolverV2 and BaseEndpoint. +// +// To migrate an EndpointResolver implementation that uses a custom endpoint, set +// the client option BaseEndpoint instead. +func WithEndpointResolver(v EndpointResolver) func(*Options) { + return func(o *Options) { + o.EndpointResolver = v + } +} + +// WithEndpointResolverV2 returns a functional option for setting the Client's +// EndpointResolverV2 option. +func WithEndpointResolverV2(v EndpointResolverV2) func(*Options) { + return func(o *Options) { + o.EndpointResolverV2 = v + } +} + +func getSigV4IdentityResolver(o Options) smithyauth.IdentityResolver { + if o.Credentials != nil { + return &internalauthsmithy.CredentialsProviderAdapter{Provider: o.Credentials} + } + return nil +} + +// WithSigV4SigningName applies an override to the authentication workflow to +// use the given signing name for SigV4-authenticated operations. +// +// This is an advanced setting. The value here is FINAL, taking precedence over +// the resolved signing name from both auth scheme resolution and endpoint +// resolution. +func WithSigV4SigningName(name string) func(*Options) { + fn := func(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, + ) { + return next.HandleInitialize(awsmiddleware.SetSigningName(ctx, name), in) + } + return func(o *Options) { + o.APIOptions = append(o.APIOptions, func(s *middleware.Stack) error { + return s.Initialize.Add( + middleware.InitializeMiddlewareFunc("withSigV4SigningName", fn), + middleware.Before, + ) + }) + } +} + +// WithSigV4SigningRegion applies an override to the authentication workflow to +// use the given signing region for SigV4-authenticated operations. +// +// This is an advanced setting. The value here is FINAL, taking precedence over +// the resolved signing region from both auth scheme resolution and endpoint +// resolution. +func WithSigV4SigningRegion(region string) func(*Options) { + fn := func(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, + ) { + return next.HandleInitialize(awsmiddleware.SetSigningRegion(ctx, region), in) + } + return func(o *Options) { + o.APIOptions = append(o.APIOptions, func(s *middleware.Stack) error { + return s.Initialize.Add( + middleware.InitializeMiddlewareFunc("withSigV4SigningRegion", fn), + middleware.Before, + ) + }) + } +} + +func ignoreAnonymousAuth(options *Options) { + if aws.IsCredentialsProvider(options.Credentials, (*aws.AnonymousCredentials)(nil)) { + options.Credentials = nil + } +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas/schemas.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas/schemas.go new file mode 100644 index 0000000..8e55f69 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas/schemas.go @@ -0,0 +1,1694 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package schemas + +import ( + smithy "github.com/aws/smithy-go" + smithyprelude "github.com/aws/smithy-go/prelude" + smithytraits "github.com/aws/smithy-go/traits" +) + +var BatchCheckLayerAvailability = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "BatchCheckLayerAvailability", +}, smithy.ShapeTypeOperation, 0) + +var BatchDeleteImage = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "BatchDeleteImage", +}, smithy.ShapeTypeOperation, 0) + +var CompleteLayerUpload = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "CompleteLayerUpload", +}, smithy.ShapeTypeOperation, 0) + +var CreateRepository = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "CreateRepository", +}, smithy.ShapeTypeOperation, 0) + +var DeleteRepository = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "DeleteRepository", +}, smithy.ShapeTypeOperation, 0) + +var DeleteRepositoryPolicy = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "DeleteRepositoryPolicy", +}, smithy.ShapeTypeOperation, 0) + +var DescribeImages = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "DescribeImages", +}, smithy.ShapeTypeOperation, 0) + +var DescribeImageTags = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "DescribeImageTags", +}, smithy.ShapeTypeOperation, 0) + +var DescribeRegistries = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "DescribeRegistries", +}, smithy.ShapeTypeOperation, 0) + +var DescribeRepositories = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "DescribeRepositories", +}, smithy.ShapeTypeOperation, 0) + +var GetAuthorizationToken = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "GetAuthorizationToken", +}, smithy.ShapeTypeOperation, 0) + +var GetRegistryCatalogData = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "GetRegistryCatalogData", +}, smithy.ShapeTypeOperation, 0) + +var GetRepositoryCatalogData = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "GetRepositoryCatalogData", +}, smithy.ShapeTypeOperation, 0) + +var GetRepositoryPolicy = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "GetRepositoryPolicy", +}, smithy.ShapeTypeOperation, 0) + +var InitiateLayerUpload = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "InitiateLayerUpload", +}, smithy.ShapeTypeOperation, 0) + +var ListTagsForResource = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ListTagsForResource", +}, smithy.ShapeTypeOperation, 0) + +var PutImage = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "PutImage", +}, smithy.ShapeTypeOperation, 0) + +var PutRegistryCatalogData = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "PutRegistryCatalogData", +}, smithy.ShapeTypeOperation, 0) + +var PutRepositoryCatalogData = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "PutRepositoryCatalogData", +}, smithy.ShapeTypeOperation, 0) + +var SetRepositoryPolicy = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "SetRepositoryPolicy", +}, smithy.ShapeTypeOperation, 0) + +var TagResource = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "TagResource", +}, smithy.ShapeTypeOperation, 0) + +var UntagResource = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "UntagResource", +}, smithy.ShapeTypeOperation, 0) + +var UploadLayerPart = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "UploadLayerPart", +}, smithy.ShapeTypeOperation, 0) + +var _SpencerFrontendService = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "SpencerFrontendService", +}, smithy.ShapeTypeService, 0, &smithytraits.XMLNamespace{URI: "http://ecr-public.amazonaws.com/doc/2020-12-02/"}) + +var SpencerFrontendService = smithy.NewServiceSchema(_SpencerFrontendService, "2020-10-30") + +var _AboutText = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "AboutText", +}, smithy.ShapeTypeString, 0) + +var _Architecture = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "Architecture", +}, smithy.ShapeTypeString, 0) + +var _ArchitectureList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ArchitectureList", +}, smithy.ShapeTypeList, 1) +var _ArchitectureList_member *smithy.Schema + +var _Arn = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "Arn", +}, smithy.ShapeTypeString, 0) + +var AuthorizationData = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "AuthorizationData", +}, smithy.ShapeTypeStructure, 2) +var AuthorizationData_authorizationToken *smithy.Schema + +var AuthorizationData_expiresAt *smithy.Schema + +var _Base64 = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "Base64", +}, smithy.ShapeTypeString, 0) + +var _BatchedOperationLayerDigest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "BatchedOperationLayerDigest", +}, smithy.ShapeTypeString, 0) + +var _BatchedOperationLayerDigestList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "BatchedOperationLayerDigestList", +}, smithy.ShapeTypeList, 1) +var _BatchedOperationLayerDigestList_member *smithy.Schema + +var _CreationTimestamp = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "CreationTimestamp", +}, smithy.ShapeTypeTimestamp, 0) + +var _DefaultRegistryAliasFlag = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "DefaultRegistryAliasFlag", +}, smithy.ShapeTypeBoolean, 0) + +var EmptyUploadException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "EmptyUploadException", +}, smithy.ShapeTypeStructure, 1) +var EmptyUploadException_message *smithy.Schema + +var _ExceptionMessage = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ExceptionMessage", +}, smithy.ShapeTypeString, 0) + +var _ExpirationTimestamp = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ExpirationTimestamp", +}, smithy.ShapeTypeTimestamp, 0) + +var _ForceFlag = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ForceFlag", +}, smithy.ShapeTypeBoolean, 0) + +var Image = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "Image", +}, smithy.ShapeTypeStructure, 5) +var Image_registryId *smithy.Schema + +var Image_repositoryName *smithy.Schema + +var Image_imageId *smithy.Schema + +var Image_imageManifest *smithy.Schema + +var Image_imageManifestMediaType *smithy.Schema + +var ImageAlreadyExistsException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ImageAlreadyExistsException", +}, smithy.ShapeTypeStructure, 1) +var ImageAlreadyExistsException_message *smithy.Schema + +var ImageDetail = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ImageDetail", +}, smithy.ShapeTypeStructure, 8) +var ImageDetail_registryId *smithy.Schema + +var ImageDetail_repositoryName *smithy.Schema + +var ImageDetail_imageDigest *smithy.Schema + +var ImageDetail_imageTags *smithy.Schema + +var ImageDetail_imageSizeInBytes *smithy.Schema + +var ImageDetail_imagePushedAt *smithy.Schema + +var ImageDetail_imageManifestMediaType *smithy.Schema + +var ImageDetail_artifactMediaType *smithy.Schema + +var _ImageDetailList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ImageDetailList", +}, smithy.ShapeTypeList, 1) +var _ImageDetailList_member *smithy.Schema + +var _ImageDigest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ImageDigest", +}, smithy.ShapeTypeString, 0) + +var ImageDigestDoesNotMatchException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ImageDigestDoesNotMatchException", +}, smithy.ShapeTypeStructure, 1) +var ImageDigestDoesNotMatchException_message *smithy.Schema + +var ImageFailure = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ImageFailure", +}, smithy.ShapeTypeStructure, 3) +var ImageFailure_imageId *smithy.Schema + +var ImageFailure_failureCode *smithy.Schema + +var ImageFailure_failureReason *smithy.Schema + +var ImageFailureCode = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ImageFailureCode", +}, smithy.ShapeTypeEnum, 7) +var ImageFailureCode_InvalidImageDigest *smithy.Schema + +var ImageFailureCode_InvalidImageTag *smithy.Schema + +var ImageFailureCode_ImageTagDoesNotMatchDigest *smithy.Schema + +var ImageFailureCode_ImageNotFound *smithy.Schema + +var ImageFailureCode_MissingDigestAndTag *smithy.Schema + +var ImageFailureCode_ImageReferencedByManifestList *smithy.Schema + +var ImageFailureCode_KmsError *smithy.Schema + +var _ImageFailureList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ImageFailureList", +}, smithy.ShapeTypeList, 1) +var _ImageFailureList_member *smithy.Schema + +var _ImageFailureReason = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ImageFailureReason", +}, smithy.ShapeTypeString, 0) + +var ImageIdentifier = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ImageIdentifier", +}, smithy.ShapeTypeStructure, 2) +var ImageIdentifier_imageDigest *smithy.Schema + +var ImageIdentifier_imageTag *smithy.Schema + +var _ImageIdentifierList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ImageIdentifierList", +}, smithy.ShapeTypeList, 1) +var _ImageIdentifierList_member *smithy.Schema + +var _ImageManifest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ImageManifest", +}, smithy.ShapeTypeString, 0) + +var ImageNotFoundException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ImageNotFoundException", +}, smithy.ShapeTypeStructure, 1) +var ImageNotFoundException_message *smithy.Schema + +var _ImageSizeInBytes = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ImageSizeInBytes", +}, smithy.ShapeTypeLong, 0) + +var _ImageTag = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ImageTag", +}, smithy.ShapeTypeString, 0) + +var ImageTagAlreadyExistsException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ImageTagAlreadyExistsException", +}, smithy.ShapeTypeStructure, 1) +var ImageTagAlreadyExistsException_message *smithy.Schema + +var ImageTagDetail = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ImageTagDetail", +}, smithy.ShapeTypeStructure, 3) +var ImageTagDetail_imageTag *smithy.Schema + +var ImageTagDetail_createdAt *smithy.Schema + +var ImageTagDetail_imageDetail *smithy.Schema + +var _ImageTagDetailList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ImageTagDetailList", +}, smithy.ShapeTypeList, 1) +var _ImageTagDetailList_member *smithy.Schema + +var _ImageTagList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ImageTagList", +}, smithy.ShapeTypeList, 1) +var _ImageTagList_member *smithy.Schema + +var InvalidLayerException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "InvalidLayerException", +}, smithy.ShapeTypeStructure, 1) +var InvalidLayerException_message *smithy.Schema + +var InvalidLayerPartException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "InvalidLayerPartException", +}, smithy.ShapeTypeStructure, 5) +var InvalidLayerPartException_registryId *smithy.Schema + +var InvalidLayerPartException_repositoryName *smithy.Schema + +var InvalidLayerPartException_uploadId *smithy.Schema + +var InvalidLayerPartException_lastValidByteReceived *smithy.Schema + +var InvalidLayerPartException_message *smithy.Schema + +var InvalidParameterException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "InvalidParameterException", +}, smithy.ShapeTypeStructure, 1) +var InvalidParameterException_message *smithy.Schema + +var InvalidTagParameterException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "InvalidTagParameterException", +}, smithy.ShapeTypeStructure, 1) +var InvalidTagParameterException_message *smithy.Schema + +var Layer = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "Layer", +}, smithy.ShapeTypeStructure, 4) +var Layer_layerDigest *smithy.Schema + +var Layer_layerAvailability *smithy.Schema + +var Layer_layerSize *smithy.Schema + +var Layer_mediaType *smithy.Schema + +var LayerAlreadyExistsException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "LayerAlreadyExistsException", +}, smithy.ShapeTypeStructure, 1) +var LayerAlreadyExistsException_message *smithy.Schema + +var LayerAvailability = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "LayerAvailability", +}, smithy.ShapeTypeEnum, 2) +var LayerAvailability_AVAILABLE *smithy.Schema + +var LayerAvailability_UNAVAILABLE *smithy.Schema + +var _LayerDigest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "LayerDigest", +}, smithy.ShapeTypeString, 0) + +var _LayerDigestList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "LayerDigestList", +}, smithy.ShapeTypeList, 1) +var _LayerDigestList_member *smithy.Schema + +var LayerFailure = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "LayerFailure", +}, smithy.ShapeTypeStructure, 3) +var LayerFailure_layerDigest *smithy.Schema + +var LayerFailure_failureCode *smithy.Schema + +var LayerFailure_failureReason *smithy.Schema + +var LayerFailureCode = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "LayerFailureCode", +}, smithy.ShapeTypeEnum, 2) +var LayerFailureCode_InvalidLayerDigest *smithy.Schema + +var LayerFailureCode_MissingLayerDigest *smithy.Schema + +var _LayerFailureList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "LayerFailureList", +}, smithy.ShapeTypeList, 1) +var _LayerFailureList_member *smithy.Schema + +var _LayerFailureReason = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "LayerFailureReason", +}, smithy.ShapeTypeString, 0) + +var _LayerList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "LayerList", +}, smithy.ShapeTypeList, 1) +var _LayerList_member *smithy.Schema + +var _LayerPartBlob = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "LayerPartBlob", +}, smithy.ShapeTypeBlob, 0) + +var LayerPartTooSmallException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "LayerPartTooSmallException", +}, smithy.ShapeTypeStructure, 1) +var LayerPartTooSmallException_message *smithy.Schema + +var _LayerSizeInBytes = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "LayerSizeInBytes", +}, smithy.ShapeTypeLong, 0) + +var LayersNotFoundException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "LayersNotFoundException", +}, smithy.ShapeTypeStructure, 1) +var LayersNotFoundException_message *smithy.Schema + +var LimitExceededException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "LimitExceededException", +}, smithy.ShapeTypeStructure, 1) +var LimitExceededException_message *smithy.Schema + +var _LogoImageBlob = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "LogoImageBlob", +}, smithy.ShapeTypeBlob, 0) + +var _MarketplaceCertified = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "MarketplaceCertified", +}, smithy.ShapeTypeBoolean, 0) + +var _MaxResults = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "MaxResults", +}, smithy.ShapeTypeInteger, 0) + +var _MediaType = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "MediaType", +}, smithy.ShapeTypeString, 0) + +var _NextToken = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "NextToken", +}, smithy.ShapeTypeString, 0) + +var _OperatingSystem = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "OperatingSystem", +}, smithy.ShapeTypeString, 0) + +var _OperatingSystemList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "OperatingSystemList", +}, smithy.ShapeTypeList, 1) +var _OperatingSystemList_member *smithy.Schema + +var _PartSize = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "PartSize", +}, smithy.ShapeTypeLong, 0) + +var _PrimaryRegistryAliasFlag = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "PrimaryRegistryAliasFlag", +}, smithy.ShapeTypeBoolean, 0) + +var _PushTimestamp = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "PushTimestamp", +}, smithy.ShapeTypeTimestamp, 0) + +var ReferencedImageDetail = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ReferencedImageDetail", +}, smithy.ShapeTypeStructure, 5) +var ReferencedImageDetail_imageDigest *smithy.Schema + +var ReferencedImageDetail_imageSizeInBytes *smithy.Schema + +var ReferencedImageDetail_imagePushedAt *smithy.Schema + +var ReferencedImageDetail_imageManifestMediaType *smithy.Schema + +var ReferencedImageDetail_artifactMediaType *smithy.Schema + +var ReferencedImagesNotFoundException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ReferencedImagesNotFoundException", +}, smithy.ShapeTypeStructure, 1) +var ReferencedImagesNotFoundException_message *smithy.Schema + +var Registry = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "Registry", +}, smithy.ShapeTypeStructure, 5) +var Registry_registryId *smithy.Schema + +var Registry_registryArn *smithy.Schema + +var Registry_registryUri *smithy.Schema + +var Registry_verified *smithy.Schema + +var Registry_aliases *smithy.Schema + +var RegistryAlias = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "RegistryAlias", +}, smithy.ShapeTypeStructure, 4) +var RegistryAlias_name *smithy.Schema + +var RegistryAlias_status *smithy.Schema + +var RegistryAlias_primaryRegistryAlias *smithy.Schema + +var RegistryAlias_defaultRegistryAlias *smithy.Schema + +var _RegistryAliasList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "RegistryAliasList", +}, smithy.ShapeTypeList, 1) +var _RegistryAliasList_member *smithy.Schema + +var _RegistryAliasName = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "RegistryAliasName", +}, smithy.ShapeTypeString, 0) + +var RegistryAliasStatus = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "RegistryAliasStatus", +}, smithy.ShapeTypeEnum, 3) +var RegistryAliasStatus_ACTIVE *smithy.Schema + +var RegistryAliasStatus_PENDING *smithy.Schema + +var RegistryAliasStatus_REJECTED *smithy.Schema + +var RegistryCatalogData = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "RegistryCatalogData", +}, smithy.ShapeTypeStructure, 1) +var RegistryCatalogData_displayName *smithy.Schema + +var _RegistryDisplayName = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "RegistryDisplayName", +}, smithy.ShapeTypeString, 0) + +var _RegistryId = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "RegistryId", +}, smithy.ShapeTypeString, 0) + +var _RegistryIdOrAlias = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "RegistryIdOrAlias", +}, smithy.ShapeTypeString, 0) + +var _RegistryList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "RegistryList", +}, smithy.ShapeTypeList, 1) +var _RegistryList_member *smithy.Schema + +var RegistryNotFoundException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "RegistryNotFoundException", +}, smithy.ShapeTypeStructure, 1) +var RegistryNotFoundException_message *smithy.Schema + +var _RegistryVerified = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "RegistryVerified", +}, smithy.ShapeTypeBoolean, 0) + +var Repository = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "Repository", +}, smithy.ShapeTypeStructure, 5) +var Repository_repositoryArn *smithy.Schema + +var Repository_registryId *smithy.Schema + +var Repository_repositoryName *smithy.Schema + +var Repository_repositoryUri *smithy.Schema + +var Repository_createdAt *smithy.Schema + +var RepositoryAlreadyExistsException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "RepositoryAlreadyExistsException", +}, smithy.ShapeTypeStructure, 1) +var RepositoryAlreadyExistsException_message *smithy.Schema + +var RepositoryCatalogData = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "RepositoryCatalogData", +}, smithy.ShapeTypeStructure, 7) +var RepositoryCatalogData_description *smithy.Schema + +var RepositoryCatalogData_architectures *smithy.Schema + +var RepositoryCatalogData_operatingSystems *smithy.Schema + +var RepositoryCatalogData_logoUrl *smithy.Schema + +var RepositoryCatalogData_aboutText *smithy.Schema + +var RepositoryCatalogData_usageText *smithy.Schema + +var RepositoryCatalogData_marketplaceCertified *smithy.Schema + +var RepositoryCatalogDataInput = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "RepositoryCatalogDataInput", +}, smithy.ShapeTypeStructure, 6) +var RepositoryCatalogDataInput_description *smithy.Schema + +var RepositoryCatalogDataInput_architectures *smithy.Schema + +var RepositoryCatalogDataInput_operatingSystems *smithy.Schema + +var RepositoryCatalogDataInput_logoImageBlob *smithy.Schema + +var RepositoryCatalogDataInput_aboutText *smithy.Schema + +var RepositoryCatalogDataInput_usageText *smithy.Schema + +var RepositoryCatalogDataNotFoundException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "RepositoryCatalogDataNotFoundException", +}, smithy.ShapeTypeStructure, 1) +var RepositoryCatalogDataNotFoundException_message *smithy.Schema + +var _RepositoryDescription = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "RepositoryDescription", +}, smithy.ShapeTypeString, 0) + +var _RepositoryList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "RepositoryList", +}, smithy.ShapeTypeList, 1) +var _RepositoryList_member *smithy.Schema + +var _RepositoryName = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "RepositoryName", +}, smithy.ShapeTypeString, 0) + +var _RepositoryNameList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "RepositoryNameList", +}, smithy.ShapeTypeList, 1) +var _RepositoryNameList_member *smithy.Schema + +var RepositoryNotEmptyException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "RepositoryNotEmptyException", +}, smithy.ShapeTypeStructure, 1) +var RepositoryNotEmptyException_message *smithy.Schema + +var RepositoryNotFoundException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "RepositoryNotFoundException", +}, smithy.ShapeTypeStructure, 1) +var RepositoryNotFoundException_message *smithy.Schema + +var RepositoryPolicyNotFoundException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "RepositoryPolicyNotFoundException", +}, smithy.ShapeTypeStructure, 1) +var RepositoryPolicyNotFoundException_message *smithy.Schema + +var _RepositoryPolicyText = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "RepositoryPolicyText", +}, smithy.ShapeTypeString, 0) + +var _ResourceUrl = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ResourceUrl", +}, smithy.ShapeTypeString, 0) + +var ServerException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ServerException", +}, smithy.ShapeTypeStructure, 1) +var ServerException_message *smithy.Schema + +var Tag = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "Tag", +}, smithy.ShapeTypeStructure, 2) +var Tag_Key *smithy.Schema + +var Tag_Value *smithy.Schema + +var _TagKey = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "TagKey", +}, smithy.ShapeTypeString, 0) + +var _TagKeyList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "TagKeyList", +}, smithy.ShapeTypeList, 1) +var _TagKeyList_member *smithy.Schema + +var _TagList = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "TagList", +}, smithy.ShapeTypeList, 1) +var _TagList_member *smithy.Schema + +var _TagValue = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "TagValue", +}, smithy.ShapeTypeString, 0) + +var TooManyTagsException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "TooManyTagsException", +}, smithy.ShapeTypeStructure, 1) +var TooManyTagsException_message *smithy.Schema + +var UnsupportedCommandException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "UnsupportedCommandException", +}, smithy.ShapeTypeStructure, 1) +var UnsupportedCommandException_message *smithy.Schema + +var _UploadId = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "UploadId", +}, smithy.ShapeTypeString, 0) + +var UploadNotFoundException = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "UploadNotFoundException", +}, smithy.ShapeTypeStructure, 1) +var UploadNotFoundException_message *smithy.Schema + +var _Url = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "Url", +}, smithy.ShapeTypeString, 0) + +var _UsageText = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "UsageText", +}, smithy.ShapeTypeString, 0) + +var BatchCheckLayerAvailabilityRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "BatchCheckLayerAvailabilityRequest", +}, smithy.ShapeTypeStructure, 3) +var BatchCheckLayerAvailabilityRequest_registryId *smithy.Schema + +var BatchCheckLayerAvailabilityRequest_repositoryName *smithy.Schema + +var BatchCheckLayerAvailabilityRequest_layerDigests *smithy.Schema + +var BatchCheckLayerAvailabilityResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "BatchCheckLayerAvailabilityResponse", +}, smithy.ShapeTypeStructure, 2) +var BatchCheckLayerAvailabilityResponse_layers *smithy.Schema + +var BatchCheckLayerAvailabilityResponse_failures *smithy.Schema + +var BatchDeleteImageRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "BatchDeleteImageRequest", +}, smithy.ShapeTypeStructure, 3) +var BatchDeleteImageRequest_registryId *smithy.Schema + +var BatchDeleteImageRequest_repositoryName *smithy.Schema + +var BatchDeleteImageRequest_imageIds *smithy.Schema + +var BatchDeleteImageResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "BatchDeleteImageResponse", +}, smithy.ShapeTypeStructure, 2) +var BatchDeleteImageResponse_imageIds *smithy.Schema + +var BatchDeleteImageResponse_failures *smithy.Schema + +var CompleteLayerUploadRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "CompleteLayerUploadRequest", +}, smithy.ShapeTypeStructure, 4) +var CompleteLayerUploadRequest_registryId *smithy.Schema + +var CompleteLayerUploadRequest_repositoryName *smithy.Schema + +var CompleteLayerUploadRequest_uploadId *smithy.Schema + +var CompleteLayerUploadRequest_layerDigests *smithy.Schema + +var CompleteLayerUploadResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "CompleteLayerUploadResponse", +}, smithy.ShapeTypeStructure, 4) +var CompleteLayerUploadResponse_registryId *smithy.Schema + +var CompleteLayerUploadResponse_repositoryName *smithy.Schema + +var CompleteLayerUploadResponse_uploadId *smithy.Schema + +var CompleteLayerUploadResponse_layerDigest *smithy.Schema + +var CreateRepositoryRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "CreateRepositoryRequest", +}, smithy.ShapeTypeStructure, 3) +var CreateRepositoryRequest_repositoryName *smithy.Schema + +var CreateRepositoryRequest_catalogData *smithy.Schema + +var CreateRepositoryRequest_tags *smithy.Schema + +var CreateRepositoryResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "CreateRepositoryResponse", +}, smithy.ShapeTypeStructure, 2) +var CreateRepositoryResponse_repository *smithy.Schema + +var CreateRepositoryResponse_catalogData *smithy.Schema + +var DeleteRepositoryRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "DeleteRepositoryRequest", +}, smithy.ShapeTypeStructure, 3) +var DeleteRepositoryRequest_registryId *smithy.Schema + +var DeleteRepositoryRequest_repositoryName *smithy.Schema + +var DeleteRepositoryRequest_force *smithy.Schema + +var DeleteRepositoryResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "DeleteRepositoryResponse", +}, smithy.ShapeTypeStructure, 1) +var DeleteRepositoryResponse_repository *smithy.Schema + +var DeleteRepositoryPolicyRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "DeleteRepositoryPolicyRequest", +}, smithy.ShapeTypeStructure, 2) +var DeleteRepositoryPolicyRequest_registryId *smithy.Schema + +var DeleteRepositoryPolicyRequest_repositoryName *smithy.Schema + +var DeleteRepositoryPolicyResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "DeleteRepositoryPolicyResponse", +}, smithy.ShapeTypeStructure, 3) +var DeleteRepositoryPolicyResponse_registryId *smithy.Schema + +var DeleteRepositoryPolicyResponse_repositoryName *smithy.Schema + +var DeleteRepositoryPolicyResponse_policyText *smithy.Schema + +var DescribeImagesRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "DescribeImagesRequest", +}, smithy.ShapeTypeStructure, 5) +var DescribeImagesRequest_registryId *smithy.Schema + +var DescribeImagesRequest_repositoryName *smithy.Schema + +var DescribeImagesRequest_imageIds *smithy.Schema + +var DescribeImagesRequest_nextToken *smithy.Schema + +var DescribeImagesRequest_maxResults *smithy.Schema + +var DescribeImagesResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "DescribeImagesResponse", +}, smithy.ShapeTypeStructure, 2) +var DescribeImagesResponse_imageDetails *smithy.Schema + +var DescribeImagesResponse_nextToken *smithy.Schema + +var DescribeImageTagsRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "DescribeImageTagsRequest", +}, smithy.ShapeTypeStructure, 4) +var DescribeImageTagsRequest_registryId *smithy.Schema + +var DescribeImageTagsRequest_repositoryName *smithy.Schema + +var DescribeImageTagsRequest_nextToken *smithy.Schema + +var DescribeImageTagsRequest_maxResults *smithy.Schema + +var DescribeImageTagsResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "DescribeImageTagsResponse", +}, smithy.ShapeTypeStructure, 2) +var DescribeImageTagsResponse_imageTagDetails *smithy.Schema + +var DescribeImageTagsResponse_nextToken *smithy.Schema + +var DescribeRegistriesRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "DescribeRegistriesRequest", +}, smithy.ShapeTypeStructure, 2) +var DescribeRegistriesRequest_nextToken *smithy.Schema + +var DescribeRegistriesRequest_maxResults *smithy.Schema + +var DescribeRegistriesResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "DescribeRegistriesResponse", +}, smithy.ShapeTypeStructure, 2) +var DescribeRegistriesResponse_registries *smithy.Schema + +var DescribeRegistriesResponse_nextToken *smithy.Schema + +var DescribeRepositoriesRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "DescribeRepositoriesRequest", +}, smithy.ShapeTypeStructure, 4) +var DescribeRepositoriesRequest_registryId *smithy.Schema + +var DescribeRepositoriesRequest_repositoryNames *smithy.Schema + +var DescribeRepositoriesRequest_nextToken *smithy.Schema + +var DescribeRepositoriesRequest_maxResults *smithy.Schema + +var DescribeRepositoriesResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "DescribeRepositoriesResponse", +}, smithy.ShapeTypeStructure, 2) +var DescribeRepositoriesResponse_repositories *smithy.Schema + +var DescribeRepositoriesResponse_nextToken *smithy.Schema + +var GetAuthorizationTokenRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "GetAuthorizationTokenRequest", +}, smithy.ShapeTypeStructure, 0) + +var GetAuthorizationTokenResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "GetAuthorizationTokenResponse", +}, smithy.ShapeTypeStructure, 1) +var GetAuthorizationTokenResponse_authorizationData *smithy.Schema + +var GetRegistryCatalogDataRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "GetRegistryCatalogDataRequest", +}, smithy.ShapeTypeStructure, 0) + +var GetRegistryCatalogDataResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "GetRegistryCatalogDataResponse", +}, smithy.ShapeTypeStructure, 1) +var GetRegistryCatalogDataResponse_registryCatalogData *smithy.Schema + +var GetRepositoryCatalogDataRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "GetRepositoryCatalogDataRequest", +}, smithy.ShapeTypeStructure, 2) +var GetRepositoryCatalogDataRequest_registryId *smithy.Schema + +var GetRepositoryCatalogDataRequest_repositoryName *smithy.Schema + +var GetRepositoryCatalogDataResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "GetRepositoryCatalogDataResponse", +}, smithy.ShapeTypeStructure, 1) +var GetRepositoryCatalogDataResponse_catalogData *smithy.Schema + +var GetRepositoryPolicyRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "GetRepositoryPolicyRequest", +}, smithy.ShapeTypeStructure, 2) +var GetRepositoryPolicyRequest_registryId *smithy.Schema + +var GetRepositoryPolicyRequest_repositoryName *smithy.Schema + +var GetRepositoryPolicyResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "GetRepositoryPolicyResponse", +}, smithy.ShapeTypeStructure, 3) +var GetRepositoryPolicyResponse_registryId *smithy.Schema + +var GetRepositoryPolicyResponse_repositoryName *smithy.Schema + +var GetRepositoryPolicyResponse_policyText *smithy.Schema + +var InitiateLayerUploadRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "InitiateLayerUploadRequest", +}, smithy.ShapeTypeStructure, 2) +var InitiateLayerUploadRequest_registryId *smithy.Schema + +var InitiateLayerUploadRequest_repositoryName *smithy.Schema + +var InitiateLayerUploadResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "InitiateLayerUploadResponse", +}, smithy.ShapeTypeStructure, 2) +var InitiateLayerUploadResponse_uploadId *smithy.Schema + +var InitiateLayerUploadResponse_partSize *smithy.Schema + +var ListTagsForResourceRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ListTagsForResourceRequest", +}, smithy.ShapeTypeStructure, 1) +var ListTagsForResourceRequest_resourceArn *smithy.Schema + +var ListTagsForResourceResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "ListTagsForResourceResponse", +}, smithy.ShapeTypeStructure, 1) +var ListTagsForResourceResponse_tags *smithy.Schema + +var PutImageRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "PutImageRequest", +}, smithy.ShapeTypeStructure, 6) +var PutImageRequest_registryId *smithy.Schema + +var PutImageRequest_repositoryName *smithy.Schema + +var PutImageRequest_imageManifest *smithy.Schema + +var PutImageRequest_imageManifestMediaType *smithy.Schema + +var PutImageRequest_imageTag *smithy.Schema + +var PutImageRequest_imageDigest *smithy.Schema + +var PutImageResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "PutImageResponse", +}, smithy.ShapeTypeStructure, 1) +var PutImageResponse_image *smithy.Schema + +var PutRegistryCatalogDataRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "PutRegistryCatalogDataRequest", +}, smithy.ShapeTypeStructure, 1) +var PutRegistryCatalogDataRequest_displayName *smithy.Schema + +var PutRegistryCatalogDataResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "PutRegistryCatalogDataResponse", +}, smithy.ShapeTypeStructure, 1) +var PutRegistryCatalogDataResponse_registryCatalogData *smithy.Schema + +var PutRepositoryCatalogDataRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "PutRepositoryCatalogDataRequest", +}, smithy.ShapeTypeStructure, 3) +var PutRepositoryCatalogDataRequest_registryId *smithy.Schema + +var PutRepositoryCatalogDataRequest_repositoryName *smithy.Schema + +var PutRepositoryCatalogDataRequest_catalogData *smithy.Schema + +var PutRepositoryCatalogDataResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "PutRepositoryCatalogDataResponse", +}, smithy.ShapeTypeStructure, 1) +var PutRepositoryCatalogDataResponse_catalogData *smithy.Schema + +var SetRepositoryPolicyRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "SetRepositoryPolicyRequest", +}, smithy.ShapeTypeStructure, 4) +var SetRepositoryPolicyRequest_registryId *smithy.Schema + +var SetRepositoryPolicyRequest_repositoryName *smithy.Schema + +var SetRepositoryPolicyRequest_policyText *smithy.Schema + +var SetRepositoryPolicyRequest_force *smithy.Schema + +var SetRepositoryPolicyResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "SetRepositoryPolicyResponse", +}, smithy.ShapeTypeStructure, 3) +var SetRepositoryPolicyResponse_registryId *smithy.Schema + +var SetRepositoryPolicyResponse_repositoryName *smithy.Schema + +var SetRepositoryPolicyResponse_policyText *smithy.Schema + +var TagResourceRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "TagResourceRequest", +}, smithy.ShapeTypeStructure, 2) +var TagResourceRequest_resourceArn *smithy.Schema + +var TagResourceRequest_tags *smithy.Schema + +var TagResourceResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "TagResourceResponse", +}, smithy.ShapeTypeStructure, 0) + +var UntagResourceRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "UntagResourceRequest", +}, smithy.ShapeTypeStructure, 2) +var UntagResourceRequest_resourceArn *smithy.Schema + +var UntagResourceRequest_tagKeys *smithy.Schema + +var UntagResourceResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "UntagResourceResponse", +}, smithy.ShapeTypeStructure, 0) + +var UploadLayerPartRequest = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "UploadLayerPartRequest", +}, smithy.ShapeTypeStructure, 6) +var UploadLayerPartRequest_registryId *smithy.Schema + +var UploadLayerPartRequest_repositoryName *smithy.Schema + +var UploadLayerPartRequest_uploadId *smithy.Schema + +var UploadLayerPartRequest_partFirstByte *smithy.Schema + +var UploadLayerPartRequest_partLastByte *smithy.Schema + +var UploadLayerPartRequest_layerPartBlob *smithy.Schema + +var UploadLayerPartResponse = smithy.NewSchema(smithy.ShapeID{ + Namespace: "com.amazonaws.ecrpublic", + Name: "UploadLayerPartResponse", +}, smithy.ShapeTypeStructure, 4) +var UploadLayerPartResponse_registryId *smithy.Schema + +var UploadLayerPartResponse_repositoryName *smithy.Schema + +var UploadLayerPartResponse_uploadId *smithy.Schema + +var UploadLayerPartResponse_lastByteReceived *smithy.Schema + +// Initialize schema members after all schemas are declared to avoid +// initialization cycles +func init() { + _ArchitectureList_member = _ArchitectureList.AddMember("member", _Architecture) + + AuthorizationData_authorizationToken = AuthorizationData.AddMember("authorizationToken", _Base64) + + AuthorizationData_expiresAt = AuthorizationData.AddMember("expiresAt", _ExpirationTimestamp) + + _BatchedOperationLayerDigestList_member = _BatchedOperationLayerDigestList.AddMember("member", _BatchedOperationLayerDigest) + + EmptyUploadException_message = EmptyUploadException.AddMember("message", _ExceptionMessage) + + ImageIdentifier_imageDigest = ImageIdentifier.AddMember("imageDigest", _ImageDigest) + + ImageIdentifier_imageTag = ImageIdentifier.AddMember("imageTag", _ImageTag) + + Image_registryId = Image.AddMember("registryId", _RegistryIdOrAlias) + + Image_repositoryName = Image.AddMember("repositoryName", _RepositoryName) + + Image_imageId = Image.AddMember("imageId", ImageIdentifier) + + Image_imageManifest = Image.AddMember("imageManifest", _ImageManifest) + + Image_imageManifestMediaType = Image.AddMember("imageManifestMediaType", _MediaType) + + ImageAlreadyExistsException_message = ImageAlreadyExistsException.AddMember("message", _ExceptionMessage) + + _ImageTagList_member = _ImageTagList.AddMember("member", _ImageTag) + + ImageDetail_registryId = ImageDetail.AddMember("registryId", _RegistryId) + + ImageDetail_repositoryName = ImageDetail.AddMember("repositoryName", _RepositoryName) + + ImageDetail_imageDigest = ImageDetail.AddMember("imageDigest", _ImageDigest) + + ImageDetail_imageTags = ImageDetail.AddMember("imageTags", _ImageTagList) + + ImageDetail_imageSizeInBytes = ImageDetail.AddMember("imageSizeInBytes", _ImageSizeInBytes) + + ImageDetail_imagePushedAt = ImageDetail.AddMember("imagePushedAt", _PushTimestamp) + + ImageDetail_imageManifestMediaType = ImageDetail.AddMember("imageManifestMediaType", _MediaType) + + ImageDetail_artifactMediaType = ImageDetail.AddMember("artifactMediaType", _MediaType) + + _ImageDetailList_member = _ImageDetailList.AddMember("member", ImageDetail) + + ImageDigestDoesNotMatchException_message = ImageDigestDoesNotMatchException.AddMember("message", _ExceptionMessage) + + ImageFailureCode_InvalidImageDigest = ImageFailureCode.AddMember("InvalidImageDigest", smithyprelude.Unit) + + ImageFailureCode_InvalidImageTag = ImageFailureCode.AddMember("InvalidImageTag", smithyprelude.Unit) + + ImageFailureCode_ImageTagDoesNotMatchDigest = ImageFailureCode.AddMember("ImageTagDoesNotMatchDigest", smithyprelude.Unit) + + ImageFailureCode_ImageNotFound = ImageFailureCode.AddMember("ImageNotFound", smithyprelude.Unit) + + ImageFailureCode_MissingDigestAndTag = ImageFailureCode.AddMember("MissingDigestAndTag", smithyprelude.Unit) + + ImageFailureCode_ImageReferencedByManifestList = ImageFailureCode.AddMember("ImageReferencedByManifestList", smithyprelude.Unit) + + ImageFailureCode_KmsError = ImageFailureCode.AddMember("KmsError", smithyprelude.Unit) + + ImageFailure_imageId = ImageFailure.AddMember("imageId", ImageIdentifier) + + ImageFailure_failureCode = ImageFailure.AddMember("failureCode", ImageFailureCode) + + ImageFailure_failureReason = ImageFailure.AddMember("failureReason", _ImageFailureReason) + + _ImageFailureList_member = _ImageFailureList.AddMember("member", ImageFailure) + + _ImageIdentifierList_member = _ImageIdentifierList.AddMember("member", ImageIdentifier) + + ImageNotFoundException_message = ImageNotFoundException.AddMember("message", _ExceptionMessage) + + ImageTagAlreadyExistsException_message = ImageTagAlreadyExistsException.AddMember("message", _ExceptionMessage) + + ReferencedImageDetail_imageDigest = ReferencedImageDetail.AddMember("imageDigest", _ImageDigest) + + ReferencedImageDetail_imageSizeInBytes = ReferencedImageDetail.AddMember("imageSizeInBytes", _ImageSizeInBytes) + + ReferencedImageDetail_imagePushedAt = ReferencedImageDetail.AddMember("imagePushedAt", _PushTimestamp) + + ReferencedImageDetail_imageManifestMediaType = ReferencedImageDetail.AddMember("imageManifestMediaType", _MediaType) + + ReferencedImageDetail_artifactMediaType = ReferencedImageDetail.AddMember("artifactMediaType", _MediaType) + + ImageTagDetail_imageTag = ImageTagDetail.AddMember("imageTag", _ImageTag) + + ImageTagDetail_createdAt = ImageTagDetail.AddMember("createdAt", _CreationTimestamp) + + ImageTagDetail_imageDetail = ImageTagDetail.AddMember("imageDetail", ReferencedImageDetail) + + _ImageTagDetailList_member = _ImageTagDetailList.AddMember("member", ImageTagDetail) + + InvalidLayerException_message = InvalidLayerException.AddMember("message", _ExceptionMessage) + + InvalidLayerPartException_registryId = InvalidLayerPartException.AddMember("registryId", _RegistryId) + + InvalidLayerPartException_repositoryName = InvalidLayerPartException.AddMember("repositoryName", _RepositoryName) + + InvalidLayerPartException_uploadId = InvalidLayerPartException.AddMember("uploadId", _UploadId) + + InvalidLayerPartException_lastValidByteReceived = InvalidLayerPartException.AddMember("lastValidByteReceived", _PartSize) + + InvalidLayerPartException_message = InvalidLayerPartException.AddMember("message", _ExceptionMessage) + + InvalidParameterException_message = InvalidParameterException.AddMember("message", _ExceptionMessage) + + InvalidTagParameterException_message = InvalidTagParameterException.AddMember("message", _ExceptionMessage) + + LayerAvailability_AVAILABLE = LayerAvailability.AddMember("AVAILABLE", smithyprelude.Unit) + + LayerAvailability_UNAVAILABLE = LayerAvailability.AddMember("UNAVAILABLE", smithyprelude.Unit) + + Layer_layerDigest = Layer.AddMember("layerDigest", _LayerDigest) + + Layer_layerAvailability = Layer.AddMember("layerAvailability", LayerAvailability) + + Layer_layerSize = Layer.AddMember("layerSize", _LayerSizeInBytes) + + Layer_mediaType = Layer.AddMember("mediaType", _MediaType) + + LayerAlreadyExistsException_message = LayerAlreadyExistsException.AddMember("message", _ExceptionMessage) + + _LayerDigestList_member = _LayerDigestList.AddMember("member", _LayerDigest) + + LayerFailureCode_InvalidLayerDigest = LayerFailureCode.AddMember("InvalidLayerDigest", smithyprelude.Unit) + + LayerFailureCode_MissingLayerDigest = LayerFailureCode.AddMember("MissingLayerDigest", smithyprelude.Unit) + + LayerFailure_layerDigest = LayerFailure.AddMember("layerDigest", _BatchedOperationLayerDigest) + + LayerFailure_failureCode = LayerFailure.AddMember("failureCode", LayerFailureCode) + + LayerFailure_failureReason = LayerFailure.AddMember("failureReason", _LayerFailureReason) + + _LayerFailureList_member = _LayerFailureList.AddMember("member", LayerFailure) + + _LayerList_member = _LayerList.AddMember("member", Layer) + + LayerPartTooSmallException_message = LayerPartTooSmallException.AddMember("message", _ExceptionMessage) + + LayersNotFoundException_message = LayersNotFoundException.AddMember("message", _ExceptionMessage) + + LimitExceededException_message = LimitExceededException.AddMember("message", _ExceptionMessage) + + _OperatingSystemList_member = _OperatingSystemList.AddMember("member", _OperatingSystem) + + ReferencedImagesNotFoundException_message = ReferencedImagesNotFoundException.AddMember("message", _ExceptionMessage) + + RegistryAliasStatus_ACTIVE = RegistryAliasStatus.AddMember("ACTIVE", smithyprelude.Unit) + + RegistryAliasStatus_PENDING = RegistryAliasStatus.AddMember("PENDING", smithyprelude.Unit) + + RegistryAliasStatus_REJECTED = RegistryAliasStatus.AddMember("REJECTED", smithyprelude.Unit) + + RegistryAlias_name = RegistryAlias.AddMember("name", _RegistryAliasName) + + RegistryAlias_status = RegistryAlias.AddMember("status", RegistryAliasStatus) + + RegistryAlias_primaryRegistryAlias = RegistryAlias.AddMember("primaryRegistryAlias", _PrimaryRegistryAliasFlag) + + RegistryAlias_defaultRegistryAlias = RegistryAlias.AddMember("defaultRegistryAlias", _DefaultRegistryAliasFlag) + + _RegistryAliasList_member = _RegistryAliasList.AddMember("member", RegistryAlias) + + Registry_registryId = Registry.AddMember("registryId", _RegistryId) + + Registry_registryArn = Registry.AddMember("registryArn", _Arn) + + Registry_registryUri = Registry.AddMember("registryUri", _Url) + + Registry_verified = Registry.AddMember("verified", _RegistryVerified) + + Registry_aliases = Registry.AddMember("aliases", _RegistryAliasList) + + RegistryCatalogData_displayName = RegistryCatalogData.AddMember("displayName", _RegistryDisplayName) + + _RegistryList_member = _RegistryList.AddMember("member", Registry) + + RegistryNotFoundException_message = RegistryNotFoundException.AddMember("message", _ExceptionMessage) + + Repository_repositoryArn = Repository.AddMember("repositoryArn", _Arn) + + Repository_registryId = Repository.AddMember("registryId", _RegistryId) + + Repository_repositoryName = Repository.AddMember("repositoryName", _RepositoryName) + + Repository_repositoryUri = Repository.AddMember("repositoryUri", _Url) + + Repository_createdAt = Repository.AddMember("createdAt", _CreationTimestamp) + + RepositoryAlreadyExistsException_message = RepositoryAlreadyExistsException.AddMember("message", _ExceptionMessage) + + RepositoryCatalogData_description = RepositoryCatalogData.AddMember("description", _RepositoryDescription) + + RepositoryCatalogData_architectures = RepositoryCatalogData.AddMember("architectures", _ArchitectureList) + + RepositoryCatalogData_operatingSystems = RepositoryCatalogData.AddMember("operatingSystems", _OperatingSystemList) + + RepositoryCatalogData_logoUrl = RepositoryCatalogData.AddMember("logoUrl", _ResourceUrl) + + RepositoryCatalogData_aboutText = RepositoryCatalogData.AddMember("aboutText", _AboutText) + + RepositoryCatalogData_usageText = RepositoryCatalogData.AddMember("usageText", _UsageText) + + RepositoryCatalogData_marketplaceCertified = RepositoryCatalogData.AddMember("marketplaceCertified", _MarketplaceCertified) + + RepositoryCatalogDataInput_description = RepositoryCatalogDataInput.AddMember("description", _RepositoryDescription) + + RepositoryCatalogDataInput_architectures = RepositoryCatalogDataInput.AddMember("architectures", _ArchitectureList) + + RepositoryCatalogDataInput_operatingSystems = RepositoryCatalogDataInput.AddMember("operatingSystems", _OperatingSystemList) + + RepositoryCatalogDataInput_logoImageBlob = RepositoryCatalogDataInput.AddMember("logoImageBlob", _LogoImageBlob) + + RepositoryCatalogDataInput_aboutText = RepositoryCatalogDataInput.AddMember("aboutText", _AboutText) + + RepositoryCatalogDataInput_usageText = RepositoryCatalogDataInput.AddMember("usageText", _UsageText) + + RepositoryCatalogDataNotFoundException_message = RepositoryCatalogDataNotFoundException.AddMember("message", _ExceptionMessage) + + _RepositoryList_member = _RepositoryList.AddMember("member", Repository) + + _RepositoryNameList_member = _RepositoryNameList.AddMember("member", _RepositoryName) + + RepositoryNotEmptyException_message = RepositoryNotEmptyException.AddMember("message", _ExceptionMessage) + + RepositoryNotFoundException_message = RepositoryNotFoundException.AddMember("message", _ExceptionMessage) + + RepositoryPolicyNotFoundException_message = RepositoryPolicyNotFoundException.AddMember("message", _ExceptionMessage) + + ServerException_message = ServerException.AddMember("message", _ExceptionMessage) + + Tag_Key = Tag.AddMember("Key", _TagKey) + + Tag_Value = Tag.AddMember("Value", _TagValue) + + _TagKeyList_member = _TagKeyList.AddMember("member", _TagKey) + + _TagList_member = _TagList.AddMember("member", Tag) + + TooManyTagsException_message = TooManyTagsException.AddMember("message", _ExceptionMessage) + + UnsupportedCommandException_message = UnsupportedCommandException.AddMember("message", _ExceptionMessage) + + UploadNotFoundException_message = UploadNotFoundException.AddMember("message", _ExceptionMessage) + + BatchCheckLayerAvailabilityRequest_registryId = BatchCheckLayerAvailabilityRequest.AddMember("registryId", _RegistryIdOrAlias) + + BatchCheckLayerAvailabilityRequest_repositoryName = BatchCheckLayerAvailabilityRequest.AddMember("repositoryName", _RepositoryName) + + BatchCheckLayerAvailabilityRequest_layerDigests = BatchCheckLayerAvailabilityRequest.AddMember("layerDigests", _BatchedOperationLayerDigestList) + + BatchCheckLayerAvailabilityResponse_layers = BatchCheckLayerAvailabilityResponse.AddMember("layers", _LayerList) + + BatchCheckLayerAvailabilityResponse_failures = BatchCheckLayerAvailabilityResponse.AddMember("failures", _LayerFailureList) + + BatchDeleteImageRequest_registryId = BatchDeleteImageRequest.AddMember("registryId", _RegistryIdOrAlias) + + BatchDeleteImageRequest_repositoryName = BatchDeleteImageRequest.AddMember("repositoryName", _RepositoryName) + + BatchDeleteImageRequest_imageIds = BatchDeleteImageRequest.AddMember("imageIds", _ImageIdentifierList) + + BatchDeleteImageResponse_imageIds = BatchDeleteImageResponse.AddMember("imageIds", _ImageIdentifierList) + + BatchDeleteImageResponse_failures = BatchDeleteImageResponse.AddMember("failures", _ImageFailureList) + + CompleteLayerUploadRequest_registryId = CompleteLayerUploadRequest.AddMember("registryId", _RegistryIdOrAlias) + + CompleteLayerUploadRequest_repositoryName = CompleteLayerUploadRequest.AddMember("repositoryName", _RepositoryName) + + CompleteLayerUploadRequest_uploadId = CompleteLayerUploadRequest.AddMember("uploadId", _UploadId) + + CompleteLayerUploadRequest_layerDigests = CompleteLayerUploadRequest.AddMember("layerDigests", _LayerDigestList) + + CompleteLayerUploadResponse_registryId = CompleteLayerUploadResponse.AddMember("registryId", _RegistryId) + + CompleteLayerUploadResponse_repositoryName = CompleteLayerUploadResponse.AddMember("repositoryName", _RepositoryName) + + CompleteLayerUploadResponse_uploadId = CompleteLayerUploadResponse.AddMember("uploadId", _UploadId) + + CompleteLayerUploadResponse_layerDigest = CompleteLayerUploadResponse.AddMember("layerDigest", _LayerDigest) + + CreateRepositoryRequest_repositoryName = CreateRepositoryRequest.AddMember("repositoryName", _RepositoryName) + + CreateRepositoryRequest_catalogData = CreateRepositoryRequest.AddMember("catalogData", RepositoryCatalogDataInput) + + CreateRepositoryRequest_tags = CreateRepositoryRequest.AddMember("tags", _TagList) + + CreateRepositoryResponse_repository = CreateRepositoryResponse.AddMember("repository", Repository) + + CreateRepositoryResponse_catalogData = CreateRepositoryResponse.AddMember("catalogData", RepositoryCatalogData) + + DeleteRepositoryRequest_registryId = DeleteRepositoryRequest.AddMember("registryId", _RegistryId) + + DeleteRepositoryRequest_repositoryName = DeleteRepositoryRequest.AddMember("repositoryName", _RepositoryName) + + DeleteRepositoryRequest_force = DeleteRepositoryRequest.AddMember("force", _ForceFlag) + + DeleteRepositoryResponse_repository = DeleteRepositoryResponse.AddMember("repository", Repository) + + DeleteRepositoryPolicyRequest_registryId = DeleteRepositoryPolicyRequest.AddMember("registryId", _RegistryId) + + DeleteRepositoryPolicyRequest_repositoryName = DeleteRepositoryPolicyRequest.AddMember("repositoryName", _RepositoryName) + + DeleteRepositoryPolicyResponse_registryId = DeleteRepositoryPolicyResponse.AddMember("registryId", _RegistryId) + + DeleteRepositoryPolicyResponse_repositoryName = DeleteRepositoryPolicyResponse.AddMember("repositoryName", _RepositoryName) + + DeleteRepositoryPolicyResponse_policyText = DeleteRepositoryPolicyResponse.AddMember("policyText", _RepositoryPolicyText) + + DescribeImagesRequest_registryId = DescribeImagesRequest.AddMember("registryId", _RegistryId) + + DescribeImagesRequest_repositoryName = DescribeImagesRequest.AddMember("repositoryName", _RepositoryName) + + DescribeImagesRequest_imageIds = DescribeImagesRequest.AddMember("imageIds", _ImageIdentifierList) + + DescribeImagesRequest_nextToken = DescribeImagesRequest.AddMember("nextToken", _NextToken) + + DescribeImagesRequest_maxResults = DescribeImagesRequest.AddMember("maxResults", _MaxResults) + + DescribeImagesResponse_imageDetails = DescribeImagesResponse.AddMember("imageDetails", _ImageDetailList) + + DescribeImagesResponse_nextToken = DescribeImagesResponse.AddMember("nextToken", _NextToken) + + DescribeImageTagsRequest_registryId = DescribeImageTagsRequest.AddMember("registryId", _RegistryId) + + DescribeImageTagsRequest_repositoryName = DescribeImageTagsRequest.AddMember("repositoryName", _RepositoryName) + + DescribeImageTagsRequest_nextToken = DescribeImageTagsRequest.AddMember("nextToken", _NextToken) + + DescribeImageTagsRequest_maxResults = DescribeImageTagsRequest.AddMember("maxResults", _MaxResults) + + DescribeImageTagsResponse_imageTagDetails = DescribeImageTagsResponse.AddMember("imageTagDetails", _ImageTagDetailList) + + DescribeImageTagsResponse_nextToken = DescribeImageTagsResponse.AddMember("nextToken", _NextToken) + + DescribeRegistriesRequest_nextToken = DescribeRegistriesRequest.AddMember("nextToken", _NextToken) + + DescribeRegistriesRequest_maxResults = DescribeRegistriesRequest.AddMember("maxResults", _MaxResults) + + DescribeRegistriesResponse_registries = DescribeRegistriesResponse.AddMember("registries", _RegistryList) + + DescribeRegistriesResponse_nextToken = DescribeRegistriesResponse.AddMember("nextToken", _NextToken) + + DescribeRepositoriesRequest_registryId = DescribeRepositoriesRequest.AddMember("registryId", _RegistryId) + + DescribeRepositoriesRequest_repositoryNames = DescribeRepositoriesRequest.AddMember("repositoryNames", _RepositoryNameList) + + DescribeRepositoriesRequest_nextToken = DescribeRepositoriesRequest.AddMember("nextToken", _NextToken) + + DescribeRepositoriesRequest_maxResults = DescribeRepositoriesRequest.AddMember("maxResults", _MaxResults) + + DescribeRepositoriesResponse_repositories = DescribeRepositoriesResponse.AddMember("repositories", _RepositoryList) + + DescribeRepositoriesResponse_nextToken = DescribeRepositoriesResponse.AddMember("nextToken", _NextToken) + + GetAuthorizationTokenResponse_authorizationData = GetAuthorizationTokenResponse.AddMember("authorizationData", AuthorizationData) + + GetRegistryCatalogDataResponse_registryCatalogData = GetRegistryCatalogDataResponse.AddMember("registryCatalogData", RegistryCatalogData) + + GetRepositoryCatalogDataRequest_registryId = GetRepositoryCatalogDataRequest.AddMember("registryId", _RegistryId) + + GetRepositoryCatalogDataRequest_repositoryName = GetRepositoryCatalogDataRequest.AddMember("repositoryName", _RepositoryName) + + GetRepositoryCatalogDataResponse_catalogData = GetRepositoryCatalogDataResponse.AddMember("catalogData", RepositoryCatalogData) + + GetRepositoryPolicyRequest_registryId = GetRepositoryPolicyRequest.AddMember("registryId", _RegistryId) + + GetRepositoryPolicyRequest_repositoryName = GetRepositoryPolicyRequest.AddMember("repositoryName", _RepositoryName) + + GetRepositoryPolicyResponse_registryId = GetRepositoryPolicyResponse.AddMember("registryId", _RegistryId) + + GetRepositoryPolicyResponse_repositoryName = GetRepositoryPolicyResponse.AddMember("repositoryName", _RepositoryName) + + GetRepositoryPolicyResponse_policyText = GetRepositoryPolicyResponse.AddMember("policyText", _RepositoryPolicyText) + + InitiateLayerUploadRequest_registryId = InitiateLayerUploadRequest.AddMember("registryId", _RegistryIdOrAlias) + + InitiateLayerUploadRequest_repositoryName = InitiateLayerUploadRequest.AddMember("repositoryName", _RepositoryName) + + InitiateLayerUploadResponse_uploadId = InitiateLayerUploadResponse.AddMember("uploadId", _UploadId) + + InitiateLayerUploadResponse_partSize = InitiateLayerUploadResponse.AddMember("partSize", _PartSize) + + ListTagsForResourceRequest_resourceArn = ListTagsForResourceRequest.AddMember("resourceArn", _Arn) + + ListTagsForResourceResponse_tags = ListTagsForResourceResponse.AddMember("tags", _TagList) + + PutImageRequest_registryId = PutImageRequest.AddMember("registryId", _RegistryIdOrAlias) + + PutImageRequest_repositoryName = PutImageRequest.AddMember("repositoryName", _RepositoryName) + + PutImageRequest_imageManifest = PutImageRequest.AddMember("imageManifest", _ImageManifest) + + PutImageRequest_imageManifestMediaType = PutImageRequest.AddMember("imageManifestMediaType", _MediaType) + + PutImageRequest_imageTag = PutImageRequest.AddMember("imageTag", _ImageTag) + + PutImageRequest_imageDigest = PutImageRequest.AddMember("imageDigest", _ImageDigest) + + PutImageResponse_image = PutImageResponse.AddMember("image", Image) + + PutRegistryCatalogDataRequest_displayName = PutRegistryCatalogDataRequest.AddMember("displayName", _RegistryDisplayName) + + PutRegistryCatalogDataResponse_registryCatalogData = PutRegistryCatalogDataResponse.AddMember("registryCatalogData", RegistryCatalogData) + + PutRepositoryCatalogDataRequest_registryId = PutRepositoryCatalogDataRequest.AddMember("registryId", _RegistryId) + + PutRepositoryCatalogDataRequest_repositoryName = PutRepositoryCatalogDataRequest.AddMember("repositoryName", _RepositoryName) + + PutRepositoryCatalogDataRequest_catalogData = PutRepositoryCatalogDataRequest.AddMember("catalogData", RepositoryCatalogDataInput) + + PutRepositoryCatalogDataResponse_catalogData = PutRepositoryCatalogDataResponse.AddMember("catalogData", RepositoryCatalogData) + + SetRepositoryPolicyRequest_registryId = SetRepositoryPolicyRequest.AddMember("registryId", _RegistryId) + + SetRepositoryPolicyRequest_repositoryName = SetRepositoryPolicyRequest.AddMember("repositoryName", _RepositoryName) + + SetRepositoryPolicyRequest_policyText = SetRepositoryPolicyRequest.AddMember("policyText", _RepositoryPolicyText) + + SetRepositoryPolicyRequest_force = SetRepositoryPolicyRequest.AddMember("force", _ForceFlag) + + SetRepositoryPolicyResponse_registryId = SetRepositoryPolicyResponse.AddMember("registryId", _RegistryId) + + SetRepositoryPolicyResponse_repositoryName = SetRepositoryPolicyResponse.AddMember("repositoryName", _RepositoryName) + + SetRepositoryPolicyResponse_policyText = SetRepositoryPolicyResponse.AddMember("policyText", _RepositoryPolicyText) + + TagResourceRequest_resourceArn = TagResourceRequest.AddMember("resourceArn", _Arn) + + TagResourceRequest_tags = TagResourceRequest.AddMember("tags", _TagList) + + UntagResourceRequest_resourceArn = UntagResourceRequest.AddMember("resourceArn", _Arn) + + UntagResourceRequest_tagKeys = UntagResourceRequest.AddMember("tagKeys", _TagKeyList) + + UploadLayerPartRequest_registryId = UploadLayerPartRequest.AddMember("registryId", _RegistryIdOrAlias) + + UploadLayerPartRequest_repositoryName = UploadLayerPartRequest.AddMember("repositoryName", _RepositoryName) + + UploadLayerPartRequest_uploadId = UploadLayerPartRequest.AddMember("uploadId", _UploadId) + + UploadLayerPartRequest_partFirstByte = UploadLayerPartRequest.AddMember("partFirstByte", _PartSize) + + UploadLayerPartRequest_partLastByte = UploadLayerPartRequest.AddMember("partLastByte", _PartSize) + + UploadLayerPartRequest_layerPartBlob = UploadLayerPartRequest.AddMember("layerPartBlob", _LayerPartBlob) + + UploadLayerPartResponse_registryId = UploadLayerPartResponse.AddMember("registryId", _RegistryId) + + UploadLayerPartResponse_repositoryName = UploadLayerPartResponse.AddMember("repositoryName", _RepositoryName) + + UploadLayerPartResponse_uploadId = UploadLayerPartResponse.AddMember("uploadId", _UploadId) + + UploadLayerPartResponse_lastByteReceived = UploadLayerPartResponse.AddMember("lastByteReceived", _PartSize) + +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/type_registry.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/type_registry.go new file mode 100644 index 0000000..1d7802a --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/type_registry.go @@ -0,0 +1,111 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/types" + smithy "github.com/aws/smithy-go" +) + +// TypeRegistry is the type registry for this service. +var TypeRegistry = &smithy.TypeRegistry{ + Entries: map[string]*smithy.TypeRegistryEntry{ + "com.amazonaws.ecrpublic#EmptyUploadException": { + Schema: schemas.EmptyUploadException, + New: func() any { return &types.EmptyUploadException{} }, + }, + "com.amazonaws.ecrpublic#ImageAlreadyExistsException": { + Schema: schemas.ImageAlreadyExistsException, + New: func() any { return &types.ImageAlreadyExistsException{} }, + }, + "com.amazonaws.ecrpublic#ImageDigestDoesNotMatchException": { + Schema: schemas.ImageDigestDoesNotMatchException, + New: func() any { return &types.ImageDigestDoesNotMatchException{} }, + }, + "com.amazonaws.ecrpublic#ImageNotFoundException": { + Schema: schemas.ImageNotFoundException, + New: func() any { return &types.ImageNotFoundException{} }, + }, + "com.amazonaws.ecrpublic#ImageTagAlreadyExistsException": { + Schema: schemas.ImageTagAlreadyExistsException, + New: func() any { return &types.ImageTagAlreadyExistsException{} }, + }, + "com.amazonaws.ecrpublic#InvalidLayerException": { + Schema: schemas.InvalidLayerException, + New: func() any { return &types.InvalidLayerException{} }, + }, + "com.amazonaws.ecrpublic#InvalidLayerPartException": { + Schema: schemas.InvalidLayerPartException, + New: func() any { return &types.InvalidLayerPartException{} }, + }, + "com.amazonaws.ecrpublic#InvalidParameterException": { + Schema: schemas.InvalidParameterException, + New: func() any { return &types.InvalidParameterException{} }, + }, + "com.amazonaws.ecrpublic#InvalidTagParameterException": { + Schema: schemas.InvalidTagParameterException, + New: func() any { return &types.InvalidTagParameterException{} }, + }, + "com.amazonaws.ecrpublic#LayerAlreadyExistsException": { + Schema: schemas.LayerAlreadyExistsException, + New: func() any { return &types.LayerAlreadyExistsException{} }, + }, + "com.amazonaws.ecrpublic#LayerPartTooSmallException": { + Schema: schemas.LayerPartTooSmallException, + New: func() any { return &types.LayerPartTooSmallException{} }, + }, + "com.amazonaws.ecrpublic#LayersNotFoundException": { + Schema: schemas.LayersNotFoundException, + New: func() any { return &types.LayersNotFoundException{} }, + }, + "com.amazonaws.ecrpublic#LimitExceededException": { + Schema: schemas.LimitExceededException, + New: func() any { return &types.LimitExceededException{} }, + }, + "com.amazonaws.ecrpublic#ReferencedImagesNotFoundException": { + Schema: schemas.ReferencedImagesNotFoundException, + New: func() any { return &types.ReferencedImagesNotFoundException{} }, + }, + "com.amazonaws.ecrpublic#RegistryNotFoundException": { + Schema: schemas.RegistryNotFoundException, + New: func() any { return &types.RegistryNotFoundException{} }, + }, + "com.amazonaws.ecrpublic#RepositoryAlreadyExistsException": { + Schema: schemas.RepositoryAlreadyExistsException, + New: func() any { return &types.RepositoryAlreadyExistsException{} }, + }, + "com.amazonaws.ecrpublic#RepositoryCatalogDataNotFoundException": { + Schema: schemas.RepositoryCatalogDataNotFoundException, + New: func() any { return &types.RepositoryCatalogDataNotFoundException{} }, + }, + "com.amazonaws.ecrpublic#RepositoryNotEmptyException": { + Schema: schemas.RepositoryNotEmptyException, + New: func() any { return &types.RepositoryNotEmptyException{} }, + }, + "com.amazonaws.ecrpublic#RepositoryNotFoundException": { + Schema: schemas.RepositoryNotFoundException, + New: func() any { return &types.RepositoryNotFoundException{} }, + }, + "com.amazonaws.ecrpublic#RepositoryPolicyNotFoundException": { + Schema: schemas.RepositoryPolicyNotFoundException, + New: func() any { return &types.RepositoryPolicyNotFoundException{} }, + }, + "com.amazonaws.ecrpublic#ServerException": { + Schema: schemas.ServerException, + New: func() any { return &types.ServerException{} }, + }, + "com.amazonaws.ecrpublic#TooManyTagsException": { + Schema: schemas.TooManyTagsException, + New: func() any { return &types.TooManyTagsException{} }, + }, + "com.amazonaws.ecrpublic#UnsupportedCommandException": { + Schema: schemas.UnsupportedCommandException, + New: func() any { return &types.UnsupportedCommandException{} }, + }, + "com.amazonaws.ecrpublic#UploadNotFoundException": { + Schema: schemas.UploadNotFoundException, + New: func() any { return &types.UploadNotFoundException{} }, + }, + }, +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/types/common_serde.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/types/common_serde.go new file mode 100644 index 0000000..e9feece --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/types/common_serde.go @@ -0,0 +1,452 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package types + +import ( + smithy "github.com/aws/smithy-go" +) + +func serializeArchitectureList(s smithy.ShapeSerializer, schema *smithy.Schema, v []string) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeBatchedOperationLayerDigestList(s smithy.ShapeSerializer, schema *smithy.Schema, v []string) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeImageDetailList(s smithy.ShapeSerializer, schema *smithy.Schema, v []ImageDetail) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeImageFailureList(s smithy.ShapeSerializer, schema *smithy.Schema, v []ImageFailure) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeImageIdentifierList(s smithy.ShapeSerializer, schema *smithy.Schema, v []ImageIdentifier) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeImageTagDetailList(s smithy.ShapeSerializer, schema *smithy.Schema, v []ImageTagDetail) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeImageTagList(s smithy.ShapeSerializer, schema *smithy.Schema, v []string) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeLayerDigestList(s smithy.ShapeSerializer, schema *smithy.Schema, v []string) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeLayerFailureList(s smithy.ShapeSerializer, schema *smithy.Schema, v []LayerFailure) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeLayerList(s smithy.ShapeSerializer, schema *smithy.Schema, v []Layer) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeOperatingSystemList(s smithy.ShapeSerializer, schema *smithy.Schema, v []string) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeRegistryAliasList(s smithy.ShapeSerializer, schema *smithy.Schema, v []RegistryAlias) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeRegistryList(s smithy.ShapeSerializer, schema *smithy.Schema, v []Registry) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeRepositoryList(s smithy.ShapeSerializer, schema *smithy.Schema, v []Repository) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func serializeRepositoryNameList(s smithy.ShapeSerializer, schema *smithy.Schema, v []string) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeTagKeyList(s smithy.ShapeSerializer, schema *smithy.Schema, v []string) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteString(schema.ListMember(), string(vv)) + } + s.CloseList() +} + +func serializeTagList(s smithy.ShapeSerializer, schema *smithy.Schema, v []Tag) { + if v == nil { + return + } + s.WriteList(schema) + for _, vv := range v { + s.WriteStruct(schema.ListMember()) + vv.SerializeMembers(s) + s.CloseStruct() + } + s.CloseList() +} + +func deserializeArchitectureList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]string) error { + *v = make([]string, 0) + var vv string + return smithy.ReadList(d, s, func() error { + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeBatchedOperationLayerDigestList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]string) error { + *v = make([]string, 0) + var vv string + return smithy.ReadList(d, s, func() error { + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeImageDetailList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]ImageDetail) error { + *v = make([]ImageDetail, 0) + var vv ImageDetail + return smithy.ReadList(d, s, func() error { + vv = ImageDetail{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeImageFailureList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]ImageFailure) error { + *v = make([]ImageFailure, 0) + var vv ImageFailure + return smithy.ReadList(d, s, func() error { + vv = ImageFailure{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeImageIdentifierList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]ImageIdentifier) error { + *v = make([]ImageIdentifier, 0) + var vv ImageIdentifier + return smithy.ReadList(d, s, func() error { + vv = ImageIdentifier{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeImageTagDetailList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]ImageTagDetail) error { + *v = make([]ImageTagDetail, 0) + var vv ImageTagDetail + return smithy.ReadList(d, s, func() error { + vv = ImageTagDetail{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeImageTagList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]string) error { + *v = make([]string, 0) + var vv string + return smithy.ReadList(d, s, func() error { + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeLayerDigestList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]string) error { + *v = make([]string, 0) + var vv string + return smithy.ReadList(d, s, func() error { + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeLayerFailureList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]LayerFailure) error { + *v = make([]LayerFailure, 0) + var vv LayerFailure + return smithy.ReadList(d, s, func() error { + vv = LayerFailure{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeLayerList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]Layer) error { + *v = make([]Layer, 0) + var vv Layer + return smithy.ReadList(d, s, func() error { + vv = Layer{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeOperatingSystemList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]string) error { + *v = make([]string, 0) + var vv string + return smithy.ReadList(d, s, func() error { + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeRegistryAliasList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]RegistryAlias) error { + *v = make([]RegistryAlias, 0) + var vv RegistryAlias + return smithy.ReadList(d, s, func() error { + vv = RegistryAlias{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeRegistryList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]Registry) error { + *v = make([]Registry, 0) + var vv Registry + return smithy.ReadList(d, s, func() error { + vv = Registry{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeRepositoryList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]Repository) error { + *v = make([]Repository, 0) + var vv Repository + return smithy.ReadList(d, s, func() error { + vv = Repository{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeRepositoryNameList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]string) error { + *v = make([]string, 0) + var vv string + return smithy.ReadList(d, s, func() error { + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeTagKeyList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]string) error { + *v = make([]string, 0) + var vv string + return smithy.ReadList(d, s, func() error { + + if err := d.ReadString(s.ListMember(), &vv); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} + +func deserializeTagList(d smithy.ShapeDeserializer, s *smithy.Schema, v *[]Tag) error { + *v = make([]Tag, 0) + var vv Tag + return smithy.ReadList(d, s, func() error { + vv = Tag{} + if err := vv.Deserialize(d); err != nil { + return err + } + + *v = append(*v, vv) + return nil + }) +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/types/enums.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/types/enums.go new file mode 100644 index 0000000..bc9ab65 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/types/enums.go @@ -0,0 +1,91 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package types + +type ImageFailureCode string + +// Enum values for ImageFailureCode +const ( + ImageFailureCodeInvalidImageDigest ImageFailureCode = "InvalidImageDigest" + ImageFailureCodeInvalidImageTag ImageFailureCode = "InvalidImageTag" + ImageFailureCodeImageTagDoesNotMatchDigest ImageFailureCode = "ImageTagDoesNotMatchDigest" + ImageFailureCodeImageNotFound ImageFailureCode = "ImageNotFound" + ImageFailureCodeMissingDigestAndTag ImageFailureCode = "MissingDigestAndTag" + ImageFailureCodeImageReferencedByManifestList ImageFailureCode = "ImageReferencedByManifestList" + ImageFailureCodeKmsError ImageFailureCode = "KmsError" +) + +// Values returns all known values for ImageFailureCode. Note that this can be +// expanded in the future, and so it is only as up to date as the client. +// +// The ordering of this slice is not guaranteed to be stable across updates. +func (ImageFailureCode) Values() []ImageFailureCode { + return []ImageFailureCode{ + "InvalidImageDigest", + "InvalidImageTag", + "ImageTagDoesNotMatchDigest", + "ImageNotFound", + "MissingDigestAndTag", + "ImageReferencedByManifestList", + "KmsError", + } +} + +type LayerAvailability string + +// Enum values for LayerAvailability +const ( + LayerAvailabilityAvailable LayerAvailability = "AVAILABLE" + LayerAvailabilityUnavailable LayerAvailability = "UNAVAILABLE" +) + +// Values returns all known values for LayerAvailability. Note that this can be +// expanded in the future, and so it is only as up to date as the client. +// +// The ordering of this slice is not guaranteed to be stable across updates. +func (LayerAvailability) Values() []LayerAvailability { + return []LayerAvailability{ + "AVAILABLE", + "UNAVAILABLE", + } +} + +type LayerFailureCode string + +// Enum values for LayerFailureCode +const ( + LayerFailureCodeInvalidLayerDigest LayerFailureCode = "InvalidLayerDigest" + LayerFailureCodeMissingLayerDigest LayerFailureCode = "MissingLayerDigest" +) + +// Values returns all known values for LayerFailureCode. Note that this can be +// expanded in the future, and so it is only as up to date as the client. +// +// The ordering of this slice is not guaranteed to be stable across updates. +func (LayerFailureCode) Values() []LayerFailureCode { + return []LayerFailureCode{ + "InvalidLayerDigest", + "MissingLayerDigest", + } +} + +type RegistryAliasStatus string + +// Enum values for RegistryAliasStatus +const ( + RegistryAliasStatusActive RegistryAliasStatus = "ACTIVE" + RegistryAliasStatusPending RegistryAliasStatus = "PENDING" + RegistryAliasStatusRejected RegistryAliasStatus = "REJECTED" +) + +// Values returns all known values for RegistryAliasStatus. Note that this can be +// expanded in the future, and so it is only as up to date as the client. +// +// The ordering of this slice is not guaranteed to be stable across updates. +func (RegistryAliasStatus) Values() []RegistryAliasStatus { + return []RegistryAliasStatus{ + "ACTIVE", + "PENDING", + "REJECTED", + } +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/types/errors.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/types/errors.go new file mode 100644 index 0000000..2da16ee --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/types/errors.go @@ -0,0 +1,1186 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package types + +import ( + "fmt" + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas" + smithy "github.com/aws/smithy-go" +) + +// The specified layer upload doesn't contain any layer parts. +type EmptyUploadException struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *EmptyUploadException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *EmptyUploadException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *EmptyUploadException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "EmptyUploadException" + } + return *e.ErrorCodeOverride +} +func (e *EmptyUploadException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *EmptyUploadException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.EmptyUploadException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *EmptyUploadException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.EmptyUploadException_message, *v.Message) + } +} +func (v *EmptyUploadException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.EmptyUploadException, func(s *smithy.Schema) error { + switch s { + case schemas.EmptyUploadException_message: + v.Message = new(string) + return d.ReadString(schemas.EmptyUploadException_message, v.Message) + } + return nil + }) +} + +// The specified image has already been pushed, and there were no changes to the +// manifest or image tag after the last push. +type ImageAlreadyExistsException struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *ImageAlreadyExistsException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *ImageAlreadyExistsException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *ImageAlreadyExistsException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "ImageAlreadyExistsException" + } + return *e.ErrorCodeOverride +} +func (e *ImageAlreadyExistsException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *ImageAlreadyExistsException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ImageAlreadyExistsException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ImageAlreadyExistsException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.ImageAlreadyExistsException_message, *v.Message) + } +} +func (v *ImageAlreadyExistsException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ImageAlreadyExistsException, func(s *smithy.Schema) error { + switch s { + case schemas.ImageAlreadyExistsException_message: + v.Message = new(string) + return d.ReadString(schemas.ImageAlreadyExistsException_message, v.Message) + } + return nil + }) +} + +// The specified image digest doesn't match the digest that Amazon ECR calculated +// for the image. +type ImageDigestDoesNotMatchException struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *ImageDigestDoesNotMatchException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *ImageDigestDoesNotMatchException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *ImageDigestDoesNotMatchException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "ImageDigestDoesNotMatchException" + } + return *e.ErrorCodeOverride +} +func (e *ImageDigestDoesNotMatchException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *ImageDigestDoesNotMatchException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ImageDigestDoesNotMatchException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ImageDigestDoesNotMatchException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.ImageDigestDoesNotMatchException_message, *v.Message) + } +} +func (v *ImageDigestDoesNotMatchException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ImageDigestDoesNotMatchException, func(s *smithy.Schema) error { + switch s { + case schemas.ImageDigestDoesNotMatchException_message: + v.Message = new(string) + return d.ReadString(schemas.ImageDigestDoesNotMatchException_message, v.Message) + } + return nil + }) +} + +// The image requested doesn't exist in the specified repository. +type ImageNotFoundException struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *ImageNotFoundException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *ImageNotFoundException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *ImageNotFoundException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "ImageNotFoundException" + } + return *e.ErrorCodeOverride +} +func (e *ImageNotFoundException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *ImageNotFoundException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ImageNotFoundException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ImageNotFoundException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.ImageNotFoundException_message, *v.Message) + } +} +func (v *ImageNotFoundException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ImageNotFoundException, func(s *smithy.Schema) error { + switch s { + case schemas.ImageNotFoundException_message: + v.Message = new(string) + return d.ReadString(schemas.ImageNotFoundException_message, v.Message) + } + return nil + }) +} + +// The specified image is tagged with a tag that already exists. The repository is +// configured for tag immutability. +type ImageTagAlreadyExistsException struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *ImageTagAlreadyExistsException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *ImageTagAlreadyExistsException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *ImageTagAlreadyExistsException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "ImageTagAlreadyExistsException" + } + return *e.ErrorCodeOverride +} +func (e *ImageTagAlreadyExistsException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *ImageTagAlreadyExistsException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ImageTagAlreadyExistsException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ImageTagAlreadyExistsException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.ImageTagAlreadyExistsException_message, *v.Message) + } +} +func (v *ImageTagAlreadyExistsException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ImageTagAlreadyExistsException, func(s *smithy.Schema) error { + switch s { + case schemas.ImageTagAlreadyExistsException_message: + v.Message = new(string) + return d.ReadString(schemas.ImageTagAlreadyExistsException_message, v.Message) + } + return nil + }) +} + +// The layer digest calculation performed by Amazon ECR when the image layer +// doesn't match the digest specified. +type InvalidLayerException struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *InvalidLayerException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *InvalidLayerException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *InvalidLayerException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "InvalidLayerException" + } + return *e.ErrorCodeOverride +} +func (e *InvalidLayerException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *InvalidLayerException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.InvalidLayerException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *InvalidLayerException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.InvalidLayerException_message, *v.Message) + } +} +func (v *InvalidLayerException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.InvalidLayerException, func(s *smithy.Schema) error { + switch s { + case schemas.InvalidLayerException_message: + v.Message = new(string) + return d.ReadString(schemas.InvalidLayerException_message, v.Message) + } + return nil + }) +} + +// The layer part size isn't valid, or the first byte specified isn't consecutive +// to the last byte of a previous layer part upload. +type InvalidLayerPartException struct { + Message *string + + ErrorCodeOverride *string + + RegistryId *string + RepositoryName *string + UploadId *string + LastValidByteReceived *int64 + + noSmithyDocumentSerde +} + +func (e *InvalidLayerPartException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *InvalidLayerPartException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *InvalidLayerPartException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "InvalidLayerPartException" + } + return *e.ErrorCodeOverride +} +func (e *InvalidLayerPartException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *InvalidLayerPartException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.InvalidLayerPartException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *InvalidLayerPartException) SerializeMembers(s smithy.ShapeSerializer) { + if v.LastValidByteReceived != nil { + s.WriteInt64(schemas.InvalidLayerPartException_lastValidByteReceived, *v.LastValidByteReceived) + } + if v.Message != nil { + s.WriteString(schemas.InvalidLayerPartException_message, *v.Message) + } + if v.RegistryId != nil { + s.WriteString(schemas.InvalidLayerPartException_registryId, *v.RegistryId) + } + if v.RepositoryName != nil { + s.WriteString(schemas.InvalidLayerPartException_repositoryName, *v.RepositoryName) + } + if v.UploadId != nil { + s.WriteString(schemas.InvalidLayerPartException_uploadId, *v.UploadId) + } +} +func (v *InvalidLayerPartException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.InvalidLayerPartException, func(s *smithy.Schema) error { + switch s { + case schemas.InvalidLayerPartException_lastValidByteReceived: + v.LastValidByteReceived = new(int64) + return d.ReadInt64(schemas.InvalidLayerPartException_lastValidByteReceived, v.LastValidByteReceived) + case schemas.InvalidLayerPartException_message: + v.Message = new(string) + return d.ReadString(schemas.InvalidLayerPartException_message, v.Message) + case schemas.InvalidLayerPartException_registryId: + v.RegistryId = new(string) + return d.ReadString(schemas.InvalidLayerPartException_registryId, v.RegistryId) + case schemas.InvalidLayerPartException_repositoryName: + v.RepositoryName = new(string) + return d.ReadString(schemas.InvalidLayerPartException_repositoryName, v.RepositoryName) + case schemas.InvalidLayerPartException_uploadId: + v.UploadId = new(string) + return d.ReadString(schemas.InvalidLayerPartException_uploadId, v.UploadId) + } + return nil + }) +} + +// The specified parameter is invalid. Review the available parameters for the API +// request. +type InvalidParameterException struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *InvalidParameterException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *InvalidParameterException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *InvalidParameterException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "InvalidParameterException" + } + return *e.ErrorCodeOverride +} +func (e *InvalidParameterException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *InvalidParameterException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.InvalidParameterException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *InvalidParameterException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.InvalidParameterException_message, *v.Message) + } +} +func (v *InvalidParameterException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.InvalidParameterException, func(s *smithy.Schema) error { + switch s { + case schemas.InvalidParameterException_message: + v.Message = new(string) + return d.ReadString(schemas.InvalidParameterException_message, v.Message) + } + return nil + }) +} + +// An invalid parameter has been specified. Tag keys can have a maximum character +// length of 128 characters, and tag values can have a maximum length of 256 +// characters. +type InvalidTagParameterException struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *InvalidTagParameterException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *InvalidTagParameterException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *InvalidTagParameterException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "InvalidTagParameterException" + } + return *e.ErrorCodeOverride +} +func (e *InvalidTagParameterException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *InvalidTagParameterException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.InvalidTagParameterException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *InvalidTagParameterException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.InvalidTagParameterException_message, *v.Message) + } +} +func (v *InvalidTagParameterException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.InvalidTagParameterException, func(s *smithy.Schema) error { + switch s { + case schemas.InvalidTagParameterException_message: + v.Message = new(string) + return d.ReadString(schemas.InvalidTagParameterException_message, v.Message) + } + return nil + }) +} + +// The image layer already exists in the associated repository. +type LayerAlreadyExistsException struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *LayerAlreadyExistsException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *LayerAlreadyExistsException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *LayerAlreadyExistsException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "LayerAlreadyExistsException" + } + return *e.ErrorCodeOverride +} +func (e *LayerAlreadyExistsException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *LayerAlreadyExistsException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.LayerAlreadyExistsException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *LayerAlreadyExistsException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.LayerAlreadyExistsException_message, *v.Message) + } +} +func (v *LayerAlreadyExistsException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.LayerAlreadyExistsException, func(s *smithy.Schema) error { + switch s { + case schemas.LayerAlreadyExistsException_message: + v.Message = new(string) + return d.ReadString(schemas.LayerAlreadyExistsException_message, v.Message) + } + return nil + }) +} + +// Layer parts must be at least 5 MiB in size. +type LayerPartTooSmallException struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *LayerPartTooSmallException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *LayerPartTooSmallException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *LayerPartTooSmallException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "LayerPartTooSmallException" + } + return *e.ErrorCodeOverride +} +func (e *LayerPartTooSmallException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *LayerPartTooSmallException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.LayerPartTooSmallException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *LayerPartTooSmallException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.LayerPartTooSmallException_message, *v.Message) + } +} +func (v *LayerPartTooSmallException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.LayerPartTooSmallException, func(s *smithy.Schema) error { + switch s { + case schemas.LayerPartTooSmallException_message: + v.Message = new(string) + return d.ReadString(schemas.LayerPartTooSmallException_message, v.Message) + } + return nil + }) +} + +// The specified layers can't be found, or the specified layer isn't valid for +// this repository. +type LayersNotFoundException struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *LayersNotFoundException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *LayersNotFoundException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *LayersNotFoundException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "LayersNotFoundException" + } + return *e.ErrorCodeOverride +} +func (e *LayersNotFoundException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *LayersNotFoundException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.LayersNotFoundException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *LayersNotFoundException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.LayersNotFoundException_message, *v.Message) + } +} +func (v *LayersNotFoundException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.LayersNotFoundException, func(s *smithy.Schema) error { + switch s { + case schemas.LayersNotFoundException_message: + v.Message = new(string) + return d.ReadString(schemas.LayersNotFoundException_message, v.Message) + } + return nil + }) +} + +// The operation didn't succeed because it would have exceeded a service limit for +// your account. For more information, see [Amazon ECR Service Quotas]in the Amazon Elastic Container +// Registry User Guide. +// +// [Amazon ECR Service Quotas]: https://docs.aws.amazon.com/AmazonECR/latest/userguide/service-quotas.html +type LimitExceededException struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *LimitExceededException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *LimitExceededException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *LimitExceededException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "LimitExceededException" + } + return *e.ErrorCodeOverride +} +func (e *LimitExceededException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *LimitExceededException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.LimitExceededException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *LimitExceededException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.LimitExceededException_message, *v.Message) + } +} +func (v *LimitExceededException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.LimitExceededException, func(s *smithy.Schema) error { + switch s { + case schemas.LimitExceededException_message: + v.Message = new(string) + return d.ReadString(schemas.LimitExceededException_message, v.Message) + } + return nil + }) +} + +// The manifest list is referencing an image that doesn't exist. +type ReferencedImagesNotFoundException struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *ReferencedImagesNotFoundException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *ReferencedImagesNotFoundException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *ReferencedImagesNotFoundException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "ReferencedImagesNotFoundException" + } + return *e.ErrorCodeOverride +} +func (e *ReferencedImagesNotFoundException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *ReferencedImagesNotFoundException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ReferencedImagesNotFoundException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ReferencedImagesNotFoundException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.ReferencedImagesNotFoundException_message, *v.Message) + } +} +func (v *ReferencedImagesNotFoundException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ReferencedImagesNotFoundException, func(s *smithy.Schema) error { + switch s { + case schemas.ReferencedImagesNotFoundException_message: + v.Message = new(string) + return d.ReadString(schemas.ReferencedImagesNotFoundException_message, v.Message) + } + return nil + }) +} + +// The registry doesn't exist. +type RegistryNotFoundException struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *RegistryNotFoundException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *RegistryNotFoundException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *RegistryNotFoundException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "RegistryNotFoundException" + } + return *e.ErrorCodeOverride +} +func (e *RegistryNotFoundException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *RegistryNotFoundException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.RegistryNotFoundException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *RegistryNotFoundException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.RegistryNotFoundException_message, *v.Message) + } +} +func (v *RegistryNotFoundException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.RegistryNotFoundException, func(s *smithy.Schema) error { + switch s { + case schemas.RegistryNotFoundException_message: + v.Message = new(string) + return d.ReadString(schemas.RegistryNotFoundException_message, v.Message) + } + return nil + }) +} + +// The specified repository already exists in the specified registry. +type RepositoryAlreadyExistsException struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *RepositoryAlreadyExistsException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *RepositoryAlreadyExistsException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *RepositoryAlreadyExistsException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "RepositoryAlreadyExistsException" + } + return *e.ErrorCodeOverride +} +func (e *RepositoryAlreadyExistsException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *RepositoryAlreadyExistsException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.RepositoryAlreadyExistsException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *RepositoryAlreadyExistsException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.RepositoryAlreadyExistsException_message, *v.Message) + } +} +func (v *RepositoryAlreadyExistsException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.RepositoryAlreadyExistsException, func(s *smithy.Schema) error { + switch s { + case schemas.RepositoryAlreadyExistsException_message: + v.Message = new(string) + return d.ReadString(schemas.RepositoryAlreadyExistsException_message, v.Message) + } + return nil + }) +} + +// The repository catalog data doesn't exist. +type RepositoryCatalogDataNotFoundException struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *RepositoryCatalogDataNotFoundException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *RepositoryCatalogDataNotFoundException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *RepositoryCatalogDataNotFoundException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "RepositoryCatalogDataNotFoundException" + } + return *e.ErrorCodeOverride +} +func (e *RepositoryCatalogDataNotFoundException) ErrorFault() smithy.ErrorFault { + return smithy.FaultClient +} +func (v *RepositoryCatalogDataNotFoundException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.RepositoryCatalogDataNotFoundException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *RepositoryCatalogDataNotFoundException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.RepositoryCatalogDataNotFoundException_message, *v.Message) + } +} +func (v *RepositoryCatalogDataNotFoundException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.RepositoryCatalogDataNotFoundException, func(s *smithy.Schema) error { + switch s { + case schemas.RepositoryCatalogDataNotFoundException_message: + v.Message = new(string) + return d.ReadString(schemas.RepositoryCatalogDataNotFoundException_message, v.Message) + } + return nil + }) +} + +// The specified repository contains images. To delete a repository that contains +// images, you must force the deletion with the force parameter. +type RepositoryNotEmptyException struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *RepositoryNotEmptyException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *RepositoryNotEmptyException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *RepositoryNotEmptyException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "RepositoryNotEmptyException" + } + return *e.ErrorCodeOverride +} +func (e *RepositoryNotEmptyException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *RepositoryNotEmptyException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.RepositoryNotEmptyException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *RepositoryNotEmptyException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.RepositoryNotEmptyException_message, *v.Message) + } +} +func (v *RepositoryNotEmptyException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.RepositoryNotEmptyException, func(s *smithy.Schema) error { + switch s { + case schemas.RepositoryNotEmptyException_message: + v.Message = new(string) + return d.ReadString(schemas.RepositoryNotEmptyException_message, v.Message) + } + return nil + }) +} + +// The specified repository can't be found. Check the spelling of the specified +// repository and ensure that you're performing operations on the correct registry. +type RepositoryNotFoundException struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *RepositoryNotFoundException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *RepositoryNotFoundException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *RepositoryNotFoundException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "RepositoryNotFoundException" + } + return *e.ErrorCodeOverride +} +func (e *RepositoryNotFoundException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *RepositoryNotFoundException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.RepositoryNotFoundException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *RepositoryNotFoundException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.RepositoryNotFoundException_message, *v.Message) + } +} +func (v *RepositoryNotFoundException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.RepositoryNotFoundException, func(s *smithy.Schema) error { + switch s { + case schemas.RepositoryNotFoundException_message: + v.Message = new(string) + return d.ReadString(schemas.RepositoryNotFoundException_message, v.Message) + } + return nil + }) +} + +// The specified repository and registry combination doesn't have an associated +// repository policy. +type RepositoryPolicyNotFoundException struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *RepositoryPolicyNotFoundException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *RepositoryPolicyNotFoundException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *RepositoryPolicyNotFoundException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "RepositoryPolicyNotFoundException" + } + return *e.ErrorCodeOverride +} +func (e *RepositoryPolicyNotFoundException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *RepositoryPolicyNotFoundException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.RepositoryPolicyNotFoundException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *RepositoryPolicyNotFoundException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.RepositoryPolicyNotFoundException_message, *v.Message) + } +} +func (v *RepositoryPolicyNotFoundException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.RepositoryPolicyNotFoundException, func(s *smithy.Schema) error { + switch s { + case schemas.RepositoryPolicyNotFoundException_message: + v.Message = new(string) + return d.ReadString(schemas.RepositoryPolicyNotFoundException_message, v.Message) + } + return nil + }) +} + +// These errors are usually caused by a server-side issue. +type ServerException struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *ServerException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *ServerException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *ServerException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "ServerException" + } + return *e.ErrorCodeOverride +} +func (e *ServerException) ErrorFault() smithy.ErrorFault { return smithy.FaultServer } +func (v *ServerException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ServerException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ServerException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.ServerException_message, *v.Message) + } +} +func (v *ServerException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ServerException, func(s *smithy.Schema) error { + switch s { + case schemas.ServerException_message: + v.Message = new(string) + return d.ReadString(schemas.ServerException_message, v.Message) + } + return nil + }) +} + +// The list of tags on the repository is over the limit. The maximum number of +// tags that can be applied to a repository is 50. +type TooManyTagsException struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *TooManyTagsException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *TooManyTagsException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *TooManyTagsException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "TooManyTagsException" + } + return *e.ErrorCodeOverride +} +func (e *TooManyTagsException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *TooManyTagsException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.TooManyTagsException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *TooManyTagsException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.TooManyTagsException_message, *v.Message) + } +} +func (v *TooManyTagsException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.TooManyTagsException, func(s *smithy.Schema) error { + switch s { + case schemas.TooManyTagsException_message: + v.Message = new(string) + return d.ReadString(schemas.TooManyTagsException_message, v.Message) + } + return nil + }) +} + +// The action isn't supported in this Region. +type UnsupportedCommandException struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *UnsupportedCommandException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *UnsupportedCommandException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *UnsupportedCommandException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "UnsupportedCommandException" + } + return *e.ErrorCodeOverride +} +func (e *UnsupportedCommandException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *UnsupportedCommandException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.UnsupportedCommandException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *UnsupportedCommandException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.UnsupportedCommandException_message, *v.Message) + } +} +func (v *UnsupportedCommandException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.UnsupportedCommandException, func(s *smithy.Schema) error { + switch s { + case schemas.UnsupportedCommandException_message: + v.Message = new(string) + return d.ReadString(schemas.UnsupportedCommandException_message, v.Message) + } + return nil + }) +} + +// The upload can't be found, or the specified upload ID isn't valid for this +// repository. +type UploadNotFoundException struct { + Message *string + + ErrorCodeOverride *string + + noSmithyDocumentSerde +} + +func (e *UploadNotFoundException) Error() string { + return fmt.Sprintf("%s: %s", e.ErrorCode(), e.ErrorMessage()) +} +func (e *UploadNotFoundException) ErrorMessage() string { + if e.Message == nil { + return "" + } + return *e.Message +} +func (e *UploadNotFoundException) ErrorCode() string { + if e == nil || e.ErrorCodeOverride == nil { + return "UploadNotFoundException" + } + return *e.ErrorCodeOverride +} +func (e *UploadNotFoundException) ErrorFault() smithy.ErrorFault { return smithy.FaultClient } +func (v *UploadNotFoundException) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.UploadNotFoundException) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *UploadNotFoundException) SerializeMembers(s smithy.ShapeSerializer) { + if v.Message != nil { + s.WriteString(schemas.UploadNotFoundException_message, *v.Message) + } +} +func (v *UploadNotFoundException) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.UploadNotFoundException, func(s *smithy.Schema) error { + switch s { + case schemas.UploadNotFoundException_message: + v.Message = new(string) + return d.ReadString(schemas.UploadNotFoundException_message, v.Message) + } + return nil + }) +} diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/types/types.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/types/types.go new file mode 100644 index 0000000..d41b897 --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/types/types.go @@ -0,0 +1,1064 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package types + +import ( + "github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas" + smithy "github.com/aws/smithy-go" + smithydocument "github.com/aws/smithy-go/document" + "time" +) + +// An authorization token data object that corresponds to a public registry. +type AuthorizationData struct { + + // A base64-encoded string that contains authorization data for a public Amazon + // ECR registry. When the string is decoded, it's presented in the format + // user:password for public registry authentication using docker login . + AuthorizationToken *string + + // The Unix time in seconds and milliseconds when the authorization token expires. + // Authorization tokens are valid for 12 hours. + ExpiresAt *time.Time + + noSmithyDocumentSerde +} + +func (v *AuthorizationData) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.AuthorizationData) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *AuthorizationData) SerializeMembers(s smithy.ShapeSerializer) { + if v.AuthorizationToken != nil { + s.WriteString(schemas.AuthorizationData_authorizationToken, *v.AuthorizationToken) + } + if v.ExpiresAt != nil { + s.WriteTime(schemas.AuthorizationData_expiresAt, *v.ExpiresAt) + } +} +func (v *AuthorizationData) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.AuthorizationData, func(s *smithy.Schema) error { + switch s { + case schemas.AuthorizationData_authorizationToken: + v.AuthorizationToken = new(string) + return d.ReadString(schemas.AuthorizationData_authorizationToken, v.AuthorizationToken) + case schemas.AuthorizationData_expiresAt: + v.ExpiresAt = new(time.Time) + return d.ReadTime(schemas.AuthorizationData_expiresAt, v.ExpiresAt) + } + return nil + }) +} + +// An object that represents an Amazon ECR image. +type Image struct { + + // An object that contains the image tag and image digest associated with an image. + ImageId *ImageIdentifier + + // The image manifest that's associated with the image. + ImageManifest *string + + // The manifest media type of the image. + ImageManifestMediaType *string + + // The Amazon Web Services account ID that's associated with the registry + // containing the image. + RegistryId *string + + // The name of the repository that's associated with the image. + RepositoryName *string + + noSmithyDocumentSerde +} + +func (v *Image) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.Image) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *Image) SerializeMembers(s smithy.ShapeSerializer) { + if v.ImageId != nil { + s.WriteStruct(schemas.Image_imageId) + v.ImageId.SerializeMembers(s) + s.CloseStruct() + } + if v.ImageManifest != nil { + s.WriteString(schemas.Image_imageManifest, *v.ImageManifest) + } + if v.ImageManifestMediaType != nil { + s.WriteString(schemas.Image_imageManifestMediaType, *v.ImageManifestMediaType) + } + if v.RegistryId != nil { + s.WriteString(schemas.Image_registryId, *v.RegistryId) + } + if v.RepositoryName != nil { + s.WriteString(schemas.Image_repositoryName, *v.RepositoryName) + } +} +func (v *Image) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.Image, func(s *smithy.Schema) error { + switch s { + case schemas.Image_imageId: + v.ImageId = &ImageIdentifier{} + return v.ImageId.Deserialize(d) + case schemas.Image_imageManifest: + v.ImageManifest = new(string) + return d.ReadString(schemas.Image_imageManifest, v.ImageManifest) + case schemas.Image_imageManifestMediaType: + v.ImageManifestMediaType = new(string) + return d.ReadString(schemas.Image_imageManifestMediaType, v.ImageManifestMediaType) + case schemas.Image_registryId: + v.RegistryId = new(string) + return d.ReadString(schemas.Image_registryId, v.RegistryId) + case schemas.Image_repositoryName: + v.RepositoryName = new(string) + return d.ReadString(schemas.Image_repositoryName, v.RepositoryName) + } + return nil + }) +} + +// An object that describes an image that's returned by a DescribeImages operation. +type ImageDetail struct { + + // The artifact media type of the image. + ArtifactMediaType *string + + // The sha256 digest of the image manifest. + ImageDigest *string + + // The media type of the image manifest. + ImageManifestMediaType *string + + // The date and time, expressed in standard JavaScript date format, that the + // current image was pushed to the repository at. + ImagePushedAt *time.Time + + // The size, in bytes, of the image in the repository. + // + // If the image is a manifest list, this is the max size of all manifests in the + // list. + // + // Beginning with Docker version 1.9, the Docker client compresses image layers + // before pushing them to a V2 Docker registry. The output of the docker images + // command shows the uncompressed image size, so it might return a larger image + // size than the image sizes that are returned by DescribeImages. + ImageSizeInBytes *int64 + + // The list of tags that's associated with this image. + ImageTags []string + + // The Amazon Web Services account ID that's associated with the public registry + // where this image belongs. + RegistryId *string + + // The name of the repository where this image belongs. + RepositoryName *string + + noSmithyDocumentSerde +} + +func (v *ImageDetail) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ImageDetail) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ImageDetail) SerializeMembers(s smithy.ShapeSerializer) { + if v.ArtifactMediaType != nil { + s.WriteString(schemas.ImageDetail_artifactMediaType, *v.ArtifactMediaType) + } + if v.ImageDigest != nil { + s.WriteString(schemas.ImageDetail_imageDigest, *v.ImageDigest) + } + if v.ImageManifestMediaType != nil { + s.WriteString(schemas.ImageDetail_imageManifestMediaType, *v.ImageManifestMediaType) + } + if v.ImagePushedAt != nil { + s.WriteTime(schemas.ImageDetail_imagePushedAt, *v.ImagePushedAt) + } + if v.ImageSizeInBytes != nil { + s.WriteInt64(schemas.ImageDetail_imageSizeInBytes, *v.ImageSizeInBytes) + } + serializeImageTagList(s, schemas.ImageDetail_imageTags, v.ImageTags) + if v.RegistryId != nil { + s.WriteString(schemas.ImageDetail_registryId, *v.RegistryId) + } + if v.RepositoryName != nil { + s.WriteString(schemas.ImageDetail_repositoryName, *v.RepositoryName) + } +} +func (v *ImageDetail) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ImageDetail, func(s *smithy.Schema) error { + switch s { + case schemas.ImageDetail_artifactMediaType: + v.ArtifactMediaType = new(string) + return d.ReadString(schemas.ImageDetail_artifactMediaType, v.ArtifactMediaType) + case schemas.ImageDetail_imageDigest: + v.ImageDigest = new(string) + return d.ReadString(schemas.ImageDetail_imageDigest, v.ImageDigest) + case schemas.ImageDetail_imageManifestMediaType: + v.ImageManifestMediaType = new(string) + return d.ReadString(schemas.ImageDetail_imageManifestMediaType, v.ImageManifestMediaType) + case schemas.ImageDetail_imagePushedAt: + v.ImagePushedAt = new(time.Time) + return d.ReadTime(schemas.ImageDetail_imagePushedAt, v.ImagePushedAt) + case schemas.ImageDetail_imageSizeInBytes: + v.ImageSizeInBytes = new(int64) + return d.ReadInt64(schemas.ImageDetail_imageSizeInBytes, v.ImageSizeInBytes) + case schemas.ImageDetail_imageTags: + return deserializeImageTagList(d, schemas.ImageDetail_imageTags, &v.ImageTags) + case schemas.ImageDetail_registryId: + v.RegistryId = new(string) + return d.ReadString(schemas.ImageDetail_registryId, v.RegistryId) + case schemas.ImageDetail_repositoryName: + v.RepositoryName = new(string) + return d.ReadString(schemas.ImageDetail_repositoryName, v.RepositoryName) + } + return nil + }) +} + +// An object that represents an Amazon ECR image failure. +type ImageFailure struct { + + // The code that's associated with the failure. + FailureCode ImageFailureCode + + // The reason for the failure. + FailureReason *string + + // The image ID that's associated with the failure. + ImageId *ImageIdentifier + + noSmithyDocumentSerde +} + +func (v *ImageFailure) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ImageFailure) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ImageFailure) SerializeMembers(s smithy.ShapeSerializer) { + if v.FailureCode != "" { + s.WriteString(schemas.ImageFailure_failureCode, string(v.FailureCode)) + } + if v.FailureReason != nil { + s.WriteString(schemas.ImageFailure_failureReason, *v.FailureReason) + } + if v.ImageId != nil { + s.WriteStruct(schemas.ImageFailure_imageId) + v.ImageId.SerializeMembers(s) + s.CloseStruct() + } +} +func (v *ImageFailure) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ImageFailure, func(s *smithy.Schema) error { + switch s { + case schemas.ImageFailure_failureCode: + var ev string + if err := d.ReadString(schemas.ImageFailure_failureCode, &ev); err != nil { + return err + } + v.FailureCode = ImageFailureCode(ev) + return nil + case schemas.ImageFailure_failureReason: + v.FailureReason = new(string) + return d.ReadString(schemas.ImageFailure_failureReason, v.FailureReason) + case schemas.ImageFailure_imageId: + v.ImageId = &ImageIdentifier{} + return v.ImageId.Deserialize(d) + } + return nil + }) +} + +// An object with identifying information for an Amazon ECR image. +type ImageIdentifier struct { + + // The sha256 digest of the image manifest. + ImageDigest *string + + // The tag that's used for the image. + ImageTag *string + + noSmithyDocumentSerde +} + +func (v *ImageIdentifier) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ImageIdentifier) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ImageIdentifier) SerializeMembers(s smithy.ShapeSerializer) { + if v.ImageDigest != nil { + s.WriteString(schemas.ImageIdentifier_imageDigest, *v.ImageDigest) + } + if v.ImageTag != nil { + s.WriteString(schemas.ImageIdentifier_imageTag, *v.ImageTag) + } +} +func (v *ImageIdentifier) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ImageIdentifier, func(s *smithy.Schema) error { + switch s { + case schemas.ImageIdentifier_imageDigest: + v.ImageDigest = new(string) + return d.ReadString(schemas.ImageIdentifier_imageDigest, v.ImageDigest) + case schemas.ImageIdentifier_imageTag: + v.ImageTag = new(string) + return d.ReadString(schemas.ImageIdentifier_imageTag, v.ImageTag) + } + return nil + }) +} + +// An object that represents the image tag details for an image. +type ImageTagDetail struct { + + // The time stamp that indicates when the image tag was created. + CreatedAt *time.Time + + // An object that describes the details of an image. + ImageDetail *ReferencedImageDetail + + // The tag that's associated with the image. + ImageTag *string + + noSmithyDocumentSerde +} + +func (v *ImageTagDetail) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ImageTagDetail) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ImageTagDetail) SerializeMembers(s smithy.ShapeSerializer) { + if v.CreatedAt != nil { + s.WriteTime(schemas.ImageTagDetail_createdAt, *v.CreatedAt) + } + if v.ImageDetail != nil { + s.WriteStruct(schemas.ImageTagDetail_imageDetail) + v.ImageDetail.SerializeMembers(s) + s.CloseStruct() + } + if v.ImageTag != nil { + s.WriteString(schemas.ImageTagDetail_imageTag, *v.ImageTag) + } +} +func (v *ImageTagDetail) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ImageTagDetail, func(s *smithy.Schema) error { + switch s { + case schemas.ImageTagDetail_createdAt: + v.CreatedAt = new(time.Time) + return d.ReadTime(schemas.ImageTagDetail_createdAt, v.CreatedAt) + case schemas.ImageTagDetail_imageDetail: + v.ImageDetail = &ReferencedImageDetail{} + return v.ImageDetail.Deserialize(d) + case schemas.ImageTagDetail_imageTag: + v.ImageTag = new(string) + return d.ReadString(schemas.ImageTagDetail_imageTag, v.ImageTag) + } + return nil + }) +} + +// An object that represents an Amazon ECR image layer. +type Layer struct { + + // The availability status of the image layer. + LayerAvailability LayerAvailability + + // The sha256 digest of the image layer. + LayerDigest *string + + // The size, in bytes, of the image layer. + LayerSize *int64 + + // The media type of the layer, such as + // application/vnd.docker.image.rootfs.diff.tar.gzip or + // application/vnd.oci.image.layer.v1.tar+gzip . + MediaType *string + + noSmithyDocumentSerde +} + +func (v *Layer) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.Layer) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *Layer) SerializeMembers(s smithy.ShapeSerializer) { + if v.LayerAvailability != "" { + s.WriteString(schemas.Layer_layerAvailability, string(v.LayerAvailability)) + } + if v.LayerDigest != nil { + s.WriteString(schemas.Layer_layerDigest, *v.LayerDigest) + } + if v.LayerSize != nil { + s.WriteInt64(schemas.Layer_layerSize, *v.LayerSize) + } + if v.MediaType != nil { + s.WriteString(schemas.Layer_mediaType, *v.MediaType) + } +} +func (v *Layer) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.Layer, func(s *smithy.Schema) error { + switch s { + case schemas.Layer_layerAvailability: + var ev string + if err := d.ReadString(schemas.Layer_layerAvailability, &ev); err != nil { + return err + } + v.LayerAvailability = LayerAvailability(ev) + return nil + case schemas.Layer_layerDigest: + v.LayerDigest = new(string) + return d.ReadString(schemas.Layer_layerDigest, v.LayerDigest) + case schemas.Layer_layerSize: + v.LayerSize = new(int64) + return d.ReadInt64(schemas.Layer_layerSize, v.LayerSize) + case schemas.Layer_mediaType: + v.MediaType = new(string) + return d.ReadString(schemas.Layer_mediaType, v.MediaType) + } + return nil + }) +} + +// An object that represents an Amazon ECR image layer failure. +type LayerFailure struct { + + // The failure code that's associated with the failure. + FailureCode LayerFailureCode + + // The reason for the failure. + FailureReason *string + + // The layer digest that's associated with the failure. + LayerDigest *string + + noSmithyDocumentSerde +} + +func (v *LayerFailure) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.LayerFailure) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *LayerFailure) SerializeMembers(s smithy.ShapeSerializer) { + if v.FailureCode != "" { + s.WriteString(schemas.LayerFailure_failureCode, string(v.FailureCode)) + } + if v.FailureReason != nil { + s.WriteString(schemas.LayerFailure_failureReason, *v.FailureReason) + } + if v.LayerDigest != nil { + s.WriteString(schemas.LayerFailure_layerDigest, *v.LayerDigest) + } +} +func (v *LayerFailure) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.LayerFailure, func(s *smithy.Schema) error { + switch s { + case schemas.LayerFailure_failureCode: + var ev string + if err := d.ReadString(schemas.LayerFailure_failureCode, &ev); err != nil { + return err + } + v.FailureCode = LayerFailureCode(ev) + return nil + case schemas.LayerFailure_failureReason: + v.FailureReason = new(string) + return d.ReadString(schemas.LayerFailure_failureReason, v.FailureReason) + case schemas.LayerFailure_layerDigest: + v.LayerDigest = new(string) + return d.ReadString(schemas.LayerFailure_layerDigest, v.LayerDigest) + } + return nil + }) +} + +// An object that describes the image tag details that are returned by a DescribeImageTags action. +type ReferencedImageDetail struct { + + // The artifact media type of the image. + ArtifactMediaType *string + + // The sha256 digest of the image manifest. + ImageDigest *string + + // The media type of the image manifest. + ImageManifestMediaType *string + + // The date and time, expressed in standard JavaScript date format, which the + // current image tag was pushed to the repository at. + ImagePushedAt *time.Time + + // The size, in bytes, of the image in the repository. + // + // If the image is a manifest list, this is the max size of all manifests in the + // list. + // + // Beginning with Docker version 1.9, the Docker client compresses image layers + // before pushing them to a V2 Docker registry. The output of the docker images + // command shows the uncompressed image size, so it might return a larger image + // size than the image sizes that are returned by DescribeImages. + ImageSizeInBytes *int64 + + noSmithyDocumentSerde +} + +func (v *ReferencedImageDetail) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.ReferencedImageDetail) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *ReferencedImageDetail) SerializeMembers(s smithy.ShapeSerializer) { + if v.ArtifactMediaType != nil { + s.WriteString(schemas.ReferencedImageDetail_artifactMediaType, *v.ArtifactMediaType) + } + if v.ImageDigest != nil { + s.WriteString(schemas.ReferencedImageDetail_imageDigest, *v.ImageDigest) + } + if v.ImageManifestMediaType != nil { + s.WriteString(schemas.ReferencedImageDetail_imageManifestMediaType, *v.ImageManifestMediaType) + } + if v.ImagePushedAt != nil { + s.WriteTime(schemas.ReferencedImageDetail_imagePushedAt, *v.ImagePushedAt) + } + if v.ImageSizeInBytes != nil { + s.WriteInt64(schemas.ReferencedImageDetail_imageSizeInBytes, *v.ImageSizeInBytes) + } +} +func (v *ReferencedImageDetail) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.ReferencedImageDetail, func(s *smithy.Schema) error { + switch s { + case schemas.ReferencedImageDetail_artifactMediaType: + v.ArtifactMediaType = new(string) + return d.ReadString(schemas.ReferencedImageDetail_artifactMediaType, v.ArtifactMediaType) + case schemas.ReferencedImageDetail_imageDigest: + v.ImageDigest = new(string) + return d.ReadString(schemas.ReferencedImageDetail_imageDigest, v.ImageDigest) + case schemas.ReferencedImageDetail_imageManifestMediaType: + v.ImageManifestMediaType = new(string) + return d.ReadString(schemas.ReferencedImageDetail_imageManifestMediaType, v.ImageManifestMediaType) + case schemas.ReferencedImageDetail_imagePushedAt: + v.ImagePushedAt = new(time.Time) + return d.ReadTime(schemas.ReferencedImageDetail_imagePushedAt, v.ImagePushedAt) + case schemas.ReferencedImageDetail_imageSizeInBytes: + v.ImageSizeInBytes = new(int64) + return d.ReadInt64(schemas.ReferencedImageDetail_imageSizeInBytes, v.ImageSizeInBytes) + } + return nil + }) +} + +// The details of a public registry. +type Registry struct { + + // An array of objects that represents the aliases for a public registry. + // + // This member is required. + Aliases []RegistryAlias + + // The Amazon Resource Name (ARN) of the public registry. + // + // This member is required. + RegistryArn *string + + // The Amazon Web Services account ID that's associated with the registry. If you + // do not specify a registry, the default public registry is assumed. + // + // This member is required. + RegistryId *string + + // The URI of a public registry. The URI contains a universal prefix and the + // registry alias. + // + // This member is required. + RegistryUri *string + + // Indicates whether the account is a verified Amazon Web Services Marketplace + // vendor. If an account is verified, each public repository receives a verified + // account badge on the Amazon ECR Public Gallery. + // + // This member is required. + Verified *bool + + noSmithyDocumentSerde +} + +func (v *Registry) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.Registry) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *Registry) SerializeMembers(s smithy.ShapeSerializer) { + serializeRegistryAliasList(s, schemas.Registry_aliases, v.Aliases) + if v.RegistryArn != nil { + s.WriteString(schemas.Registry_registryArn, *v.RegistryArn) + } + if v.RegistryId != nil { + s.WriteString(schemas.Registry_registryId, *v.RegistryId) + } + if v.RegistryUri != nil { + s.WriteString(schemas.Registry_registryUri, *v.RegistryUri) + } + if v.Verified != nil { + s.WriteBool(schemas.Registry_verified, *v.Verified) + } +} +func (v *Registry) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.Registry, func(s *smithy.Schema) error { + switch s { + case schemas.Registry_aliases: + return deserializeRegistryAliasList(d, schemas.Registry_aliases, &v.Aliases) + case schemas.Registry_registryArn: + v.RegistryArn = new(string) + return d.ReadString(schemas.Registry_registryArn, v.RegistryArn) + case schemas.Registry_registryId: + v.RegistryId = new(string) + return d.ReadString(schemas.Registry_registryId, v.RegistryId) + case schemas.Registry_registryUri: + v.RegistryUri = new(string) + return d.ReadString(schemas.Registry_registryUri, v.RegistryUri) + case schemas.Registry_verified: + v.Verified = new(bool) + return d.ReadBool(schemas.Registry_verified, v.Verified) + } + return nil + }) +} + +// An object representing the aliases for a public registry. A public registry is +// given an alias when it's created. However, a custom alias can be set using the +// Amazon ECR console. For more information, see [Registries]in the Amazon Elastic Container +// Registry User Guide. +// +// [Registries]: https://docs.aws.amazon.com/AmazonECR/latest/userguide/Registries.html +type RegistryAlias struct { + + // Indicates whether the registry alias is the default alias for the registry. + // When the first public repository is created, your public registry is assigned a + // default registry alias. + // + // This member is required. + DefaultRegistryAlias bool + + // The name of the registry alias. + // + // This member is required. + Name *string + + // Indicates whether the registry alias is the primary alias for the registry. If + // true, the alias is the primary registry alias and is displayed in both the + // repository URL and the image URI used in the docker pull commands on the Amazon + // ECR Public Gallery. + // + // A registry alias that isn't the primary registry alias can be used in the + // repository URI in a docker pull command. + // + // This member is required. + PrimaryRegistryAlias bool + + // The status of the registry alias. + // + // This member is required. + Status RegistryAliasStatus + + noSmithyDocumentSerde +} + +func (v *RegistryAlias) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.RegistryAlias) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *RegistryAlias) SerializeMembers(s smithy.ShapeSerializer) { + s.WriteBool(schemas.RegistryAlias_defaultRegistryAlias, v.DefaultRegistryAlias) + if v.Name != nil { + s.WriteString(schemas.RegistryAlias_name, *v.Name) + } + s.WriteBool(schemas.RegistryAlias_primaryRegistryAlias, v.PrimaryRegistryAlias) + if v.Status != "" { + s.WriteString(schemas.RegistryAlias_status, string(v.Status)) + } +} +func (v *RegistryAlias) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.RegistryAlias, func(s *smithy.Schema) error { + switch s { + case schemas.RegistryAlias_defaultRegistryAlias: + return d.ReadBool(schemas.RegistryAlias_defaultRegistryAlias, &v.DefaultRegistryAlias) + case schemas.RegistryAlias_name: + v.Name = new(string) + return d.ReadString(schemas.RegistryAlias_name, v.Name) + case schemas.RegistryAlias_primaryRegistryAlias: + return d.ReadBool(schemas.RegistryAlias_primaryRegistryAlias, &v.PrimaryRegistryAlias) + case schemas.RegistryAlias_status: + var ev string + if err := d.ReadString(schemas.RegistryAlias_status, &ev); err != nil { + return err + } + v.Status = RegistryAliasStatus(ev) + return nil + } + return nil + }) +} + +// The metadata for a public registry. +type RegistryCatalogData struct { + + // The display name for a public registry. This appears on the Amazon ECR Public + // Gallery. + // + // Only accounts that have the verified account badge can have a registry display + // name. + DisplayName *string + + noSmithyDocumentSerde +} + +func (v *RegistryCatalogData) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.RegistryCatalogData) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *RegistryCatalogData) SerializeMembers(s smithy.ShapeSerializer) { + if v.DisplayName != nil { + s.WriteString(schemas.RegistryCatalogData_displayName, *v.DisplayName) + } +} +func (v *RegistryCatalogData) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.RegistryCatalogData, func(s *smithy.Schema) error { + switch s { + case schemas.RegistryCatalogData_displayName: + v.DisplayName = new(string) + return d.ReadString(schemas.RegistryCatalogData_displayName, v.DisplayName) + } + return nil + }) +} + +// An object representing a repository. +type Repository struct { + + // The date and time, in JavaScript date format, when the repository was created. + CreatedAt *time.Time + + // The Amazon Web Services account ID that's associated with the public registry + // that contains the repository. + RegistryId *string + + // The Amazon Resource Name (ARN) that identifies the repository. The ARN contains + // the arn:aws:ecr namespace, followed by the region of the repository, Amazon Web + // Services account ID of the repository owner, repository namespace, and + // repository name. For example, arn:aws:ecr:region:012345678910:repository/test . + RepositoryArn *string + + // The name of the repository. + RepositoryName *string + + // The URI for the repository. You can use this URI for container image push and + // pull operations. + RepositoryUri *string + + noSmithyDocumentSerde +} + +func (v *Repository) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.Repository) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *Repository) SerializeMembers(s smithy.ShapeSerializer) { + if v.CreatedAt != nil { + s.WriteTime(schemas.Repository_createdAt, *v.CreatedAt) + } + if v.RegistryId != nil { + s.WriteString(schemas.Repository_registryId, *v.RegistryId) + } + if v.RepositoryArn != nil { + s.WriteString(schemas.Repository_repositoryArn, *v.RepositoryArn) + } + if v.RepositoryName != nil { + s.WriteString(schemas.Repository_repositoryName, *v.RepositoryName) + } + if v.RepositoryUri != nil { + s.WriteString(schemas.Repository_repositoryUri, *v.RepositoryUri) + } +} +func (v *Repository) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.Repository, func(s *smithy.Schema) error { + switch s { + case schemas.Repository_createdAt: + v.CreatedAt = new(time.Time) + return d.ReadTime(schemas.Repository_createdAt, v.CreatedAt) + case schemas.Repository_registryId: + v.RegistryId = new(string) + return d.ReadString(schemas.Repository_registryId, v.RegistryId) + case schemas.Repository_repositoryArn: + v.RepositoryArn = new(string) + return d.ReadString(schemas.Repository_repositoryArn, v.RepositoryArn) + case schemas.Repository_repositoryName: + v.RepositoryName = new(string) + return d.ReadString(schemas.Repository_repositoryName, v.RepositoryName) + case schemas.Repository_repositoryUri: + v.RepositoryUri = new(string) + return d.ReadString(schemas.Repository_repositoryUri, v.RepositoryUri) + } + return nil + }) +} + +// The catalog data for a repository. This data is publicly visible in the Amazon +// ECR Public Gallery. +type RepositoryCatalogData struct { + + // The longform description of the contents of the repository. This text appears + // in the repository details on the Amazon ECR Public Gallery. + AboutText *string + + // The architecture tags that are associated with the repository. + // + // Only supported operating system tags appear publicly in the Amazon ECR Public + // Gallery. For more information, see RepositoryCatalogDataInput. + Architectures []string + + // The short description of the repository. + Description *string + + // The URL that contains the logo that's associated with the repository. + LogoUrl *string + + // Indicates whether the repository is certified by Amazon Web Services + // Marketplace. + MarketplaceCertified *bool + + // The operating system tags that are associated with the repository. + // + // Only supported operating system tags appear publicly in the Amazon ECR Public + // Gallery. For more information, see RepositoryCatalogDataInput. + OperatingSystems []string + + // The longform usage details of the contents of the repository. The usage text + // provides context for users of the repository. + UsageText *string + + noSmithyDocumentSerde +} + +func (v *RepositoryCatalogData) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.RepositoryCatalogData) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *RepositoryCatalogData) SerializeMembers(s smithy.ShapeSerializer) { + if v.AboutText != nil { + s.WriteString(schemas.RepositoryCatalogData_aboutText, *v.AboutText) + } + serializeArchitectureList(s, schemas.RepositoryCatalogData_architectures, v.Architectures) + if v.Description != nil { + s.WriteString(schemas.RepositoryCatalogData_description, *v.Description) + } + if v.LogoUrl != nil { + s.WriteString(schemas.RepositoryCatalogData_logoUrl, *v.LogoUrl) + } + if v.MarketplaceCertified != nil { + s.WriteBool(schemas.RepositoryCatalogData_marketplaceCertified, *v.MarketplaceCertified) + } + serializeOperatingSystemList(s, schemas.RepositoryCatalogData_operatingSystems, v.OperatingSystems) + if v.UsageText != nil { + s.WriteString(schemas.RepositoryCatalogData_usageText, *v.UsageText) + } +} +func (v *RepositoryCatalogData) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.RepositoryCatalogData, func(s *smithy.Schema) error { + switch s { + case schemas.RepositoryCatalogData_aboutText: + v.AboutText = new(string) + return d.ReadString(schemas.RepositoryCatalogData_aboutText, v.AboutText) + case schemas.RepositoryCatalogData_architectures: + return deserializeArchitectureList(d, schemas.RepositoryCatalogData_architectures, &v.Architectures) + case schemas.RepositoryCatalogData_description: + v.Description = new(string) + return d.ReadString(schemas.RepositoryCatalogData_description, v.Description) + case schemas.RepositoryCatalogData_logoUrl: + v.LogoUrl = new(string) + return d.ReadString(schemas.RepositoryCatalogData_logoUrl, v.LogoUrl) + case schemas.RepositoryCatalogData_marketplaceCertified: + v.MarketplaceCertified = new(bool) + return d.ReadBool(schemas.RepositoryCatalogData_marketplaceCertified, v.MarketplaceCertified) + case schemas.RepositoryCatalogData_operatingSystems: + return deserializeOperatingSystemList(d, schemas.RepositoryCatalogData_operatingSystems, &v.OperatingSystems) + case schemas.RepositoryCatalogData_usageText: + v.UsageText = new(string) + return d.ReadString(schemas.RepositoryCatalogData_usageText, v.UsageText) + } + return nil + }) +} + +// An object that contains the catalog data for a repository. This data is +// publicly visible in the Amazon ECR Public Gallery. +type RepositoryCatalogDataInput struct { + + // A detailed description of the contents of the repository. It's publicly visible + // in the Amazon ECR Public Gallery. The text must be in markdown format. + AboutText *string + + // The system architecture that the images in the repository are compatible with. + // On the Amazon ECR Public Gallery, the following supported architectures appear + // as badges on the repository and are used as search filters. + // + // If an unsupported tag is added to your repository catalog data, it's associated + // with the repository and can be retrieved using the API but isn't discoverable in + // the Amazon ECR Public Gallery. + // + // - ARM + // + // - ARM 64 + // + // - x86 + // + // - x86-64 + Architectures []string + + // A short description of the contents of the repository. This text appears in + // both the image details and also when searching for repositories on the Amazon + // ECR Public Gallery. + Description *string + + // The base64-encoded repository logo payload. + // + // The repository logo is only publicly visible in the Amazon ECR Public Gallery + // for verified accounts. + LogoImageBlob []byte + + // The operating systems that the images in the repository are compatible with. On + // the Amazon ECR Public Gallery, the following supported operating systems appear + // as badges on the repository and are used as search filters. + // + // If an unsupported tag is added to your repository catalog data, it's associated + // with the repository and can be retrieved using the API but isn't discoverable in + // the Amazon ECR Public Gallery. + // + // - Linux + // + // - Windows + OperatingSystems []string + + // Detailed information about how to use the contents of the repository. It's + // publicly visible in the Amazon ECR Public Gallery. The usage text provides + // context, support information, and additional usage details for users of the + // repository. The text must be in markdown format. + UsageText *string + + noSmithyDocumentSerde +} + +func (v *RepositoryCatalogDataInput) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.RepositoryCatalogDataInput) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *RepositoryCatalogDataInput) SerializeMembers(s smithy.ShapeSerializer) { + if v.AboutText != nil { + s.WriteString(schemas.RepositoryCatalogDataInput_aboutText, *v.AboutText) + } + serializeArchitectureList(s, schemas.RepositoryCatalogDataInput_architectures, v.Architectures) + if v.Description != nil { + s.WriteString(schemas.RepositoryCatalogDataInput_description, *v.Description) + } + if v.LogoImageBlob != nil { + s.WriteBlob(schemas.RepositoryCatalogDataInput_logoImageBlob, v.LogoImageBlob) + } + serializeOperatingSystemList(s, schemas.RepositoryCatalogDataInput_operatingSystems, v.OperatingSystems) + if v.UsageText != nil { + s.WriteString(schemas.RepositoryCatalogDataInput_usageText, *v.UsageText) + } +} +func (v *RepositoryCatalogDataInput) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.RepositoryCatalogDataInput, func(s *smithy.Schema) error { + switch s { + case schemas.RepositoryCatalogDataInput_aboutText: + v.AboutText = new(string) + return d.ReadString(schemas.RepositoryCatalogDataInput_aboutText, v.AboutText) + case schemas.RepositoryCatalogDataInput_architectures: + return deserializeArchitectureList(d, schemas.RepositoryCatalogDataInput_architectures, &v.Architectures) + case schemas.RepositoryCatalogDataInput_description: + v.Description = new(string) + return d.ReadString(schemas.RepositoryCatalogDataInput_description, v.Description) + case schemas.RepositoryCatalogDataInput_logoImageBlob: + return d.ReadBlob(schemas.RepositoryCatalogDataInput_logoImageBlob, &v.LogoImageBlob) + case schemas.RepositoryCatalogDataInput_operatingSystems: + return deserializeOperatingSystemList(d, schemas.RepositoryCatalogDataInput_operatingSystems, &v.OperatingSystems) + case schemas.RepositoryCatalogDataInput_usageText: + v.UsageText = new(string) + return d.ReadString(schemas.RepositoryCatalogDataInput_usageText, v.UsageText) + } + return nil + }) +} + +// The metadata that you apply to a resource to help you categorize and organize +// them. Each tag consists of a key and an optional value. You define both. Tag +// keys can have a maximum character length of 128 characters, and tag values can +// have a maximum length of 256 characters. +type Tag struct { + + // One part of a key-value pair that make up a tag. A key is a general label that + // acts like a category for more specific tag values. + Key *string + + // The optional part of a key-value pair that make up a tag. A value acts as a + // descriptor within a tag category (key). + Value *string + + noSmithyDocumentSerde +} + +func (v *Tag) Serialize(s smithy.ShapeSerializer) { + s.WriteStruct(schemas.Tag) + v.SerializeMembers(s) + s.CloseStruct() +} + +func (v *Tag) SerializeMembers(s smithy.ShapeSerializer) { + if v.Key != nil { + s.WriteString(schemas.Tag_Key, *v.Key) + } + if v.Value != nil { + s.WriteString(schemas.Tag_Value, *v.Value) + } +} +func (v *Tag) Deserialize(d smithy.ShapeDeserializer) error { + return smithy.ReadStruct(d, schemas.Tag, func(s *smithy.Schema) error { + switch s { + case schemas.Tag_Key: + v.Key = new(string) + return d.ReadString(schemas.Tag_Key, v.Key) + case schemas.Tag_Value: + v.Value = new(string) + return d.ReadString(schemas.Tag_Value, v.Value) + } + return nil + }) +} + +type noSmithyDocumentSerde = smithydocument.NoSerde diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/validators.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/validators.go new file mode 100644 index 0000000..76d60ad --- /dev/null +++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecrpublic/validators.go @@ -0,0 +1,751 @@ +// Code generated by smithy-go-codegen DO NOT EDIT. + +package ecrpublic + +import ( + "context" + "fmt" + smithy "github.com/aws/smithy-go" + "github.com/aws/smithy-go/middleware" +) + +type validateOpBatchCheckLayerAvailability struct { +} + +func (*validateOpBatchCheckLayerAvailability) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpBatchCheckLayerAvailability) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*BatchCheckLayerAvailabilityInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpBatchCheckLayerAvailabilityInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpBatchDeleteImage struct { +} + +func (*validateOpBatchDeleteImage) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpBatchDeleteImage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*BatchDeleteImageInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpBatchDeleteImageInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpCompleteLayerUpload struct { +} + +func (*validateOpCompleteLayerUpload) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpCompleteLayerUpload) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*CompleteLayerUploadInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpCompleteLayerUploadInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpCreateRepository struct { +} + +func (*validateOpCreateRepository) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpCreateRepository) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*CreateRepositoryInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpCreateRepositoryInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpDeleteRepository struct { +} + +func (*validateOpDeleteRepository) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDeleteRepository) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DeleteRepositoryInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDeleteRepositoryInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpDeleteRepositoryPolicy struct { +} + +func (*validateOpDeleteRepositoryPolicy) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDeleteRepositoryPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DeleteRepositoryPolicyInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDeleteRepositoryPolicyInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpDescribeImages struct { +} + +func (*validateOpDescribeImages) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDescribeImages) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DescribeImagesInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDescribeImagesInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpDescribeImageTags struct { +} + +func (*validateOpDescribeImageTags) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpDescribeImageTags) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*DescribeImageTagsInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpDescribeImageTagsInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpGetRepositoryCatalogData struct { +} + +func (*validateOpGetRepositoryCatalogData) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpGetRepositoryCatalogData) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*GetRepositoryCatalogDataInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpGetRepositoryCatalogDataInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpGetRepositoryPolicy struct { +} + +func (*validateOpGetRepositoryPolicy) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpGetRepositoryPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*GetRepositoryPolicyInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpGetRepositoryPolicyInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpInitiateLayerUpload struct { +} + +func (*validateOpInitiateLayerUpload) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpInitiateLayerUpload) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*InitiateLayerUploadInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpInitiateLayerUploadInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpListTagsForResource struct { +} + +func (*validateOpListTagsForResource) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*ListTagsForResourceInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpListTagsForResourceInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpPutImage struct { +} + +func (*validateOpPutImage) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpPutImage) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*PutImageInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpPutImageInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpPutRepositoryCatalogData struct { +} + +func (*validateOpPutRepositoryCatalogData) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpPutRepositoryCatalogData) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*PutRepositoryCatalogDataInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpPutRepositoryCatalogDataInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpSetRepositoryPolicy struct { +} + +func (*validateOpSetRepositoryPolicy) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpSetRepositoryPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*SetRepositoryPolicyInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpSetRepositoryPolicyInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpTagResource struct { +} + +func (*validateOpTagResource) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*TagResourceInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpTagResourceInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpUntagResource struct { +} + +func (*validateOpUntagResource) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*UntagResourceInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpUntagResourceInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +type validateOpUploadLayerPart struct { +} + +func (*validateOpUploadLayerPart) ID() string { + return "OperationInputValidation" +} + +func (m *validateOpUploadLayerPart) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( + out middleware.InitializeOutput, metadata middleware.Metadata, err error, +) { + input, ok := in.Parameters.(*UploadLayerPartInput) + if !ok { + return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) + } + if err := validateOpUploadLayerPartInput(input); err != nil { + return out, metadata, err + } + return next.HandleInitialize(ctx, in) +} + +func addOpBatchCheckLayerAvailabilityValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpBatchCheckLayerAvailability{}, middleware.After) +} + +func addOpBatchDeleteImageValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpBatchDeleteImage{}, middleware.After) +} + +func addOpCompleteLayerUploadValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpCompleteLayerUpload{}, middleware.After) +} + +func addOpCreateRepositoryValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpCreateRepository{}, middleware.After) +} + +func addOpDeleteRepositoryValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDeleteRepository{}, middleware.After) +} + +func addOpDeleteRepositoryPolicyValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDeleteRepositoryPolicy{}, middleware.After) +} + +func addOpDescribeImagesValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDescribeImages{}, middleware.After) +} + +func addOpDescribeImageTagsValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpDescribeImageTags{}, middleware.After) +} + +func addOpGetRepositoryCatalogDataValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpGetRepositoryCatalogData{}, middleware.After) +} + +func addOpGetRepositoryPolicyValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpGetRepositoryPolicy{}, middleware.After) +} + +func addOpInitiateLayerUploadValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpInitiateLayerUpload{}, middleware.After) +} + +func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) +} + +func addOpPutImageValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpPutImage{}, middleware.After) +} + +func addOpPutRepositoryCatalogDataValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpPutRepositoryCatalogData{}, middleware.After) +} + +func addOpSetRepositoryPolicyValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpSetRepositoryPolicy{}, middleware.After) +} + +func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) +} + +func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) +} + +func addOpUploadLayerPartValidationMiddleware(stack *middleware.Stack) error { + return stack.Initialize.Add(&validateOpUploadLayerPart{}, middleware.After) +} + +func validateOpBatchCheckLayerAvailabilityInput(v *BatchCheckLayerAvailabilityInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "BatchCheckLayerAvailabilityInput"} + if v.RepositoryName == nil { + invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) + } + if v.LayerDigests == nil { + invalidParams.Add(smithy.NewErrParamRequired("LayerDigests")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpBatchDeleteImageInput(v *BatchDeleteImageInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteImageInput"} + if v.RepositoryName == nil { + invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) + } + if v.ImageIds == nil { + invalidParams.Add(smithy.NewErrParamRequired("ImageIds")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpCompleteLayerUploadInput(v *CompleteLayerUploadInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "CompleteLayerUploadInput"} + if v.RepositoryName == nil { + invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) + } + if v.UploadId == nil { + invalidParams.Add(smithy.NewErrParamRequired("UploadId")) + } + if v.LayerDigests == nil { + invalidParams.Add(smithy.NewErrParamRequired("LayerDigests")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpCreateRepositoryInput(v *CreateRepositoryInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "CreateRepositoryInput"} + if v.RepositoryName == nil { + invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpDeleteRepositoryInput(v *DeleteRepositoryInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DeleteRepositoryInput"} + if v.RepositoryName == nil { + invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpDeleteRepositoryPolicyInput(v *DeleteRepositoryPolicyInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DeleteRepositoryPolicyInput"} + if v.RepositoryName == nil { + invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpDescribeImagesInput(v *DescribeImagesInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DescribeImagesInput"} + if v.RepositoryName == nil { + invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpDescribeImageTagsInput(v *DescribeImageTagsInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "DescribeImageTagsInput"} + if v.RepositoryName == nil { + invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpGetRepositoryCatalogDataInput(v *GetRepositoryCatalogDataInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "GetRepositoryCatalogDataInput"} + if v.RepositoryName == nil { + invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpGetRepositoryPolicyInput(v *GetRepositoryPolicyInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "GetRepositoryPolicyInput"} + if v.RepositoryName == nil { + invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpInitiateLayerUploadInput(v *InitiateLayerUploadInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "InitiateLayerUploadInput"} + if v.RepositoryName == nil { + invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} + if v.ResourceArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpPutImageInput(v *PutImageInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "PutImageInput"} + if v.RepositoryName == nil { + invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) + } + if v.ImageManifest == nil { + invalidParams.Add(smithy.NewErrParamRequired("ImageManifest")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpPutRepositoryCatalogDataInput(v *PutRepositoryCatalogDataInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "PutRepositoryCatalogDataInput"} + if v.RepositoryName == nil { + invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) + } + if v.CatalogData == nil { + invalidParams.Add(smithy.NewErrParamRequired("CatalogData")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpSetRepositoryPolicyInput(v *SetRepositoryPolicyInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "SetRepositoryPolicyInput"} + if v.RepositoryName == nil { + invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) + } + if v.PolicyText == nil { + invalidParams.Add(smithy.NewErrParamRequired("PolicyText")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpTagResourceInput(v *TagResourceInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} + if v.ResourceArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) + } + if v.Tags == nil { + invalidParams.Add(smithy.NewErrParamRequired("Tags")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpUntagResourceInput(v *UntagResourceInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} + if v.ResourceArn == nil { + invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) + } + if v.TagKeys == nil { + invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} + +func validateOpUploadLayerPartInput(v *UploadLayerPartInput) error { + if v == nil { + return nil + } + invalidParams := smithy.InvalidParamsError{Context: "UploadLayerPartInput"} + if v.RepositoryName == nil { + invalidParams.Add(smithy.NewErrParamRequired("RepositoryName")) + } + if v.UploadId == nil { + invalidParams.Add(smithy.NewErrParamRequired("UploadId")) + } + if v.PartFirstByte == nil { + invalidParams.Add(smithy.NewErrParamRequired("PartFirstByte")) + } + if v.PartLastByte == nil { + invalidParams.Add(smithy.NewErrParamRequired("PartLastByte")) + } + if v.LayerPartBlob == nil { + invalidParams.Add(smithy.NewErrParamRequired("LayerPartBlob")) + } + if invalidParams.Len() > 0 { + return invalidParams + } else { + return nil + } +} diff --git a/vendor/modules.txt b/vendor/modules.txt index 48c218e..d3749a8 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -59,6 +59,12 @@ github.com/aws/aws-sdk-go-v2/service/ecr github.com/aws/aws-sdk-go-v2/service/ecr/internal/endpoints github.com/aws/aws-sdk-go-v2/service/ecr/schemas github.com/aws/aws-sdk-go-v2/service/ecr/types +# github.com/aws/aws-sdk-go-v2/service/ecrpublic v1.47.0 +## explicit; go 1.24 +github.com/aws/aws-sdk-go-v2/service/ecrpublic +github.com/aws/aws-sdk-go-v2/service/ecrpublic/internal/endpoints +github.com/aws/aws-sdk-go-v2/service/ecrpublic/schemas +github.com/aws/aws-sdk-go-v2/service/ecrpublic/types # github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.19 ## explicit; go 1.24 github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding