or run

npx @tessl/cli init

Version

Tile

Overview

Evals

Files

docs

configuration.md events.md index.md requests.md services.md utilities.md

tile.json

Service Clients

The AWS SDK provides 387 service clients with consistent interfaces for accessing all Amazon Web Services. Each service client follows the same pattern for configuration, authentication, and API operations.

Service Client Pattern

Base Service Interface

class ServiceClient {
  constructor(options?: ClientConfiguration);
  
  // Configuration
  config: Config & ClientConfiguration;
  endpoint: Endpoint;
  
  // Core methods
  makeRequest(operation: string, params?: any, callback?: RequestCallback): Request;
  defineService(serviceIdentifier: string, versions: string[], features?: any): typeof ServiceClient;
  addVersions(versions: string[]): void;
  
  // Properties
  api: ApiModel;
  serviceIdentifier: string;
  apiVersions: string[];
}

interface ClientConfiguration extends ConfigurationOptions {
  apiVersion?: string;
  endpoint?: string | Endpoint;
  region?: string;
  maxRetries?: number;
  httpOptions?: HTTPOptions;
  paramValidation?: boolean | ParamValidationOptions;
  convertResponseTypes?: boolean;
  correctClockSkew?: boolean;
  retryDelayOptions?: RetryDelayOptions;
  logger?: Logger;
  systemClockOffset?: number;
  signatureVersion?: string;
  customUserAgent?: string;
}

Creating Service Instances

Basic Service Creation:

const s3 = new AWS.S3();
const dynamodb = new AWS.DynamoDB();
const lambda = new AWS.Lambda();

With Configuration:

const s3 = new AWS.S3({
  region: 'us-west-2',
  apiVersion: '2006-03-01',
  httpOptions: { timeout: 120000 }
});

Individual Service Import:

const S3 = require('aws-sdk/clients/s3');
const s3 = new S3({ region: 'us-east-1' });

Core Compute Services

Amazon EC2

class EC2 extends ServiceClient {
  // Instance management
  runInstances(params: RunInstancesRequest, callback?: Callback<RunInstancesResult>): Request<RunInstancesResult>;
  describeInstances(params?: DescribeInstancesRequest, callback?: Callback<DescribeInstancesResult>): Request<DescribeInstancesResult>;
  terminateInstances(params: TerminateInstancesRequest, callback?: Callback<TerminateInstancesResult>): Request<TerminateInstancesResult>;
  startInstances(params: StartInstancesRequest, callback?: Callback<StartInstancesResult>): Request<StartInstancesResult>;
  stopInstances(params: StopInstancesRequest, callback?: Callback<StopInstancesResult>): Request<StopInstancesResult>;
  rebootInstances(params: RebootInstancesRequest, callback?: Callback): Request<{}>;
  
  // Image management
  createImage(params: CreateImageRequest, callback?: Callback<CreateImageResult>): Request<CreateImageResult>;
  describeImages(params?: DescribeImagesRequest, callback?: Callback<DescribeImagesResult>): Request<DescribeImagesResult>;
  deregisterImage(params: DeregisterImageRequest, callback?: Callback): Request<{}>;
  
  // Security groups
  createSecurityGroup(params: CreateSecurityGroupRequest, callback?: Callback<CreateSecurityGroupResult>): Request<CreateSecurityGroupResult>;
  authorizeSecurityGroupIngress(params: AuthorizeSecurityGroupIngressRequest, callback?: Callback): Request<{}>;
  revokeSecurityGroupIngress(params: RevokeSecurityGroupIngressRequest, callback?: Callback): Request<{}>;
  
  // Key pairs
  createKeyPair(params: CreateKeyPairRequest, callback?: Callback<CreateKeyPairResult>): Request<CreateKeyPairResult>;
  describeKeyPairs(params?: DescribeKeyPairsRequest, callback?: Callback<DescribeKeyPairsResult>): Request<DescribeKeyPairsResult>;
  deleteKeyPair(params: DeleteKeyPairRequest, callback?: Callback): Request<{}>;
}

const ec2 = new AWS.EC2();

AWS Lambda

