@aws-sdk/client-storage-gateway 3.933.0 → 3.935.0

package/dist-es/models/models_0.js

@@ -1,191 +1 @@
-import { StorageGatewayServiceException as __BaseException } from "./StorageGatewayServiceException";
-export const ErrorCode = {
-    ActivationKeyExpired: "ActivationKeyExpired",
-    ActivationKeyInvalid: "ActivationKeyInvalid",
-    ActivationKeyNotFound: "ActivationKeyNotFound",
-    AuthenticationFailure: "AuthenticationFailure",
-    BandwidthThrottleScheduleNotFound: "BandwidthThrottleScheduleNotFound",
-    Blocked: "Blocked",
-    CannotExportSnapshot: "CannotExportSnapshot",
-    ChapCredentialNotFound: "ChapCredentialNotFound",
-    DiskAlreadyAllocated: "DiskAlreadyAllocated",
-    DiskDoesNotExist: "DiskDoesNotExist",
-    DiskSizeGreaterThanVolumeMaxSize: "DiskSizeGreaterThanVolumeMaxSize",
-    DiskSizeLessThanVolumeSize: "DiskSizeLessThanVolumeSize",
-    DiskSizeNotGigAligned: "DiskSizeNotGigAligned",
-    DuplicateCertificateInfo: "DuplicateCertificateInfo",
-    DuplicateSchedule: "DuplicateSchedule",
-    EndpointNotFound: "EndpointNotFound",
-    GatewayInternalError: "GatewayInternalError",
-    GatewayNotConnected: "GatewayNotConnected",
-    GatewayNotFound: "GatewayNotFound",
-    GatewayProxyNetworkConnectionBusy: "GatewayProxyNetworkConnectionBusy",
-    IAMNotSupported: "IAMNotSupported",
-    InitiatorInvalid: "InitiatorInvalid",
-    InitiatorNotFound: "InitiatorNotFound",
-    InternalError: "InternalError",
-    InvalidEndpoint: "InvalidEndpoint",
-    InvalidGateway: "InvalidGateway",
-    InvalidParameters: "InvalidParameters",
-    InvalidSchedule: "InvalidSchedule",
-    JoinDomainInProgress: "JoinDomainInProgress",
-    LocalStorageLimitExceeded: "LocalStorageLimitExceeded",
-    LunAlreadyAllocated_: "LunAlreadyAllocated ",
-    LunInvalid: "LunInvalid",
-    MaximumContentLengthExceeded: "MaximumContentLengthExceeded",
-    MaximumTapeCartridgeCountExceeded: "MaximumTapeCartridgeCountExceeded",
-    MaximumVolumeCountExceeded: "MaximumVolumeCountExceeded",
-    NetworkConfigurationChanged: "NetworkConfigurationChanged",
-    NoDisksAvailable: "NoDisksAvailable",
-    NotImplemented: "NotImplemented",
-    NotSupported: "NotSupported",
-    OperationAborted: "OperationAborted",
-    OutdatedGateway: "OutdatedGateway",
-    ParametersNotImplemented: "ParametersNotImplemented",
-    RegionInvalid: "RegionInvalid",
-    RequestTimeout: "RequestTimeout",
-    ServiceUnavailable: "ServiceUnavailable",
-    SnapshotDeleted: "SnapshotDeleted",
-    SnapshotIdInvalid: "SnapshotIdInvalid",
-    SnapshotInProgress: "SnapshotInProgress",
-    SnapshotNotFound: "SnapshotNotFound",
-    SnapshotScheduleNotFound: "SnapshotScheduleNotFound",
-    StagingAreaFull: "StagingAreaFull",
-    StorageFailure: "StorageFailure",
-    TapeCartridgeNotFound: "TapeCartridgeNotFound",
-    TargetAlreadyExists: "TargetAlreadyExists",
-    TargetInvalid: "TargetInvalid",
-    TargetNotFound: "TargetNotFound",
-    UnauthorizedOperation: "UnauthorizedOperation",
-    VolumeAlreadyExists: "VolumeAlreadyExists",
-    VolumeIdInvalid: "VolumeIdInvalid",
-    VolumeInUse: "VolumeInUse",
-    VolumeNotFound: "VolumeNotFound",
-    VolumeNotReady: "VolumeNotReady",
-};
-export class InternalServerError extends __BaseException {
-    name = "InternalServerError";
-    $fault = "server";
-    error;
-    constructor(opts) {
-        super({
-            name: "InternalServerError",
-            $fault: "server",
-            ...opts,
-        });
-        Object.setPrototypeOf(this, InternalServerError.prototype);
-        this.error = opts.error;
-    }
-}
-export class InvalidGatewayRequestException extends __BaseException {
-    name = "InvalidGatewayRequestException";
-    $fault = "client";
-    error;
-    constructor(opts) {
-        super({
-            name: "InvalidGatewayRequestException",
-            $fault: "client",
-            ...opts,
-        });
-        Object.setPrototypeOf(this, InvalidGatewayRequestException.prototype);
-        this.error = opts.error;
-    }
-}
-export const ActiveDirectoryStatus = {
-    ACCESS_DENIED: "ACCESS_DENIED",
-    DETACHED: "DETACHED",
-    INSUFFICIENT_PERMISSIONS: "INSUFFICIENT_PERMISSIONS",
-    JOINED: "JOINED",
-    JOINING: "JOINING",
-    NETWORK_ERROR: "NETWORK_ERROR",
-    TIMEOUT: "TIMEOUT",
-    UNKNOWN_ERROR: "UNKNOWN_ERROR",
-};
-export const AutomaticUpdatePolicy = {
-    ALL_VERSIONS: "ALL_VERSIONS",
-    EMERGENCY_VERSIONS_ONLY: "EMERGENCY_VERSIONS_ONLY",
-};
-export const AvailabilityMonitorTestStatus = {
-    COMPLETE: "COMPLETE",
-    FAILED: "FAILED",
-    PENDING: "PENDING",
-};
-export const CacheReportFilterName = {
-    UploadFailureReason: "UploadFailureReason",
-    UploadState: "UploadState",
-};
-export const CacheReportStatus = {
-    CANCELED: "CANCELED",
-    COMPLETED: "COMPLETED",
-    ERROR: "ERROR",
-    FAILED: "FAILED",
-    IN_PROGRESS: "IN_PROGRESS",
-};
-export const CaseSensitivity = {
-    CaseSensitive: "CaseSensitive",
-    ClientSpecified: "ClientSpecified",
-};
-export const EncryptionType = {
-    DsseKms: "DsseKms",
-    SseKms: "SseKms",
-    SseS3: "SseS3",
-};
-export const ObjectACL = {
-    authenticated_read: "authenticated-read",
-    aws_exec_read: "aws-exec-read",
-    bucket_owner_full_control: "bucket-owner-full-control",
-    bucket_owner_read: "bucket-owner-read",
-    private: "private",
-    public_read: "public-read",
-    public_read_write: "public-read-write",
-};
-export class ServiceUnavailableError extends __BaseException {
-    name = "ServiceUnavailableError";
-    $fault = "server";
-    error;
-    constructor(opts) {
-        super({
-            name: "ServiceUnavailableError",
-            $fault: "server",
-            ...opts,
-        });
-        Object.setPrototypeOf(this, ServiceUnavailableError.prototype);
-        this.error = opts.error;
-    }
-}
-export const RetentionLockType = {
-    COMPLIANCE: "COMPLIANCE",
-    GOVERNANCE: "GOVERNANCE",
-    NONE: "NONE",
-};
-export const TapeStorageClass = {
-    DEEP_ARCHIVE: "DEEP_ARCHIVE",
-    GLACIER: "GLACIER",
-};
-export const GatewayCapacity = {
-    Large: "Large",
-    Medium: "Medium",
-    Small: "Small",
-};
-export const HostEnvironment = {
-    EC2: "EC2",
-    HYPER_V: "HYPER-V",
-    KVM: "KVM",
-    OTHER: "OTHER",
-    SNOWBALL: "SNOWBALL",
-    VMWARE: "VMWARE",
-};
-export const SMBSecurityStrategy = {
-    ClientSpecified: "ClientSpecified",
-    MandatoryEncryption: "MandatoryEncryption",
-    MandatoryEncryptionNoAes128: "MandatoryEncryptionNoAes128",
-    MandatorySigning: "MandatorySigning",
-};
-export const FileShareType = {
-    NFS: "NFS",
-    SMB: "SMB",
-};
-export const PoolStatus = {
-    ACTIVE: "ACTIVE",
-    DELETED: "DELETED",
-};
+export {};

