1. Drop the source/ directory into your project root if building from source, or install directly from npm (preferred for consumers).

2. If building from source, ensure you have Node.js 18+ and Yarn Berry:

   corepack enable
   yarn install
   yarn turbo run build
   

3. For a standard TypeScript consumer project, add to your tsconfig.json:

   {
     "compilerOptions": {
       "target": "ES2020",
       "module": "commonjs",
       "moduleResolution": "node",
       "esModuleInterop": true,
       "strict": true
     }
   }
   

4. Set AWS credentials via environment variables or ~/.aws/credentials:

   export AWS_REGION=us-east-1
   export AWS_ACCESS_KEY_ID=your_key
   export AWS_SECRET_ACCESS_KEY=your_secret
   # Or use AWS_PROFILE for named profiles
   

5. The SDK automatically resolves credentials using the default credential provider chain (env vars → shared credentials file → IAM role). No manual credential wiring is required for standard deployments.

Public API

AccessAnalyzerClient

import { AccessAnalyzerClient } from "@aws-sdk/client-accessanalyzer";

const client = new AccessAnalyzerClient({ region: "us-east-1" });

The base client for IAM Access Analyzer. Instantiate once per region and reuse across commands. Accepts standard SmithyResolvedConfiguration options including region, credentials, and endpoint.

ListAnalyzersCommand

import {
  AccessAnalyzerClient,
  ListAnalyzersCommand,
  ListAnalyzersCommandInput,
  ListAnalyzersCommandOutput,
} from "@aws-sdk/client-accessanalyzer";

const input: ListAnalyzersCommandInput = { type: "ACCOUNT" };
const output: ListAnalyzersCommandOutput = await client.send(
  new ListAnalyzersCommand(input)
);

Returns all Access Analyzer analyzers in the current account and region. Use this to discover existing analyzers before creating findings queries. Pair with paginateListAnalyzers for large result sets.

ValidatePolicyCommand

import {
  AccessAnalyzerClient,
  ValidatePolicyCommand,
  ValidatePolicyCommandInput,
} from "@aws-sdk/client-accessanalyzer";

const input: ValidatePolicyCommandInput = {
  policyDocument: JSON.stringify({ Version: "2012-10-17", Statement: [] }),
  policyType: "IDENTITY_POLICY",
};
const result = await client.send(new ValidatePolicyCommand(input));

Validates an IAM policy document and returns a list of findings with severity and location. Use this in CI pipelines to gate policy deployments. Supports pagination via paginateValidatePolicy.

AccountClient

import { AccountClient, ListRegionsCommand } from "@aws-sdk/client-account";

const client = new AccountClient({ region: "us-east-1" });
const regions = await client.send(new ListRegionsCommand({}));

Client for AWS Account Management operations. Use to manage account-level settings such as alternate contacts, enabled regions, and primary email updates.

Working examples

Scenario - List all IAM Access Analyzers in an account

Retrieve all analyzers configured in us-east-1 and print their names and types.

import {
  AccessAnalyzerClient,
  ListAnalyzersCommand,
} from "@aws-sdk/client-accessanalyzer";

async function listAnalyzers(): Promise<void> {
  const client = new AccessAnalyzerClient({ region: "us-east-1" });
  const response = await client.send(new ListAnalyzersCommand({}));
  for (const analyzer of response.analyzers ?? []) {
    console.log(`${analyzer.name} — type: ${analyzer.type} — status: ${analyzer.status}`);
  }
}

listAnalyzers().catch(console.error);

Scenario - Validate an IAM policy before deployment

Run policy validation in a pre-deploy script to catch misconfigurations early.

import {
  AccessAnalyzerClient,
  ValidatePolicyCommand,
} from "@aws-sdk/client-accessanalyzer";
import * as fs from "fs";

async function validatePolicy(policyPath: string): Promise<void> {
  const client = new AccessAnalyzerClient({ region: "us-east-1" });
  const policyDocument = fs.readFileSync(policyPath, "utf-8");

  const result = await client.send(
    new ValidatePolicyCommand({
      policyDocument,
      policyType: "IDENTITY_POLICY",
    })
  );

  const findings = result.findings ?? [];
  if (findings.length === 0) {
    console.log("Policy is valid.");
  } else {
    for (const f of findings) {
      console.error(`[${f.findingType}] ${f.issueCode}: ${f.findingDetails}`);
    }
    process.exit(1);
  }
}