class Lambda extends ServiceClient {
  // Function management
  createFunction(params: CreateFunctionRequest, callback?: Callback<FunctionConfiguration>): Request<FunctionConfiguration>;
  updateFunctionCode(params: UpdateFunctionCodeRequest, callback?: Callback<FunctionConfiguration>): Request<FunctionConfiguration>;
  updateFunctionConfiguration(params: UpdateFunctionConfigurationRequest, callback?: Callback<FunctionConfiguration>): Request<FunctionConfiguration>;
  deleteFunction(params: DeleteFunctionRequest, callback?: Callback): Request<{}>;
  getFunction(params: GetFunctionRequest, callback?: Callback<GetFunctionResponse>): Request<GetFunctionResponse>;
  listFunctions(params?: ListFunctionsRequest, callback?: Callback<ListFunctionsResponse>): Request<ListFunctionsResponse>;
  
  // Function invocation
  invoke(params: InvocationRequest, callback?: Callback<InvocationResponse>): Request<InvocationResponse>;
  invokeAsync(params: InvokeAsyncRequest, callback?: Callback<InvokeAsyncResponse>): Request<InvokeAsyncResponse>;
  
  // Event source mappings
  createEventSourceMapping(params: CreateEventSourceMappingRequest, callback?: Callback<EventSourceMappingConfiguration>): Request<EventSourceMappingConfiguration>;
  listEventSourceMappings(params?: ListEventSourceMappingsRequest, callback?: Callback<ListEventSourceMappingsResponse>): Request<ListEventSourceMappingsResponse>;
  deleteEventSourceMapping(params: DeleteEventSourceMappingRequest, callback?: Callback<EventSourceMappingConfiguration>): Request<EventSourceMappingConfiguration>;
}

const lambda = new AWS.Lambda();

Amazon ECS

class ECS extends ServiceClient {
  // Cluster management
  createCluster(params?: CreateClusterRequest, callback?: Callback<CreateClusterResponse>): Request<CreateClusterResponse>;
  deleteCluster(params: DeleteClusterRequest, callback?: Callback<DeleteClusterResponse>): Request<DeleteClusterResponse>;
  describeClusters(params?: DescribeClustersRequest, callback?: Callback<DescribeClustersResponse>): Request<DescribeClustersResponse>;
  listClusters(params?: ListClustersRequest, callback?: Callback<ListClustersResponse>): Request<ListClustersResponse>;
  
  // Task definitions
  registerTaskDefinition(params: RegisterTaskDefinitionRequest, callback?: Callback<RegisterTaskDefinitionResponse>): Request<RegisterTaskDefinitionResponse>;
  deregisterTaskDefinition(params: DeregisterTaskDefinitionRequest, callback?: Callback<DeregisterTaskDefinitionResponse>): Request<DeregisterTaskDefinitionResponse>;
  describeTaskDefinition(params: DescribeTaskDefinitionRequest, callback?: Callback<DescribeTaskDefinitionResponse>): Request<DescribeTaskDefinitionResponse>;
  
  // Task management
  runTask(params: RunTaskRequest, callback?: Callback<RunTaskResponse>): Request<RunTaskResponse>;
  startTask(params: StartTaskRequest, callback?: Callback<StartTaskResponse>): Request<StartTaskResponse>;
  stopTask(params: StopTaskRequest, callback?: Callback<StopTaskResponse>): Request<StopTaskResponse>;
  describeTasks(params: DescribeTasksRequest, callback?: Callback<DescribeTasksResponse>): Request<DescribeTasksResponse>;
  listTasks(params?: ListTasksRequest, callback?: Callback<ListTasksResponse>): Request<ListTasksResponse>;
  
  // Service management
  createService(params: CreateServiceRequest, callback?: Callback<CreateServiceResponse>): Request<CreateServiceResponse>;
  updateService(params: UpdateServiceRequest, callback?: Callback<UpdateServiceResponse>): Request<UpdateServiceResponse>;
  deleteService(params: DeleteServiceRequest, callback?: Callback<DeleteServiceResponse>): Request<DeleteServiceResponse>;
  describeServices(params: DescribeServicesRequest, callback?: Callback<DescribeServicesResponse>): Request<DescribeServicesResponse>;
  listServices(params?: ListServicesRequest, callback?: Callback<ListServicesResponse>): Request<ListServicesResponse>;
}

const ecs = new AWS.ECS();

Storage Services

Amazon S3

class S3 extends ServiceClient {
  // Bucket operations
  createBucket(params: CreateBucketRequest, callback?: Callback<CreateBucketOutput>): Request<CreateBucketOutput>;
  deleteBucket(params: DeleteBucketRequest, callback?: Callback): Request<{}>;
  listBuckets(callback?: Callback<ListBucketsOutput>): Request<ListBucketsOutput>;
  headBucket(params: HeadBucketRequest, callback?: Callback): Request<{}>;
  