package/dist-es/schemas/schemas_0.js

@@ -565,7 +565,7 @@ const _s = "server";
 const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.storagegateway";
 const n0 = "com.amazonaws.storagegateway";
 import { TypeRegistry } from "@smithy/core/schema";
-import { InternalServerError as __InternalServerError, InvalidGatewayRequestException as __InvalidGatewayRequestException, ServiceUnavailableError as __ServiceUnavailableError, } from "../models/index";
+import { InternalServerError as __InternalServerError, InvalidGatewayRequestException as __InvalidGatewayRequestException, ServiceUnavailableError as __ServiceUnavailableError, } from "../models/errors";
 import { StorageGatewayServiceException as __StorageGatewayServiceException } from "../models/StorageGatewayServiceException";
 export var ChapSecret = [0, n0, _CS, 8, 0];
 export var DomainUserPassword = [0, n0, _DUP, 8, 0];

package/dist-types/index.d.ts

@@ -73,5 +73,7 @@ export type { RuntimeExtension } from "./runtimeExtensions";
 export type { StorageGatewayExtensionConfiguration } from "./extensionConfiguration";
 export * from "./commands";
 export * from "./pagination";
-export * from "./models";
+export * from "./models/enums";
+export * from "./models/errors";
+export type * from "./models/models_0";
 export { StorageGatewayServiceException } from "./models/StorageGatewayServiceException";