validatePolicy("./my-policy.json").catch(console.error);

Scenario - Manage AWS account regions using the Account client

Enable or list opted-in regions for an account.

import {
  AccountClient,
  ListRegionsCommand,
  GetRegionOptStatusCommand,
} from "@aws-sdk/client-account";

async function inspectRegions(): Promise<void> {
  const client = new AccountClient({ region: "us-east-1" });

  const { regions } = await client.send(
    new ListRegionsCommand({ regionOptStatusContains: ["ENABLED", "ENABLING"] })
  );

  for (const region of regions ?? []) {
    const status = await client.send(
      new GetRegionOptStatusCommand({ regionName: region.regionName! })
    );
    console.log(`${region.regionName}: ${status.regionOptStatus}`);
  }
}

inspectRegions().catch(console.error);

File walkthrough

• clients/ - Contains one subdirectory per AWS service (e.g., client-accessanalyzer/, client-account/). Each subdirectory is a standalone npm package with its own package.json, src/, and compiled output.
• clients/client-accessanalyzer/src/index.ts - Public entrypoint for the Access Analyzer client; re-exports the client class, all commands, paginators, models, enums, and error types.
• clients/client-account/src/index.ts - Public entrypoint for the Account Management client; same structure as all other service clients.
• tsconfig.json - Root TypeScript config; extended by per-package configs.
• tsconfig.cjs.json / tsconfig.es.json / tsconfig.types.json - Build variant configs for CommonJS output, ESM output, and .d.ts declarations respectively.
• turbo.json - Defines the Turborepo task graph: build, test, lint tasks with correct dependency ordering across the monorepo.
• lerna.json - Configures Lerna for versioning and publishing individual @aws-sdk/* packages independently.
• package.json - Root workspace manifest; declares all clients/* as Yarn workspaces and lists shared dev dependencies.
• jest.config.base.js - Base Jest configuration extended by each package for consistent test behavior.
• prettier.config.js - Shared Prettier formatting rules applied monorepo-wide.

Common pitfalls and fixes

• Wrong region - If you omit region in the client constructor and AWS_REGION is not set, calls fail with a config error; always pass region explicitly or set AWS_REGION.
• ESM/CJS interop errors - If your bundler emits ERR_REQUIRE_ESM, set "esModuleInterop": true in tsconfig.json and use import syntax, not require().
• Credential resolution order - The SDK checks env vars, then ~/.aws/credentials, then EC2/ECS metadata; if running in Lambda, do not pass credentials manually — the role is picked up automatically.
• Paginator vs. single call - Commands like ListAnalyzersCommand return at most one page; for full result sets import and use paginateListAnalyzers from @aws-sdk/client-accessanalyzer instead.
• TypeScript strict mode errors on output types - All response fields are optional (| undefined) by design; use optional chaining (?.) and nullish coalescing (??) throughout.
• Building from source with Yarn workspaces - Running npm install instead of yarn install in the monorepo will break workspace symlinks; use yarn and turbo run build as documented.

Vibe-coding prompt template

I have the AWS SDK for JavaScript v3 monorepo under source/ in my project.
I also have USAGE.md which documents the real exports and working examples.
The upstream package name is aws-sdk-js-v3 and individual clients are published
as @aws-sdk/client-<service-name>.

My project is a Node.js TypeScript application. Please integrate the following
AWS service client(s) from source/ into my project step by step:

1. Read USAGE.md and source/clients/client-<service>/src/index.ts to understand
   the real exported symbols — do not invent any API names.
2. Add the required npm install lines for only the clients I need.
3. Create a client module in src/aws/<service>.ts that instantiates the client
   and exports typed helper functions wrapping the commands I need.
4. Wire credentials via environment variables as shown in USAGE.md.
5. Add error handling using the ServiceException base class exported from
   each client package.
6. Show me the full TypeScript code for each file you create or modify.

License and credit

The AWS SDK for JavaScript v3 is licensed under the Apache License 2.0. See source/LICENSE for the full license text. The upstream project is maintained by Amazon Web Services at https://github.com/aws/aws-sdk-js-v3 and published on npm under the @aws-sdk scope.

This product’s unique contribution is clean room implementation of valuable code block into AVCP compatible standard.

The full install guide and integration prompts unlock after purchase.

Webiny Serverless CMS Platform for AWS Enterprises

CRM, ERP, Admin & Internal Tools

Free