  // Object operations
  putObject(params: PutObjectRequest, callback?: Callback<PutObjectOutput>): Request<PutObjectOutput>;
  getObject(params: GetObjectRequest, callback?: Callback<GetObjectOutput>): Request<GetObjectOutput>;
  deleteObject(params: DeleteObjectRequest, callback?: Callback<DeleteObjectOutput>): Request<DeleteObjectOutput>;
  copyObject(params: CopyObjectRequest, callback?: Callback<CopyObjectOutput>): Request<CopyObjectOutput>;
  headObject(params: HeadObjectRequest, callback?: Callback<HeadObjectOutput>): Request<HeadObjectOutput>;
  listObjects(params: ListObjectsRequest, callback?: Callback<ListObjectsOutput>): Request<ListObjectsOutput>;
  listObjectsV2(params: ListObjectsV2Request, callback?: Callback<ListObjectsV2Output>): Request<ListObjectsV2Output>;
  
  // Multipart upload
  createMultipartUpload(params: CreateMultipartUploadRequest, callback?: Callback<CreateMultipartUploadOutput>): Request<CreateMultipartUploadOutput>;
  uploadPart(params: UploadPartRequest, callback?: Callback<UploadPartOutput>): Request<UploadPartOutput>;
  completeMultipartUpload(params: CompleteMultipartUploadRequest, callback?: Callback<CompleteMultipartUploadOutput>): Request<CompleteMultipartUploadOutput>;
  abortMultipartUpload(params: AbortMultipartUploadRequest, callback?: Callback<AbortMultipartUploadOutput>): Request<AbortMultipartUploadOutput>;
  listParts(params: ListPartsRequest, callback?: Callback<ListPartsOutput>): Request<ListPartsOutput>;
  
  // Enhanced S3 methods
  upload(params: S3.ManagedUpload.ManagedUploadOptions, callback?: Callback<S3.ManagedUpload.SendData>): S3.ManagedUpload;
  getSignedUrl(operation: string, params: any, callback?: (err: Error, url: string) => void): string;
  getSignedUrlPromise(operation: string, params: any): Promise<string>;
  presignedPost(params: PresignedPost.Params, callback: (err: Error, data: PresignedPost.PresignedPostOptions) => void): void;
}

const s3 = new AWS.S3();

S3 Specialized Utilities

S3 Managed Upload:

class S3.ManagedUpload {
  constructor(options: ManagedUploadOptions);
  
  // Properties
  promise(): Promise<SendData>;
  send(callback?: (err: Error, data: SendData) => void): void;
  abort(): void;
  on(event: string, listener: Function): ManagedUpload;
  
  // Progress tracking
  minPartSize: number;
  maxTotalParts: number;
  
  static minPartSize: number;
  static maxTotalParts: number;
}

interface ManagedUploadOptions {
  params: PutObjectRequest;
  options?: {
    partSize?: number;
    queueSize?: number;
    leavePartsOnError?: boolean;
    service?: S3;
  };
}

interface SendData {
  Location: string;
  ETag: string;
  Bucket: string;
  Key: string;
}

// Managed upload with progress tracking
const upload = s3.upload({
  Bucket: 'my-bucket',
  Key: 'large-file.zip',
  Body: fs.createReadStream('large-file.zip')
});

upload.on('httpUploadProgress', (progress) => {
  console.log(`Uploaded ${progress.loaded} of ${progress.total} bytes`);
});

upload.send((err, data) => {
  if (err) console.error(err);
  else console.log('Upload successful:', data.Location);
});

S3 Presigner:

class S3.Presigner {
  constructor(options?: {
    credentials?: Credentials;
    region?: string;
    endpoint?: string;
  });
  
  presign(request: Request, expires?: number): void;
}

// Pre-signed URLs for secure access
const presigner = new AWS.S3.Presigner();
const url = s3.getSignedUrl('getObject', {
  Bucket: 'my-bucket',
  Key: 'private-file.pdf',
  Expires: 3600 // 1 hour
});

// Pre-signed POST for browser uploads
s3.presignedPost({
  Bucket: 'my-bucket',
  Fields: {
    key: 'uploads/${filename}',
    acl: 'private'
  },
  Conditions: [
    ['content-length-range', 0, 104857600] // 100MB max
  ],
  Expires: 300 // 5 minutes
}, (err, data) => {
  if (err) console.error(err);
  else console.log('Presigned POST:', data);
});