package/dist-types/models/enums.d.ts

@@ -0,0 +1,276 @@
+/**
+ * @public
+ * @enum
+ */
+export declare const ErrorCode: {
+    readonly ActivationKeyExpired: "ActivationKeyExpired";
+    readonly ActivationKeyInvalid: "ActivationKeyInvalid";
+    readonly ActivationKeyNotFound: "ActivationKeyNotFound";
+    readonly AuthenticationFailure: "AuthenticationFailure";
+    readonly BandwidthThrottleScheduleNotFound: "BandwidthThrottleScheduleNotFound";
+    readonly Blocked: "Blocked";
+    readonly CannotExportSnapshot: "CannotExportSnapshot";
+    readonly ChapCredentialNotFound: "ChapCredentialNotFound";
+    readonly DiskAlreadyAllocated: "DiskAlreadyAllocated";
+    readonly DiskDoesNotExist: "DiskDoesNotExist";
+    readonly DiskSizeGreaterThanVolumeMaxSize: "DiskSizeGreaterThanVolumeMaxSize";
+    readonly DiskSizeLessThanVolumeSize: "DiskSizeLessThanVolumeSize";
+    readonly DiskSizeNotGigAligned: "DiskSizeNotGigAligned";
+    readonly DuplicateCertificateInfo: "DuplicateCertificateInfo";
+    readonly DuplicateSchedule: "DuplicateSchedule";
+    readonly EndpointNotFound: "EndpointNotFound";
+    readonly GatewayInternalError: "GatewayInternalError";
+    readonly GatewayNotConnected: "GatewayNotConnected";
+    readonly GatewayNotFound: "GatewayNotFound";
+    readonly GatewayProxyNetworkConnectionBusy: "GatewayProxyNetworkConnectionBusy";
+    readonly IAMNotSupported: "IAMNotSupported";
+    readonly InitiatorInvalid: "InitiatorInvalid";
+    readonly InitiatorNotFound: "InitiatorNotFound";
+    readonly InternalError: "InternalError";
+    readonly InvalidEndpoint: "InvalidEndpoint";
+    readonly InvalidGateway: "InvalidGateway";
+    readonly InvalidParameters: "InvalidParameters";
+    readonly InvalidSchedule: "InvalidSchedule";
+    readonly JoinDomainInProgress: "JoinDomainInProgress";
+    readonly LocalStorageLimitExceeded: "LocalStorageLimitExceeded";
+    readonly LunAlreadyAllocated_: "LunAlreadyAllocated ";
+    readonly LunInvalid: "LunInvalid";
+    readonly MaximumContentLengthExceeded: "MaximumContentLengthExceeded";
+    readonly MaximumTapeCartridgeCountExceeded: "MaximumTapeCartridgeCountExceeded";
+    readonly MaximumVolumeCountExceeded: "MaximumVolumeCountExceeded";
+    readonly NetworkConfigurationChanged: "NetworkConfigurationChanged";
+    readonly NoDisksAvailable: "NoDisksAvailable";
+    readonly NotImplemented: "NotImplemented";
+    readonly NotSupported: "NotSupported";
+    readonly OperationAborted: "OperationAborted";
+    readonly OutdatedGateway: "OutdatedGateway";
+    readonly ParametersNotImplemented: "ParametersNotImplemented";
+    readonly RegionInvalid: "RegionInvalid";
+    readonly RequestTimeout: "RequestTimeout";
+    readonly ServiceUnavailable: "ServiceUnavailable";
+    readonly SnapshotDeleted: "SnapshotDeleted";
+    readonly SnapshotIdInvalid: "SnapshotIdInvalid";
+    readonly SnapshotInProgress: "SnapshotInProgress";
+    readonly SnapshotNotFound: "SnapshotNotFound";
+    readonly SnapshotScheduleNotFound: "SnapshotScheduleNotFound";
+    readonly StagingAreaFull: "StagingAreaFull";
+    readonly StorageFailure: "StorageFailure";
+    readonly TapeCartridgeNotFound: "TapeCartridgeNotFound";
+    readonly TargetAlreadyExists: "TargetAlreadyExists";
+    readonly TargetInvalid: "TargetInvalid";
+    readonly TargetNotFound: "TargetNotFound";
+    readonly UnauthorizedOperation: "UnauthorizedOperation";
+    readonly VolumeAlreadyExists: "VolumeAlreadyExists";
+    readonly VolumeIdInvalid: "VolumeIdInvalid";
+    readonly VolumeInUse: "VolumeInUse";
+    readonly VolumeNotFound: "VolumeNotFound";
+    readonly VolumeNotReady: "VolumeNotReady";
+};
+/**
+ * @public
+ */
+export type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];
+/**
+ * @public
+ * @enum
+ */
+export declare const ActiveDirectoryStatus: {
+    readonly ACCESS_DENIED: "ACCESS_DENIED";
+    readonly DETACHED: "DETACHED";
+    readonly INSUFFICIENT_PERMISSIONS: "INSUFFICIENT_PERMISSIONS";
+    readonly JOINED: "JOINED";
+    readonly JOINING: "JOINING";
+    readonly NETWORK_ERROR: "NETWORK_ERROR";
+    readonly TIMEOUT: "TIMEOUT";
+    readonly UNKNOWN_ERROR: "UNKNOWN_ERROR";
+};
+/**
+ * @public
+ */
+export type ActiveDirectoryStatus = (typeof ActiveDirectoryStatus)[keyof typeof ActiveDirectoryStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const AutomaticUpdatePolicy: {
+    readonly ALL_VERSIONS: "ALL_VERSIONS";
+    readonly EMERGENCY_VERSIONS_ONLY: "EMERGENCY_VERSIONS_ONLY";
+};
+/**
+ * @public
+ */
+export type AutomaticUpdatePolicy = (typeof AutomaticUpdatePolicy)[keyof typeof AutomaticUpdatePolicy];
+/**
+ * @public
+ * @enum
+ */
+export declare const AvailabilityMonitorTestStatus: {
+    readonly COMPLETE: "COMPLETE";
+    readonly FAILED: "FAILED";
+    readonly PENDING: "PENDING";
+};
+/**
+ * @public
+ */
+export type AvailabilityMonitorTestStatus = (typeof AvailabilityMonitorTestStatus)[keyof typeof AvailabilityMonitorTestStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const CacheReportFilterName: {
+    readonly UploadFailureReason: "UploadFailureReason";
+    readonly UploadState: "UploadState";
+};
+/**
+ * @public
+ */
+export type CacheReportFilterName = (typeof CacheReportFilterName)[keyof typeof CacheReportFilterName];
+/**
+ * @public
+ * @enum
+ */
+export declare const CacheReportStatus: {
+    readonly CANCELED: "CANCELED";
+    readonly COMPLETED: "COMPLETED";
+    readonly ERROR: "ERROR";
+    readonly FAILED: "FAILED";
+    readonly IN_PROGRESS: "IN_PROGRESS";
+};
+/**
+ * @public
+ */
+export type CacheReportStatus = (typeof CacheReportStatus)[keyof typeof CacheReportStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const CaseSensitivity: {
+    readonly CaseSensitive: "CaseSensitive";
+    readonly ClientSpecified: "ClientSpecified";
+};
+/**
+ * @public
+ */
+export type CaseSensitivity = (typeof CaseSensitivity)[keyof typeof CaseSensitivity];
+/**
+ * @public
+ * @enum
+ */
+export declare const EncryptionType: {
+    readonly DsseKms: "DsseKms";
+    readonly SseKms: "SseKms";
+    readonly SseS3: "SseS3";
+};
+/**
+ * @public
+ */
+export type EncryptionType = (typeof EncryptionType)[keyof typeof EncryptionType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ObjectACL: {
+    readonly authenticated_read: "authenticated-read";
+    readonly aws_exec_read: "aws-exec-read";
+    readonly bucket_owner_full_control: "bucket-owner-full-control";
+    readonly bucket_owner_read: "bucket-owner-read";
+    readonly private: "private";
+    readonly public_read: "public-read";
+    readonly public_read_write: "public-read-write";
+};
+/**
+ * @public
+ */
+export type ObjectACL = (typeof ObjectACL)[keyof typeof ObjectACL];
+/**
+ * @public
+ * @enum
+ */
+export declare const RetentionLockType: {
+    readonly COMPLIANCE: "COMPLIANCE";
+    readonly GOVERNANCE: "GOVERNANCE";
+    readonly NONE: "NONE";
+};
+/**
+ * @public
+ */
+export type RetentionLockType = (typeof RetentionLockType)[keyof typeof RetentionLockType];
+/**
+ * @public
+ * @enum
+ */
+export declare const TapeStorageClass: {
+    readonly DEEP_ARCHIVE: "DEEP_ARCHIVE";
+    readonly GLACIER: "GLACIER";
+};
+/**
+ * @public
+ */
+export type TapeStorageClass = (typeof TapeStorageClass)[keyof typeof TapeStorageClass];
+/**
+ * @public
+ * @enum
+ */
+export declare const GatewayCapacity: {
+    readonly Large: "Large";
+    readonly Medium: "Medium";
+    readonly Small: "Small";
+};
+/**
+ * @public
+ */
+export type GatewayCapacity = (typeof GatewayCapacity)[keyof typeof GatewayCapacity];
+/**
+ * @public
+ * @enum
+ */
+export declare const HostEnvironment: {
+    readonly EC2: "EC2";
+    readonly HYPER_V: "HYPER-V";
+    readonly KVM: "KVM";
+    readonly OTHER: "OTHER";
+    readonly SNOWBALL: "SNOWBALL";
+    readonly VMWARE: "VMWARE";
+};
+/**
+ * @public
+ */
+export type HostEnvironment = (typeof HostEnvironment)[keyof typeof HostEnvironment];
+/**
+ * @public
+ * @enum
+ */
+export declare const SMBSecurityStrategy: {
+    readonly ClientSpecified: "ClientSpecified";
+    readonly MandatoryEncryption: "MandatoryEncryption";
+    readonly MandatoryEncryptionNoAes128: "MandatoryEncryptionNoAes128";
+    readonly MandatorySigning: "MandatorySigning";
+};
+/**
+ * @public
+ */
+export type SMBSecurityStrategy = (typeof SMBSecurityStrategy)[keyof typeof SMBSecurityStrategy];
+/**
+ * @public
+ * @enum
+ */
+export declare const FileShareType: {
+    readonly NFS: "NFS";
+    readonly SMB: "SMB";
+};
+/**
+ * @public
+ */
+export type FileShareType = (typeof FileShareType)[keyof typeof FileShareType];
+/**
+ * @public
+ * @enum
+ */
+export declare const PoolStatus: {
+    readonly ACTIVE: "ACTIVE";
+    readonly DELETED: "DELETED";
+};
+/**
+ * @public
+ */
+export type PoolStatus = (typeof PoolStatus)[keyof typeof PoolStatus];

package/dist-types/models/errors.d.ts

@@ -0,0 +1,60 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { StorageGatewayError } from "./models_0";
+import { StorageGatewayServiceException as __BaseException } from "./StorageGatewayServiceException";
+/**
+ * <p>An internal server error has occurred during the request. For more information, see the
+ *          error and message fields.</p>
+ * @public
+ */
+export declare class InternalServerError extends __BaseException {
+    readonly name: "InternalServerError";
+    readonly $fault: "server";
+    /**
+     * <p>A <a>StorageGatewayError</a> that provides more information about the cause
+     *          of the error.</p>
+     * @public
+     */
+    error?: StorageGatewayError | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InternalServerError, __BaseException>);
+}
+/**
+ * <p>An exception occurred because an invalid gateway request was issued to the service. For
+ *          more information, see the error and message fields.</p>
+ * @public
+ */
+export declare class InvalidGatewayRequestException extends __BaseException {
+    readonly name: "InvalidGatewayRequestException";
+    readonly $fault: "client";
+    /**
+     * <p>A <a>StorageGatewayError</a> that provides more detail about the cause of the
+     *          error.</p>
+     * @public
+     */
+    error?: StorageGatewayError | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidGatewayRequestException, __BaseException>);
+}
+/**
+ * <p>An internal server error has occurred because the service is unavailable. For more
+ *          information, see the error and message fields.</p>
+ * @public
+ */
+export declare class ServiceUnavailableError extends __BaseException {
+    readonly name: "ServiceUnavailableError";
+    readonly $fault: "server";
+    /**
+     * <p>A <a>StorageGatewayError</a> that provides more information about the cause
+     *          of the error.</p>
+     * @public
+     */
+    error?: StorageGatewayError | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ServiceUnavailableError, __BaseException>);
+}