@aws-sdk/client-codeartifact 3.50.0 → 3.53.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,1288 @@
+
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { Readable } from "stream";
+import { CodeartifactServiceException as __BaseException } from "./CodeartifactServiceException";
+
+export declare class AccessDeniedException extends __BaseException {
+    readonly name: "AccessDeniedException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<AccessDeniedException, __BaseException>);
+}
+export declare enum HashAlgorithm {
+    MD5 = "MD5",
+    SHA1 = "SHA-1",
+    SHA256 = "SHA-256",
+    SHA512 = "SHA-512"
+}
+
+export interface AssetSummary {
+    
+    name: string | undefined;
+    
+    size?: number;
+    
+    hashes?: {
+        [key: string]: string;
+    };
+}
+export declare namespace AssetSummary {
+    
+    const filterSensitiveLog: (obj: AssetSummary) => any;
+}
+export interface AssociateExternalConnectionRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+    
+    repository: string | undefined;
+    
+    externalConnection: string | undefined;
+}
+export declare namespace AssociateExternalConnectionRequest {
+    
+    const filterSensitiveLog: (obj: AssociateExternalConnectionRequest) => any;
+}
+export declare enum PackageFormat {
+    MAVEN = "maven",
+    NPM = "npm",
+    NUGET = "nuget",
+    PYPI = "pypi"
+}
+export declare enum ExternalConnectionStatus {
+    AVAILABLE = "Available"
+}
+
+export interface RepositoryExternalConnectionInfo {
+    
+    externalConnectionName?: string;
+    
+    packageFormat?: PackageFormat | string;
+    
+    status?: ExternalConnectionStatus | string;
+}
+export declare namespace RepositoryExternalConnectionInfo {
+    
+    const filterSensitiveLog: (obj: RepositoryExternalConnectionInfo) => any;
+}
+
+export interface UpstreamRepositoryInfo {
+    
+    repositoryName?: string;
+}
+export declare namespace UpstreamRepositoryInfo {
+    
+    const filterSensitiveLog: (obj: UpstreamRepositoryInfo) => any;
+}
+
+export interface RepositoryDescription {
+    
+    name?: string;
+    
+    administratorAccount?: string;
+    
+    domainName?: string;
+    
+    domainOwner?: string;
+    
+    arn?: string;
+    
+    description?: string;
+    
+    upstreams?: UpstreamRepositoryInfo[];
+    
+    externalConnections?: RepositoryExternalConnectionInfo[];
+}
+export declare namespace RepositoryDescription {
+    
+    const filterSensitiveLog: (obj: RepositoryDescription) => any;
+}
+export interface AssociateExternalConnectionResult {
+    
+    repository?: RepositoryDescription;
+}
+export declare namespace AssociateExternalConnectionResult {
+    
+    const filterSensitiveLog: (obj: AssociateExternalConnectionResult) => any;
+}
+export declare enum ResourceType {
+    ASSET = "asset",
+    DOMAIN = "domain",
+    PACKAGE = "package",
+    PACKAGE_VERSION = "package-version",
+    REPOSITORY = "repository"
+}
+
+export declare class ConflictException extends __BaseException {
+    readonly name: "ConflictException";
+    readonly $fault: "client";
+    
+    resourceId?: string;
+    
+    resourceType?: ResourceType | string;
+    
+    constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
+}
+
+export declare class InternalServerException extends __BaseException {
+    readonly name: "InternalServerException";
+    readonly $fault: "server";
+    
+    constructor(opts: __ExceptionOptionType<InternalServerException, __BaseException>);
+}
+
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    
+    resourceId?: string;
+    
+    resourceType?: ResourceType | string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+
+export declare class ServiceQuotaExceededException extends __BaseException {
+    readonly name: "ServiceQuotaExceededException";
+    readonly $fault: "client";
+    
+    resourceId?: string;
+    
+    resourceType?: ResourceType | string;
+    
+    constructor(opts: __ExceptionOptionType<ServiceQuotaExceededException, __BaseException>);
+}
+
+export declare class ThrottlingException extends __BaseException {
+    readonly name: "ThrottlingException";
+    readonly $fault: "client";
+    
+    retryAfterSeconds?: number;
+    
+    constructor(opts: __ExceptionOptionType<ThrottlingException, __BaseException>);
+}
+export declare enum ValidationExceptionReason {
+    CANNOT_PARSE = "CANNOT_PARSE",
+    ENCRYPTION_KEY_ERROR = "ENCRYPTION_KEY_ERROR",
+    FIELD_VALIDATION_FAILED = "FIELD_VALIDATION_FAILED",
+    OTHER = "OTHER",
+    UNKNOWN_OPERATION = "UNKNOWN_OPERATION"
+}
+
+export declare class ValidationException extends __BaseException {
+    readonly name: "ValidationException";
+    readonly $fault: "client";
+    
+    reason?: ValidationExceptionReason | string;
+    
+    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
+}
+export interface CopyPackageVersionsRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+    
+    sourceRepository: string | undefined;
+    
+    destinationRepository: string | undefined;
+    
+    format: PackageFormat | string | undefined;
+    
+    namespace?: string;
+    
+    package: string | undefined;
+    
+    versions?: string[];
+    
+    versionRevisions?: {
+        [key: string]: string;
+    };
+    
+    allowOverwrite?: boolean;
+    
+    includeFromUpstream?: boolean;
+}
+export declare namespace CopyPackageVersionsRequest {
+    
+    const filterSensitiveLog: (obj: CopyPackageVersionsRequest) => any;
+}
+export declare enum PackageVersionErrorCode {
+    ALREADY_EXISTS = "ALREADY_EXISTS",
+    MISMATCHED_REVISION = "MISMATCHED_REVISION",
+    MISMATCHED_STATUS = "MISMATCHED_STATUS",
+    NOT_ALLOWED = "NOT_ALLOWED",
+    NOT_FOUND = "NOT_FOUND",
+    SKIPPED = "SKIPPED"
+}
+
+export interface PackageVersionError {
+    
+    errorCode?: PackageVersionErrorCode | string;
+    
+    errorMessage?: string;
+}
+export declare namespace PackageVersionError {
+    
+    const filterSensitiveLog: (obj: PackageVersionError) => any;
+}
+export declare enum PackageVersionStatus {
+    ARCHIVED = "Archived",
+    DELETED = "Deleted",
+    DISPOSED = "Disposed",
+    PUBLISHED = "Published",
+    UNFINISHED = "Unfinished",
+    UNLISTED = "Unlisted"
+}
+
+export interface SuccessfulPackageVersionInfo {
+    
+    revision?: string;
+    
+    status?: PackageVersionStatus | string;
+}
+export declare namespace SuccessfulPackageVersionInfo {
+    
+    const filterSensitiveLog: (obj: SuccessfulPackageVersionInfo) => any;
+}
+export interface CopyPackageVersionsResult {
+    
+    successfulVersions?: {
+        [key: string]: SuccessfulPackageVersionInfo;
+    };
+    
+    failedVersions?: {
+        [key: string]: PackageVersionError;
+    };
+}
+export declare namespace CopyPackageVersionsResult {
+    
+    const filterSensitiveLog: (obj: CopyPackageVersionsResult) => any;
+}
+
+export interface Tag {
+    
+    key: string | undefined;
+    
+    value: string | undefined;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+export interface CreateDomainRequest {
+    
+    domain: string | undefined;
+    
+    encryptionKey?: string;
+    
+    tags?: Tag[];
+}
+export declare namespace CreateDomainRequest {
+    
+    const filterSensitiveLog: (obj: CreateDomainRequest) => any;
+}
+export declare enum DomainStatus {
+    ACTIVE = "Active",
+    DELETED = "Deleted"
+}
+
+export interface DomainDescription {
+    
+    name?: string;
+    
+    owner?: string;
+    
+    arn?: string;
+    
+    status?: DomainStatus | string;
+    
+    createdTime?: Date;
+    
+    encryptionKey?: string;
+    
+    repositoryCount?: number;
+    
+    assetSizeBytes?: number;
+    
+    s3BucketArn?: string;
+}
+export declare namespace DomainDescription {
+    
+    const filterSensitiveLog: (obj: DomainDescription) => any;
+}
+export interface CreateDomainResult {
+    
+    domain?: DomainDescription;
+}
+export declare namespace CreateDomainResult {
+    
+    const filterSensitiveLog: (obj: CreateDomainResult) => any;
+}
+
+export interface UpstreamRepository {
+    
+    repositoryName: string | undefined;
+}
+export declare namespace UpstreamRepository {
+    
+    const filterSensitiveLog: (obj: UpstreamRepository) => any;
+}
+export interface CreateRepositoryRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+    
+    repository: string | undefined;
+    
+    description?: string;
+    
+    upstreams?: UpstreamRepository[];
+    
+    tags?: Tag[];
+}
+export declare namespace CreateRepositoryRequest {
+    
+    const filterSensitiveLog: (obj: CreateRepositoryRequest) => any;
+}
+export interface CreateRepositoryResult {
+    
+    repository?: RepositoryDescription;
+}
+export declare namespace CreateRepositoryResult {
+    
+    const filterSensitiveLog: (obj: CreateRepositoryResult) => any;
+}
+export interface DeleteDomainRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+}
+export declare namespace DeleteDomainRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDomainRequest) => any;
+}
+export interface DeleteDomainResult {
+    
+    domain?: DomainDescription;
+}
+export declare namespace DeleteDomainResult {
+    
+    const filterSensitiveLog: (obj: DeleteDomainResult) => any;
+}
+export interface DeleteDomainPermissionsPolicyRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+    
+    policyRevision?: string;
+}
+export declare namespace DeleteDomainPermissionsPolicyRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDomainPermissionsPolicyRequest) => any;
+}
+
+export interface ResourcePolicy {
+    
+    resourceArn?: string;
+    
+    revision?: string;
+    
+    document?: string;
+}
+export declare namespace ResourcePolicy {
+    
+    const filterSensitiveLog: (obj: ResourcePolicy) => any;
+}
+export interface DeleteDomainPermissionsPolicyResult {
+    
+    policy?: ResourcePolicy;
+}
+export declare namespace DeleteDomainPermissionsPolicyResult {
+    
+    const filterSensitiveLog: (obj: DeleteDomainPermissionsPolicyResult) => any;
+}
+export interface DeletePackageVersionsRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+    
+    repository: string | undefined;
+    
+    format: PackageFormat | string | undefined;
+    
+    namespace?: string;
+    
+    package: string | undefined;
+    
+    versions: string[] | undefined;
+    
+    expectedStatus?: PackageVersionStatus | string;
+}
+export declare namespace DeletePackageVersionsRequest {
+    
+    const filterSensitiveLog: (obj: DeletePackageVersionsRequest) => any;
+}
+export interface DeletePackageVersionsResult {
+    
+    successfulVersions?: {
+        [key: string]: SuccessfulPackageVersionInfo;
+    };
+    
+    failedVersions?: {
+        [key: string]: PackageVersionError;
+    };
+}
+export declare namespace DeletePackageVersionsResult {
+    
+    const filterSensitiveLog: (obj: DeletePackageVersionsResult) => any;
+}
+export interface DeleteRepositoryRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+    
+    repository: string | undefined;
+}
+export declare namespace DeleteRepositoryRequest {
+    
+    const filterSensitiveLog: (obj: DeleteRepositoryRequest) => any;
+}
+export interface DeleteRepositoryResult {
+    
+    repository?: RepositoryDescription;
+}
+export declare namespace DeleteRepositoryResult {
+    
+    const filterSensitiveLog: (obj: DeleteRepositoryResult) => any;
+}
+export interface DeleteRepositoryPermissionsPolicyRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+    
+    repository: string | undefined;
+    
+    policyRevision?: string;
+}
+export declare namespace DeleteRepositoryPermissionsPolicyRequest {
+    
+    const filterSensitiveLog: (obj: DeleteRepositoryPermissionsPolicyRequest) => any;
+}
+export interface DeleteRepositoryPermissionsPolicyResult {
+    
+    policy?: ResourcePolicy;
+}
+export declare namespace DeleteRepositoryPermissionsPolicyResult {
+    
+    const filterSensitiveLog: (obj: DeleteRepositoryPermissionsPolicyResult) => any;
+}
+export interface DescribeDomainRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+}
+export declare namespace DescribeDomainRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDomainRequest) => any;
+}
+export interface DescribeDomainResult {
+    
+    domain?: DomainDescription;
+}
+export declare namespace DescribeDomainResult {
+    
+    const filterSensitiveLog: (obj: DescribeDomainResult) => any;
+}
+export interface DescribePackageVersionRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+    
+    repository: string | undefined;
+    
+    format: PackageFormat | string | undefined;
+    
+    namespace?: string;
+    
+    package: string | undefined;
+    
+    packageVersion: string | undefined;
+}
+export declare namespace DescribePackageVersionRequest {
+    
+    const filterSensitiveLog: (obj: DescribePackageVersionRequest) => any;
+}
+
+export interface LicenseInfo {
+    
+    name?: string;
+    
+    url?: string;
+}
+export declare namespace LicenseInfo {
+    
+    const filterSensitiveLog: (obj: LicenseInfo) => any;
+}
+
+export interface PackageVersionDescription {
+    
+    format?: PackageFormat | string;
+    
+    namespace?: string;
+    
+    packageName?: string;
+    
+    displayName?: string;
+    
+    version?: string;
+    
+    summary?: string;
+    
+    homePage?: string;
+    
+    sourceCodeRepository?: string;
+    
+    publishedTime?: Date;
+    
+    licenses?: LicenseInfo[];
+    
+    revision?: string;
+    
+    status?: PackageVersionStatus | string;
+}
+export declare namespace PackageVersionDescription {
+    
+    const filterSensitiveLog: (obj: PackageVersionDescription) => any;
+}
+export interface DescribePackageVersionResult {
+    
+    packageVersion: PackageVersionDescription | undefined;
+}
+export declare namespace DescribePackageVersionResult {
+    
+    const filterSensitiveLog: (obj: DescribePackageVersionResult) => any;
+}
+export interface DescribeRepositoryRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+    
+    repository: string | undefined;
+}
+export declare namespace DescribeRepositoryRequest {
+    
+    const filterSensitiveLog: (obj: DescribeRepositoryRequest) => any;
+}
+export interface DescribeRepositoryResult {
+    
+    repository?: RepositoryDescription;
+}
+export declare namespace DescribeRepositoryResult {
+    
+    const filterSensitiveLog: (obj: DescribeRepositoryResult) => any;
+}
+export interface DisassociateExternalConnectionRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+    
+    repository: string | undefined;
+    
+    externalConnection: string | undefined;
+}
+export declare namespace DisassociateExternalConnectionRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateExternalConnectionRequest) => any;
+}
+export interface DisassociateExternalConnectionResult {
+    
+    repository?: RepositoryDescription;
+}
+export declare namespace DisassociateExternalConnectionResult {
+    
+    const filterSensitiveLog: (obj: DisassociateExternalConnectionResult) => any;
+}
+export interface DisposePackageVersionsRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+    
+    repository: string | undefined;
+    
+    format: PackageFormat | string | undefined;
+    
+    namespace?: string;
+    
+    package: string | undefined;
+    
+    versions: string[] | undefined;
+    
+    versionRevisions?: {
+        [key: string]: string;
+    };
+    
+    expectedStatus?: PackageVersionStatus | string;
+}
+export declare namespace DisposePackageVersionsRequest {
+    
+    const filterSensitiveLog: (obj: DisposePackageVersionsRequest) => any;
+}
+export interface DisposePackageVersionsResult {
+    
+    successfulVersions?: {
+        [key: string]: SuccessfulPackageVersionInfo;
+    };
+    
+    failedVersions?: {
+        [key: string]: PackageVersionError;
+    };
+}
+export declare namespace DisposePackageVersionsResult {
+    
+    const filterSensitiveLog: (obj: DisposePackageVersionsResult) => any;
+}
+export interface GetAuthorizationTokenRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+    
+    durationSeconds?: number;
+}
+export declare namespace GetAuthorizationTokenRequest {
+    
+    const filterSensitiveLog: (obj: GetAuthorizationTokenRequest) => any;
+}
+export interface GetAuthorizationTokenResult {
+    
+    authorizationToken?: string;
+    
+    expiration?: Date;
+}
+export declare namespace GetAuthorizationTokenResult {
+    
+    const filterSensitiveLog: (obj: GetAuthorizationTokenResult) => any;
+}
+export interface GetDomainPermissionsPolicyRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+}
+export declare namespace GetDomainPermissionsPolicyRequest {
+    
+    const filterSensitiveLog: (obj: GetDomainPermissionsPolicyRequest) => any;
+}
+export interface GetDomainPermissionsPolicyResult {
+    
+    policy?: ResourcePolicy;
+}
+export declare namespace GetDomainPermissionsPolicyResult {
+    
+    const filterSensitiveLog: (obj: GetDomainPermissionsPolicyResult) => any;
+}
+export interface GetPackageVersionAssetRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+    
+    repository: string | undefined;
+    
+    format: PackageFormat | string | undefined;
+    
+    namespace?: string;
+    
+    package: string | undefined;
+    
+    packageVersion: string | undefined;
+    
+    asset: string | undefined;
+    
+    packageVersionRevision?: string;
+}
+export declare namespace GetPackageVersionAssetRequest {
+    
+    const filterSensitiveLog: (obj: GetPackageVersionAssetRequest) => any;
+}
+export interface GetPackageVersionAssetResult {
+    
+    asset?: Readable | ReadableStream | Blob;
+    
+    assetName?: string;
+    
+    packageVersion?: string;
+    
+    packageVersionRevision?: string;
+}
+export declare namespace GetPackageVersionAssetResult {
+    
+    const filterSensitiveLog: (obj: GetPackageVersionAssetResult) => any;
+}
+export interface GetPackageVersionReadmeRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+    
+    repository: string | undefined;
+    
+    format: PackageFormat | string | undefined;
+    
+    namespace?: string;
+    
+    package: string | undefined;
+    
+    packageVersion: string | undefined;
+}
+export declare namespace GetPackageVersionReadmeRequest {
+    
+    const filterSensitiveLog: (obj: GetPackageVersionReadmeRequest) => any;
+}
+export interface GetPackageVersionReadmeResult {
+    
+    format?: PackageFormat | string;
+    
+    namespace?: string;
+    
+    package?: string;
+    
+    version?: string;
+    
+    versionRevision?: string;
+    
+    readme?: string;
+}
+export declare namespace GetPackageVersionReadmeResult {
+    
+    const filterSensitiveLog: (obj: GetPackageVersionReadmeResult) => any;
+}
+export interface GetRepositoryEndpointRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+    
+    repository: string | undefined;
+    
+    format: PackageFormat | string | undefined;
+}
+export declare namespace GetRepositoryEndpointRequest {
+    
+    const filterSensitiveLog: (obj: GetRepositoryEndpointRequest) => any;
+}
+export interface GetRepositoryEndpointResult {
+    
+    repositoryEndpoint?: string;
+}
+export declare namespace GetRepositoryEndpointResult {
+    
+    const filterSensitiveLog: (obj: GetRepositoryEndpointResult) => any;
+}
+export interface GetRepositoryPermissionsPolicyRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+    
+    repository: string | undefined;
+}
+export declare namespace GetRepositoryPermissionsPolicyRequest {
+    
+    const filterSensitiveLog: (obj: GetRepositoryPermissionsPolicyRequest) => any;
+}
+export interface GetRepositoryPermissionsPolicyResult {
+    
+    policy?: ResourcePolicy;
+}
+export declare namespace GetRepositoryPermissionsPolicyResult {
+    
+    const filterSensitiveLog: (obj: GetRepositoryPermissionsPolicyResult) => any;
+}
+export interface ListDomainsRequest {
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListDomainsRequest {
+    
+    const filterSensitiveLog: (obj: ListDomainsRequest) => any;
+}
+
+export interface DomainSummary {
+    
+    name?: string;
+    
+    owner?: string;
+    
+    arn?: string;
+    
+    status?: DomainStatus | string;
+    
+    createdTime?: Date;
+    
+    encryptionKey?: string;
+}
+export declare namespace DomainSummary {
+    
+    const filterSensitiveLog: (obj: DomainSummary) => any;
+}
+export interface ListDomainsResult {
+    
+    domains?: DomainSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListDomainsResult {
+    
+    const filterSensitiveLog: (obj: ListDomainsResult) => any;
+}
+export interface ListPackagesRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+    
+    repository: string | undefined;
+    
+    format?: PackageFormat | string;
+    
+    namespace?: string;
+    
+    packagePrefix?: string;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListPackagesRequest {
+    
+    const filterSensitiveLog: (obj: ListPackagesRequest) => any;
+}
+
+export interface PackageSummary {
+    
+    format?: PackageFormat | string;
+    
+    namespace?: string;
+    
+    package?: string;
+}
+export declare namespace PackageSummary {
+    
+    const filterSensitiveLog: (obj: PackageSummary) => any;
+}
+export interface ListPackagesResult {
+    
+    packages?: PackageSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListPackagesResult {
+    
+    const filterSensitiveLog: (obj: ListPackagesResult) => any;
+}
+export interface ListPackageVersionAssetsRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+    
+    repository: string | undefined;
+    
+    format: PackageFormat | string | undefined;
+    
+    namespace?: string;
+    
+    package: string | undefined;
+    
+    packageVersion: string | undefined;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListPackageVersionAssetsRequest {
+    
+    const filterSensitiveLog: (obj: ListPackageVersionAssetsRequest) => any;
+}
+export interface ListPackageVersionAssetsResult {
+    
+    format?: PackageFormat | string;
+    
+    namespace?: string;
+    
+    package?: string;
+    
+    version?: string;
+    
+    versionRevision?: string;
+    
+    nextToken?: string;
+    
+    assets?: AssetSummary[];
+}
+export declare namespace ListPackageVersionAssetsResult {
+    
+    const filterSensitiveLog: (obj: ListPackageVersionAssetsResult) => any;
+}
+export interface ListPackageVersionDependenciesRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+    
+    repository: string | undefined;
+    
+    format: PackageFormat | string | undefined;
+    
+    namespace?: string;
+    
+    package: string | undefined;
+    
+    packageVersion: string | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListPackageVersionDependenciesRequest {
+    
+    const filterSensitiveLog: (obj: ListPackageVersionDependenciesRequest) => any;
+}
+
+export interface PackageDependency {
+    
+    namespace?: string;
+    
+    package?: string;
+    
+    dependencyType?: string;
+    
+    versionRequirement?: string;
+}
+export declare namespace PackageDependency {
+    
+    const filterSensitiveLog: (obj: PackageDependency) => any;
+}
+export interface ListPackageVersionDependenciesResult {
+    
+    format?: PackageFormat | string;
+    
+    namespace?: string;
+    
+    package?: string;
+    
+    version?: string;
+    
+    versionRevision?: string;
+    
+    nextToken?: string;
+    
+    dependencies?: PackageDependency[];
+}
+export declare namespace ListPackageVersionDependenciesResult {
+    
+    const filterSensitiveLog: (obj: ListPackageVersionDependenciesResult) => any;
+}
+export declare enum PackageVersionSortType {
+    PUBLISHED_TIME = "PUBLISHED_TIME"
+}
+export interface ListPackageVersionsRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+    
+    repository: string | undefined;
+    
+    format: PackageFormat | string | undefined;
+    
+    namespace?: string;
+    
+    package: string | undefined;
+    
+    status?: PackageVersionStatus | string;
+    
+    sortBy?: PackageVersionSortType | string;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListPackageVersionsRequest {
+    
+    const filterSensitiveLog: (obj: ListPackageVersionsRequest) => any;
+}
+
+export interface PackageVersionSummary {
+    
+    version: string | undefined;
+    
+    revision?: string;
+    
+    status: PackageVersionStatus | string | undefined;
+}
+export declare namespace PackageVersionSummary {
+    
+    const filterSensitiveLog: (obj: PackageVersionSummary) => any;
+}
+export interface ListPackageVersionsResult {
+    
+    defaultDisplayVersion?: string;
+    
+    format?: PackageFormat | string;
+    
+    namespace?: string;
+    
+    package?: string;
+    
+    versions?: PackageVersionSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListPackageVersionsResult {
+    
+    const filterSensitiveLog: (obj: ListPackageVersionsResult) => any;
+}
+export interface ListRepositoriesRequest {
+    
+    repositoryPrefix?: string;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListRepositoriesRequest {
+    
+    const filterSensitiveLog: (obj: ListRepositoriesRequest) => any;
+}
+
+export interface RepositorySummary {
+    
+    name?: string;
+    
+    administratorAccount?: string;
+    
+    domainName?: string;
+    
+    domainOwner?: string;
+    
+    arn?: string;
+    
+    description?: string;
+}
+export declare namespace RepositorySummary {
+    
+    const filterSensitiveLog: (obj: RepositorySummary) => any;
+}
+export interface ListRepositoriesResult {
+    
+    repositories?: RepositorySummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListRepositoriesResult {
+    
+    const filterSensitiveLog: (obj: ListRepositoriesResult) => any;
+}
+export interface ListRepositoriesInDomainRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+    
+    administratorAccount?: string;
+    
+    repositoryPrefix?: string;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListRepositoriesInDomainRequest {
+    
+    const filterSensitiveLog: (obj: ListRepositoriesInDomainRequest) => any;
+}
+export interface ListRepositoriesInDomainResult {
+    
+    repositories?: RepositorySummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListRepositoriesInDomainResult {
+    
+    const filterSensitiveLog: (obj: ListRepositoriesInDomainResult) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    resourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResult {
+    
+    tags?: Tag[];
+}
+export declare namespace ListTagsForResourceResult {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResult) => any;
+}
+export interface PutDomainPermissionsPolicyRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+    
+    policyRevision?: string;
+    
+    policyDocument: string | undefined;
+}
+export declare namespace PutDomainPermissionsPolicyRequest {
+    
+    const filterSensitiveLog: (obj: PutDomainPermissionsPolicyRequest) => any;
+}
+export interface PutDomainPermissionsPolicyResult {
+    
+    policy?: ResourcePolicy;
+}
+export declare namespace PutDomainPermissionsPolicyResult {
+    
+    const filterSensitiveLog: (obj: PutDomainPermissionsPolicyResult) => any;
+}
+export interface PutRepositoryPermissionsPolicyRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+    
+    repository: string | undefined;
+    
+    policyRevision?: string;
+    
+    policyDocument: string | undefined;
+}
+export declare namespace PutRepositoryPermissionsPolicyRequest {
+    
+    const filterSensitiveLog: (obj: PutRepositoryPermissionsPolicyRequest) => any;
+}
+export interface PutRepositoryPermissionsPolicyResult {
+    
+    policy?: ResourcePolicy;
+}
+export declare namespace PutRepositoryPermissionsPolicyResult {
+    
+    const filterSensitiveLog: (obj: PutRepositoryPermissionsPolicyResult) => any;
+}
+export interface TagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tags: Tag[] | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResult {
+}
+export declare namespace TagResourceResult {
+    
+    const filterSensitiveLog: (obj: TagResourceResult) => any;
+}
+export interface UntagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResult {
+}
+export declare namespace UntagResourceResult {
+    
+    const filterSensitiveLog: (obj: UntagResourceResult) => any;
+}
+export interface UpdatePackageVersionsStatusRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+    
+    repository: string | undefined;
+    
+    format: PackageFormat | string | undefined;
+    
+    namespace?: string;
+    
+    package: string | undefined;
+    
+    versions: string[] | undefined;
+    
+    versionRevisions?: {
+        [key: string]: string;
+    };
+    
+    expectedStatus?: PackageVersionStatus | string;
+    
+    targetStatus: PackageVersionStatus | string | undefined;
+}
+export declare namespace UpdatePackageVersionsStatusRequest {
+    
+    const filterSensitiveLog: (obj: UpdatePackageVersionsStatusRequest) => any;
+}
+export interface UpdatePackageVersionsStatusResult {
+    
+    successfulVersions?: {
+        [key: string]: SuccessfulPackageVersionInfo;
+    };
+    
+    failedVersions?: {
+        [key: string]: PackageVersionError;
+    };
+}
+export declare namespace UpdatePackageVersionsStatusResult {
+    
+    const filterSensitiveLog: (obj: UpdatePackageVersionsStatusResult) => any;
+}
+export interface UpdateRepositoryRequest {
+    
+    domain: string | undefined;
+    
+    domainOwner?: string;
+    
+    repository: string | undefined;
+    
+    description?: string;
+    
+    upstreams?: UpstreamRepository[];
+}
+export declare namespace UpdateRepositoryRequest {
+    
+    const filterSensitiveLog: (obj: UpdateRepositoryRequest) => any;
+}
+export interface UpdateRepositoryResult {
+    
+    repository?: RepositoryDescription;
+}
+export declare namespace UpdateRepositoryResult {
+    
+    const filterSensitiveLog: (obj: UpdateRepositoryResult) => any;
+}