Amazon DynamoDB

class DynamoDB extends ServiceClient {
  // Table operations
  createTable(params: CreateTableInput, callback?: Callback<CreateTableOutput>): Request<CreateTableOutput>;
  deleteTable(params: DeleteTableInput, callback?: Callback<DeleteTableOutput>): Request<DeleteTableOutput>;
  describeTable(params: DescribeTableInput, callback?: Callback<DescribeTableOutput>): Request<DescribeTableOutput>;
  listTables(params?: ListTablesInput, callback?: Callback<ListTablesOutput>): Request<ListTablesOutput>;
  updateTable(params: UpdateTableInput, callback?: Callback<UpdateTableOutput>): Request<UpdateTableOutput>;
  
  // Item operations
  putItem(params: PutItemInput, callback?: Callback<PutItemOutput>): Request<PutItemOutput>;
  getItem(params: GetItemInput, callback?: Callback<GetItemOutput>): Request<GetItemOutput>;
  updateItem(params: UpdateItemInput, callback?: Callback<UpdateItemOutput>): Request<UpdateItemOutput>;
  deleteItem(params: DeleteItemInput, callback?: Callback<DeleteItemOutput>): Request<DeleteItemOutput>;
  
  // Batch operations
  batchGetItem(params: BatchGetItemInput, callback?: Callback<BatchGetItemOutput>): Request<BatchGetItemOutput>;
  batchWriteItem(params: BatchWriteItemInput, callback?: Callback<BatchWriteItemOutput>): Request<BatchWriteItemOutput>;
  
  // Query and scan
  query(params: QueryInput, callback?: Callback<QueryOutput>): Request<QueryOutput>;
  scan(params: ScanInput, callback?: Callback<ScanOutput>): Request<ScanOutput>;
  
  // Utility methods
  waitFor(state: string, params?: any, callback?: Callback<any>): Request<any>;
}

const dynamodb = new AWS.DynamoDB();

DynamoDB Specialized Utilities

DynamoDB Document Client:

class DynamoDB.DocumentClient {
  constructor(options?: {
    params?: any;
    service?: DynamoDB;
    convertEmptyValues?: boolean;
    wrapNumbers?: boolean;
  });
  
  // Simplified operations with JavaScript object support
  put(params: DocumentClient.PutItemInput, callback?: Callback<DocumentClient.PutItemOutput>): Request<DocumentClient.PutItemOutput>;
  get(params: DocumentClient.GetItemInput, callback?: Callback<DocumentClient.GetItemOutput>): Request<DocumentClient.GetItemOutput>;
  update(params: DocumentClient.UpdateItemInput, callback?: Callback<DocumentClient.UpdateItemOutput>): Request<DocumentClient.UpdateItemOutput>;
  delete(params: DocumentClient.DeleteItemInput, callback?: Callback<DocumentClient.DeleteItemOutput>): Request<DocumentClient.DeleteItemOutput>;
  
  // Batch operations
  batchGet(params: DocumentClient.BatchGetItemInput, callback?: Callback<DocumentClient.BatchGetItemOutput>): Request<DocumentClient.BatchGetItemOutput>;
  batchWrite(params: DocumentClient.BatchWriteItemInput, callback?: Callback<DocumentClient.BatchWriteItemOutput>): Request<DocumentClient.BatchWriteItemOutput>;
  
  // Query and scan with simplified syntax
  query(params: DocumentClient.QueryInput, callback?: Callback<DocumentClient.QueryOutput>): Request<DocumentClient.QueryOutput>;
  scan(params: DocumentClient.ScanInput, callback?: Callback<DocumentClient.ScanOutput>): Request<DocumentClient.ScanOutput>;
  
  // Transaction operations
  transactGet(params: DocumentClient.TransactGetItemsInput, callback?: Callback<DocumentClient.TransactGetItemsOutput>): Request<DocumentClient.TransactGetItemsOutput>;
  transactWrite(params: DocumentClient.TransactWriteItemsInput, callback?: Callback<DocumentClient.TransactWriteItemsOutput>): Request<DocumentClient.TransactWriteItemsOutput>;
}

// High-level DynamoDB operations with JavaScript objects
const docClient = new AWS.DynamoDB.DocumentClient();

// Put item with plain JavaScript object
docClient.put({
  TableName: 'users',
  Item: {
    id: '123',
    name: 'John Doe',
    email: 'john@example.com',
    age: 30,
    active: true
  }
}, (err, data) => {
  if (err) console.error(err);
  else console.log('Item saved:', data);
});

// Query with simplified conditions
docClient.query({
  TableName: 'users',
  KeyConditionExpression: 'id = :id',
  ExpressionAttributeValues: {
    ':id': '123'
  }
}).promise()
  .then(data => console.log('Query result:', data.Items))
  .catch(err => console.error(err));

DynamoDB Data Type Converter:

const AWS.DynamoDB.Converter = {
  // Convert JavaScript objects to DynamoDB format
  marshall(data: any, options?: {
    convertEmptyValues?: boolean;
    convertClassInstanceToMap?: boolean;
    wrapNumbers?: boolean;
  }): AttributeMap;
  
  // Convert DynamoDB format to JavaScript objects
  unmarshall(data: AttributeMap, options?: {
    convertEmptyValues?: boolean;
    wrapNumbers?: boolean;
  }): any;
  
  // Individual type conversion
  input(data: any, options?: any): AttributeValue;
  output(data: AttributeValue, options?: any): any;
};

// Convert JavaScript object to DynamoDB format
const dynamoItem = AWS.DynamoDB.Converter.marshall({
  id: '123',
  name: 'John Doe',
  age: 30,
  tags: ['admin', 'user']
});
// Result: { id: { S: '123' }, name: { S: 'John Doe' }, age: { N: '30' }, tags: { SS: ['admin', 'user'] } }

// Convert DynamoDB format to JavaScript object
const jsObject = AWS.DynamoDB.Converter.unmarshall({
  id: { S: '123' },
  name: { S: 'John Doe' },
  age: { N: '30' }
});
// Result: { id: '123', name: 'John Doe', age: 30 }

DynamoDB Set Data Types:

class DynamoDB.StringSet {
  constructor(values: string[]);
  values: string[];
  wrapperName: string;
}

class DynamoDB.NumberSet {
  constructor(values: number[]);
  values: number[];
  wrapperName: string;
}

class DynamoDB.BinarySet {
  constructor(values: (Buffer | string)[]);
  values: (Buffer | string)[];
  wrapperName: string;
}

// Set data types for DynamoDB operations
const docClient = new AWS.DynamoDB.DocumentClient();

docClient.put({
  TableName: 'users',
  Item: {
    id: '123',
    name: 'John Doe',
    skills: new AWS.DynamoDB.StringSet(['JavaScript', 'Python', 'Go']),
    scores: new AWS.DynamoDB.NumberSet([95, 87, 92]),
    certificates: new AWS.DynamoDB.BinarySet([cert1Buffer, cert2Buffer])
  }
});

Database Services

Amazon RDS

class RDS extends ServiceClient {
  // DB instance management
  createDBInstance(params: CreateDBInstanceMessage, callback?: Callback<CreateDBInstanceResult>): Request<CreateDBInstanceResult>;
  deleteDBInstance(params: DeleteDBInstanceMessage, callback?: Callback<DeleteDBInstanceResult>): Request<DeleteDBInstanceResult>;
  describeDBInstances(params?: DescribeDBInstancesMessage, callback?: Callback<DBInstanceMessage>): Request<DBInstanceMessage>;
  modifyDBInstance(params: ModifyDBInstanceMessage, callback?: Callback<ModifyDBInstanceResult>): Request<ModifyDBInstanceResult>;
  rebootDBInstance(params: RebootDBInstanceMessage, callback?: Callback<RebootDBInstanceResult>): Request<RebootDBInstanceResult>;
  startDBInstance(params: StartDBInstanceMessage, callback?: Callback<StartDBInstanceResult>): Request<StartDBInstanceResult>;
  stopDBInstance(params: StopDBInstanceMessage, callback?: Callback<StopDBInstanceResult>): Request<StopDBInstanceResult>;
  
  // Snapshot management
  createDBSnapshot(params: CreateDBSnapshotMessage, callback?: Callback<CreateDBSnapshotResult>): Request<CreateDBSnapshotResult>;
  deleteDBSnapshot(params: DeleteDBSnapshotMessage, callback?: Callback<DeleteDBSnapshotResult>): Request<DeleteDBSnapshotResult>;
  describeDBSnapshots(params?: DescribeDBSnapshotsMessage, callback?: Callback<DBSnapshotMessage>): Request<DBSnapshotMessage>;
  restoreDBInstanceFromDBSnapshot(params: RestoreDBInstanceFromDBSnapshotMessage, callback?: Callback<RestoreDBInstanceFromDBSnapshotResult>): Request<RestoreDBInstanceFromDBSnapshotResult>;
  
  // DB cluster management (Aurora)
  createDBCluster(params: CreateDBClusterMessage, callback?: Callback<CreateDBClusterResult>): Request<CreateDBClusterResult>;
  deleteDBCluster(params: DeleteDBClusterMessage, callback?: Callback<DeleteDBClusterResult>): Request<DeleteDBClusterResult>;
  describeDBClusters(params?: DescribeDBClustersMessage, callback?: Callback<DBClustersMessage>): Request<DBClustersMessage>;
  modifyDBCluster(params: ModifyDBClusterMessage, callback?: Callback<ModifyDBClusterResult>): Request<ModifyDBClusterResult>;
  startDBCluster(params: StartDBClusterMessage, callback?: Callback<StartDBClusterResult>): Request<StartDBClusterResult>;
  stopDBCluster(params: StopDBClusterMessage, callback?: Callback<StopDBClusterResult>): Request<StopDBClusterResult>;
}

const rds = new AWS.RDS();

Amazon ElastiCache

class ElastiCache extends ServiceClient {
  // Cache cluster management
  createCacheCluster(params: CreateCacheClusterMessage, callback?: Callback<CreateCacheClusterResult>): Request<CreateCacheClusterResult>;
  deleteCacheCluster(params: DeleteCacheClusterMessage, callback?: Callback<DeleteCacheClusterResult>): Request<DeleteCacheClusterResult>;
  describeCacheClusters(params?: DescribeCacheClustersMessage, callback?: Callback<CacheClusterMessage>): Request<CacheClusterMessage>;
  modifyCacheCluster(params: ModifyCacheClusterMessage, callback?: Callback<ModifyCacheClusterResult>): Request<ModifyCacheClusterResult>;
  rebootCacheCluster(params: RebootCacheClusterMessage, callback?: Callback<RebootCacheClusterResult>): Request<RebootCacheClusterResult>;
  
  // Replication group management (Redis)
  createReplicationGroup(params: CreateReplicationGroupMessage, callback?: Callback<CreateReplicationGroupResult>): Request<CreateReplicationGroupResult>;
  deleteReplicationGroup(params: DeleteReplicationGroupMessage, callback?: Callback<DeleteReplicationGroupResult>): Request<DeleteReplicationGroupResult>;
  describeReplicationGroups(params?: DescribeReplicationGroupsMessage, callback?: Callback<ReplicationGroupMessage>): Request<ReplicationGroupMessage>;
  modifyReplicationGroup(params: ModifyReplicationGroupMessage, callback?: Callback<ModifyReplicationGroupResult>): Request<ModifyReplicationGroupResult>;
  
  // Snapshot management
  createSnapshot(params: CreateSnapshotMessage, callback?: Callback<CreateSnapshotResult>): Request<CreateSnapshotResult>;
  deleteSnapshot(params: DeleteSnapshotMessage, callback?: Callback<DeleteSnapshotResult>): Request<DeleteSnapshotResult>;
  describeSnapshots(params?: DescribeSnapshotsMessage, callback?: Callback<DescribeSnapshotsListMessage>): Request<DescribeSnapshotsListMessage>;
}

const elasticache = new AWS.ElastiCache();

Messaging Services

Amazon SQS

class SQS extends ServiceClient {
  // Queue management
  createQueue(params: CreateQueueRequest, callback?: Callback<CreateQueueResult>): Request<CreateQueueResult>;
  deleteQueue(params: DeleteQueueRequest, callback?: Callback): Request<{}>;
  listQueues(params?: ListQueuesRequest, callback?: Callback<ListQueuesResult>): Request<ListQueuesResult>;
  getQueueUrl(params: GetQueueUrlRequest, callback?: Callback<GetQueueUrlResult>): Request<GetQueueUrlResult>;
  getQueueAttributes(params: GetQueueAttributesRequest, callback?: Callback<GetQueueAttributesResult>): Request<GetQueueAttributesResult>;
  setQueueAttributes(params: SetQueueAttributesRequest, callback?: Callback): Request<{}>;
  
  // Message operations
  sendMessage(params: SendMessageRequest, callback?: Callback<SendMessageResult>): Request<SendMessageResult>;
  sendMessageBatch(params: SendMessageBatchRequest, callback?: Callback<SendMessageBatchResult>): Request<SendMessageBatchResult>;
  receiveMessage(params: ReceiveMessageRequest, callback?: Callback<ReceiveMessageResult>): Request<ReceiveMessageResult>;
  deleteMessage(params: DeleteMessageRequest, callback?: Callback): Request<{}>;
  deleteMessageBatch(params: DeleteMessageBatchRequest, callback?: Callback<DeleteMessageBatchResult>): Request<DeleteMessageBatchResult>;
  changeMessageVisibility(params: ChangeMessageVisibilityRequest, callback?: Callback): Request<{}>;
  changeMessageVisibilityBatch(params: ChangeMessageVisibilityBatchRequest, callback?: Callback<ChangeMessageVisibilityBatchResult>): Request<ChangeMessageVisibilityBatchResult>;
  
  // Dead letter queue and redrive
  purgeQueue(params: PurgeQueueRequest, callback?: Callback): Request<{}>;
}

const sqs = new AWS.SQS();

Amazon SNS

class SNS extends ServiceClient {
  // Topic management
  createTopic(params: CreateTopicInput, callback?: Callback<CreateTopicResponse>): Request<CreateTopicResponse>;
  deleteTopic(params: DeleteTopicInput, callback?: Callback): Request<{}>;
  listTopics(params?: ListTopicsInput, callback?: Callback<ListTopicsResponse>): Request<ListTopicsResponse>;
  getTopicAttributes(params: GetTopicAttributesInput, callback?: Callback<GetTopicAttributesResponse>): Request<GetTopicAttributesResponse>;
  setTopicAttributes(params: SetTopicAttributesInput, callback?: Callback): Request<{}>;
  
  // Subscription management
  subscribe(params: SubscribeInput, callback?: Callback<SubscribeResponse>): Request<SubscribeResponse>;
  unsubscribe(params: UnsubscribeInput, callback?: Callback): Request<{}>;
  listSubscriptions(params?: ListSubscriptionsInput, callback?: Callback<ListSubscriptionsResponse>): Request<ListSubscriptionsResponse>;
  listSubscriptionsByTopic(params: ListSubscriptionsByTopicInput, callback?: Callback<ListSubscriptionsByTopicResponse>): Request<ListSubscriptionsByTopicResponse>;
  confirmSubscription(params: ConfirmSubscriptionInput, callback?: Callback<ConfirmSubscriptionResponse>): Request<ConfirmSubscriptionResponse>;
  
  // Message publishing
  publish(params: PublishInput, callback?: Callback<PublishResponse>): Request<PublishResponse>;
  publishBatch(params: PublishBatchInput, callback?: Callback<PublishBatchResponse>): Request<PublishBatchResponse>;
}

const sns = new AWS.SNS();

Amazon CloudFront

class CloudFront extends ServiceClient {
  // Distribution management
  createDistribution(params: CreateDistributionRequest, callback?: Callback<CreateDistributionResult>): Request<CreateDistributionResult>;
  getDistribution(params: GetDistributionRequest, callback?: Callback<GetDistributionResult>): Request<GetDistributionResult>;
  updateDistribution(params: UpdateDistributionRequest, callback?: Callback<UpdateDistributionResult>): Request<UpdateDistributionResult>;
  deleteDistribution(params: DeleteDistributionRequest, callback?: Callback): Request<{}>;
  listDistributions(params?: ListDistributionsRequest, callback?: Callback<ListDistributionsResult>): Request<ListDistributionsResult>;
  
  // Invalidation management
  createInvalidation(params: CreateInvalidationRequest, callback?: Callback<CreateInvalidationResult>): Request<CreateInvalidationResult>;
  getInvalidation(params: GetInvalidationRequest, callback?: Callback<GetInvalidationResult>): Request<GetInvalidationResult>;
  listInvalidations(params: ListInvalidationsRequest, callback?: Callback<ListInvalidationsResult>): Request<ListInvalidationsResult>;
}

const cloudfront = new AWS.CloudFront();

CloudFront Specialized Utilities

CloudFront URL Signer:

class CloudFront.Signer {
  constructor(keyPairId: string, privateKey: string | Buffer);
  
  // Properties
  keyPairId: string;
  
  // Methods
  getSignedUrl(options: {
    url: string;
    expires?: number | Date;
    policy?: string;
  }): string;
  
  getSignedCookie(options: {
    url: string;
    expires?: number | Date;
    policy?: string;
  }): {
    'CloudFront-Policy': string;
    'CloudFront-Signature': string;
    'CloudFront-Key-Pair-Id': string;
  };
  
  // Static methods
  static getSignedUrl(url: string, options: {
    keypairId: string;
    privateKeyString?: string;
    privateKeyPath?: string;
    expires?: number | Date;
    policy?: string;
  }): string;
  
  static getSignedCookie(url: string, options: {
    keypairId: string;
    privateKeyString?: string;
    privateKeyPath?: string;
    expires?: number | Date;
    policy?: string;
  }): object;
}

// Sign URLs for private CloudFront content
const privateKey = fs.readFileSync('path/to/private-key.pem');
const signer = new AWS.CloudFront.Signer('KEYPAIRID', privateKey);

// Create signed URL with expiration
const signedUrl = signer.getSignedUrl({
  url: 'https://d123456789.cloudfront.net/private-content.pdf',
  expires: Math.floor((Date.now() + 3600000) / 1000) // 1 hour from now
});

// Create signed cookies for access to multiple files
const signedCookies = signer.getSignedCookie({
  url: 'https://d123456789.cloudfront.net/private/*',
  expires: Math.floor((Date.now() + 3600000) / 1000)
});

// Static method usage
const staticSignedUrl = AWS.CloudFront.Signer.getSignedUrl(
  'https://d123456789.cloudfront.net/private-content.pdf',
  {
    keypairId: 'KEYPAIRID',
    privateKeyPath: 'path/to/private-key.pem',
    expires: Math.floor((Date.now() + 3600000) / 1000)
  }
);

Complete Service List

The AWS SDK includes clients for all 387 AWS services. Here are the remaining major categories:

Security & Identity Services

IAM - Identity and Access Management
STS - Security Token Service
KMS - Key Management Service
SecretsManager - AWS Secrets Manager
CognitoIdentity - Amazon Cognito Identity
CognitoIdentityServiceProvider - Amazon Cognito User Pools
GuardDuty - Amazon GuardDuty
SecurityHub - AWS Security Hub
Inspector - Amazon Inspector
WAF - AWS Web Application Firewall
Shield - AWS Shield
Organizations - AWS Organizations

Analytics & Big Data Services

EMR - Elastic MapReduce
Kinesis - Amazon Kinesis Data Streams
KinesisAnalytics - Amazon Kinesis Data Analytics
Firehose - Amazon Kinesis Data Firehose
Glue - AWS Glue
Athena - Amazon Athena
QuickSight - Amazon QuickSight
ElasticSearch - Amazon Elasticsearch Service
MSK - Amazon Managed Streaming for Apache Kafka

Machine Learning Services

SageMaker - Amazon SageMaker
Comprehend - Amazon Comprehend
Rekognition - Amazon Rekognition
Polly - Amazon Polly
Translate - Amazon Translate
Textract - Amazon Textract
Transcribe - Amazon Transcribe
Personalize - Amazon Personalize
Forecast - Amazon Forecast
Lex - Amazon Lex

Monitoring & Management

CloudWatch - Amazon CloudWatch
CloudTrail - AWS CloudTrail
Config - AWS Config
SSM - AWS Systems Manager
OpsWorks - AWS OpsWorks
ServiceCatalog - AWS Service Catalog
TrustedAdvisor - AWS Trusted Advisor
XRay - AWS X-Ray

Developer Tools

CodeCommit - AWS CodeCommit
CodeBuild - AWS CodeBuild
CodeDeploy - AWS CodeDeploy
CodePipeline - AWS CodePipeline
Cloud9 - AWS Cloud9
CodeArtifact - AWS CodeArtifact

IoT Services

IoT - AWS IoT Core
IoTData - AWS IoT Data Plane
IoTAnalytics - AWS IoT Analytics
IoTEvents - AWS IoT Events
Greengrass - AWS IoT Greengrass
IoTSiteWise - AWS IoT SiteWise

Media Services

MediaConvert - AWS Elemental MediaConvert
MediaLive - AWS Elemental MediaLive
MediaPackage - AWS Elemental MediaPackage
ElasticTranscoder - Amazon Elastic Transcoder
IVS - Amazon Interactive Video Service

End User Computing

WorkSpaces - Amazon WorkSpaces
AppStream - Amazon AppStream 2.0
WorkDocs - Amazon WorkDocs
WorkMail - Amazon WorkMail
Connect - Amazon Connect

Each service client follows the same interface pattern with service-specific operations, consistent error handling, and support for callbacks, promises, and event-driven processing.