@hanzo/s3 0.6.3 → 8.0.7

package/dist/esm/notification.d.mts

@@ -0,0 +1,58 @@
+import { EventEmitter } from 'eventemitter3';
+import type { TypedClient } from "./internal/client.mjs";
+type Event = unknown;
+export declare class TargetConfig {
+  private Filter?;
+  private Event?;
+  private Id;
+  setId(id: unknown): void;
+  addEvent(newevent: Event): void;
+  addFilterSuffix(suffix: string): void;
+  addFilterPrefix(prefix: string): void;
+}
+export declare class TopicConfig extends TargetConfig {
+  private Topic;
+  constructor(arn: string);
+}
+export declare class QueueConfig extends TargetConfig {
+  private Queue;
+  constructor(arn: string);
+}
+export declare class CloudFunctionConfig extends TargetConfig {
+  private CloudFunction;
+  constructor(arn: string);
+}
+export declare class NotificationConfig {
+  private TopicConfiguration?;
+  private CloudFunctionConfiguration?;
+  private QueueConfiguration?;
+  add(target: TargetConfig): void;
+}
+export declare const buildARN: (partition: string, service: string, region: string, accountId: string, resource: string) => string;
+export declare const ObjectCreatedAll = "s3:ObjectCreated:*";
+export declare const ObjectCreatedPut = "s3:ObjectCreated:Put";
+export declare const ObjectCreatedPost = "s3:ObjectCreated:Post";
+export declare const ObjectCreatedCopy = "s3:ObjectCreated:Copy";
+export declare const ObjectCreatedCompleteMultipartUpload = "s3:ObjectCreated:CompleteMultipartUpload";
+export declare const ObjectRemovedAll = "s3:ObjectRemoved:*";
+export declare const ObjectRemovedDelete = "s3:ObjectRemoved:Delete";
+export declare const ObjectRemovedDeleteMarkerCreated = "s3:ObjectRemoved:DeleteMarkerCreated";
+export declare const ObjectReducedRedundancyLostObject = "s3:ReducedRedundancyLostObject";
+export type NotificationEvent = 's3:ObjectCreated:*' | 's3:ObjectCreated:Put' | 's3:ObjectCreated:Post' | 's3:ObjectCreated:Copy' | 's3:ObjectCreated:CompleteMultipartUpload' | 's3:ObjectRemoved:*' | 's3:ObjectRemoved:Delete' | 's3:ObjectRemoved:DeleteMarkerCreated' | 's3:ReducedRedundancyLostObject' | 's3:TestEvent' | 's3:ObjectRestore:Post' | 's3:ObjectRestore:Completed' | 's3:Replication:OperationFailedReplication' | 's3:Replication:OperationMissedThreshold' | 's3:Replication:OperationReplicatedAfterThreshold' | 's3:Replication:OperationNotTracked' | string;
+export type NotificationRecord = unknown;
+export declare class NotificationPoller extends EventEmitter<{
+  notification: (event: NotificationRecord) => void;
+  error: (error: unknown) => void;
+}> {
+  private client;
+  private bucketName;
+  private prefix;
+  private suffix;
+  private events;
+  private ending;
+  constructor(client: TypedClient, bucketName: string, prefix: string, suffix: string, events: NotificationEvent[]);
+  start(): void;
+  stop(): void;
+  checkForChanges(): void;
+}
+export {};

package/dist/esm/notification.mjs

@@ -0,0 +1,209 @@
+/*
+ * Hanzo S3 Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2016 Hanzo AI, Inc.
+ *
+ * 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.
+ */
+
+import { EventEmitter } from 'eventemitter3';
+import jsonLineParser from 'stream-json/jsonl/Parser.js';
+import { DEFAULT_REGION } from "./helpers.mjs";
+import { pipesetup, uriEscape } from "./internal/helper.mjs";
+
+// TODO: type this
+
+// Base class for three supported configs.
+export class TargetConfig {
+  setId(id) {
+    this.Id = id;
+  }
+  addEvent(newevent) {
+    if (!this.Event) {
+      this.Event = [];
+    }
+    this.Event.push(newevent);
+  }
+  addFilterSuffix(suffix) {
+    if (!this.Filter) {
+      this.Filter = {
+        S3Key: {
+          FilterRule: []
+        }
+      };
+    }
+    this.Filter.S3Key.FilterRule.push({
+      Name: 'suffix',
+      Value: suffix
+    });
+  }
+  addFilterPrefix(prefix) {
+    if (!this.Filter) {
+      this.Filter = {
+        S3Key: {
+          FilterRule: []
+        }
+      };
+    }
+    this.Filter.S3Key.FilterRule.push({
+      Name: 'prefix',
+      Value: prefix
+    });
+  }
+}
+
+// 1. Topic (simple notification service)
+export class TopicConfig extends TargetConfig {
+  constructor(arn) {
+    super();
+    this.Topic = arn;
+  }
+}
+
+// 2. Queue (simple queue service)
+export class QueueConfig extends TargetConfig {
+  constructor(arn) {
+    super();
+    this.Queue = arn;
+  }
+}
+
+// 3. CloudFront (lambda function)
+export class CloudFunctionConfig extends TargetConfig {
+  constructor(arn) {
+    super();
+    this.CloudFunction = arn;
+  }
+}
+
+// Notification config - array of target configs.
+// Target configs can be
+// 1. Topic (simple notification service)
+// 2. Queue (simple queue service)
+// 3. CloudFront (lambda function)
+export class NotificationConfig {
+  add(target) {
+    let instance;
+    if (target instanceof TopicConfig) {
+      instance = this.TopicConfiguration ?? (this.TopicConfiguration = []);
+    }
+    if (target instanceof QueueConfig) {
+      instance = this.QueueConfiguration ?? (this.QueueConfiguration = []);
+    }
+    if (target instanceof CloudFunctionConfig) {
+      instance = this.CloudFunctionConfiguration ?? (this.CloudFunctionConfiguration = []);
+    }
+    if (instance) {
+      instance.push(target);
+    }
+  }
+}
+export const buildARN = (partition, service, region, accountId, resource) => {
+  return 'arn:' + partition + ':' + service + ':' + region + ':' + accountId + ':' + resource;
+};
+export const ObjectCreatedAll = 's3:ObjectCreated:*';
+export const ObjectCreatedPut = 's3:ObjectCreated:Put';
+export const ObjectCreatedPost = 's3:ObjectCreated:Post';
+export const ObjectCreatedCopy = 's3:ObjectCreated:Copy';
+export const ObjectCreatedCompleteMultipartUpload = 's3:ObjectCreated:CompleteMultipartUpload';
+export const ObjectRemovedAll = 's3:ObjectRemoved:*';
+export const ObjectRemovedDelete = 's3:ObjectRemoved:Delete';
+export const ObjectRemovedDeleteMarkerCreated = 's3:ObjectRemoved:DeleteMarkerCreated';
+export const ObjectReducedRedundancyLostObject = 's3:ReducedRedundancyLostObject';
+
+// put string at least so auto-complete could work
+// TODO: type this
+// Poll for notifications, used in #listenBucketNotification.
+// Listening constitutes repeatedly requesting s3 whether or not any
+// changes have occurred.
+export class NotificationPoller extends EventEmitter {
+  constructor(client, bucketName, prefix, suffix, events) {
+    super();
+    this.client = client;
+    this.bucketName = bucketName;
+    this.prefix = prefix;
+    this.suffix = suffix;
+    this.events = events;
+    this.ending = false;
+  }
+
+  // Starts the polling.
+  start() {
+    this.ending = false;
+    process.nextTick(() => {
+      this.checkForChanges();
+    });
+  }
+
+  // Stops the polling.
+  stop() {
+    this.ending = true;
+  }
+  checkForChanges() {
+    // Don't continue if we're looping again but are cancelled.
+    if (this.ending) {
+      return;
+    }
+    const method = 'GET';
+    const queries = [];
+    if (this.prefix) {
+      const prefix = uriEscape(this.prefix);
+      queries.push(`prefix=${prefix}`);
+    }
+    if (this.suffix) {
+      const suffix = uriEscape(this.suffix);
+      queries.push(`suffix=${suffix}`);
+    }
+    if (this.events) {
+      this.events.forEach(s3event => queries.push('events=' + uriEscape(s3event)));
+    }
+    queries.sort();
+    let query = '';
+    if (queries.length > 0) {
+      query = `${queries.join('&')}`;
+    }
+    const region = this.client.region || DEFAULT_REGION;
+    this.client.makeRequestAsync({
+      method,
+      bucketName: this.bucketName,
+      query
+    }, '', [200], region).then(response => {
+      const asm = jsonLineParser.make();
+      pipesetup(response, asm).on('data', data => {
+        // Data is flushed periodically (every 5 seconds), so we should
+        // handle it after flushing from the JSON parser.
+        let records = data.value.Records;
+        // If null (= no records), change to an empty array.
+        if (!records) {
+          records = [];
+        }
+
+        // Iterate over the notifications and emit them individually.
+        records.forEach(record => {
+          this.emit('notification', record);
+        });
+
+        // If we're done, stop.
+        if (this.ending) {
+          response === null || response === void 0 ? void 0 : response.destroy();
+        }
+      }).on('error', e => this.emit('error', e)).on('end', () => {
+        // Do it again, if we haven't cancelled yet.
+        process.nextTick(() => {
+          this.checkForChanges();
+        });
+      });
+    }, e => {
+      return this.emit('error', e);
+    });
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["EventEmitter","jsonLineParser","DEFAULT_REGION","pipesetup","uriEscape","TargetConfig","setId","id","Id","addEvent","newevent","Event","push","addFilterSuffix","suffix","Filter","S3Key","FilterRule","Name","Value","addFilterPrefix","prefix","TopicConfig","constructor","arn","Topic","QueueConfig","Queue","CloudFunctionConfig","CloudFunction","NotificationConfig","add","target","instance","TopicConfiguration","QueueConfiguration","CloudFunctionConfiguration","buildARN","partition","service","region","accountId","resource","ObjectCreatedAll","ObjectCreatedPut","ObjectCreatedPost","ObjectCreatedCopy","ObjectCreatedCompleteMultipartUpload","ObjectRemovedAll","ObjectRemovedDelete","ObjectRemovedDeleteMarkerCreated","ObjectReducedRedundancyLostObject","NotificationPoller","client","bucketName","events","ending","start","process","nextTick","checkForChanges","stop","method","queries","forEach","s3event","sort","query","length","join","makeRequestAsync","then","response","asm","make","on","data","records","value","Records","record","emit","destroy","e"],"sources":["notification.ts"],"sourcesContent":["/*\n * Hanzo S3 Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2016 Hanzo AI, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { EventEmitter } from 'eventemitter3'\nimport jsonLineParser from 'stream-json/jsonl/Parser.js'\n\nimport { DEFAULT_REGION } from './helpers.ts'\nimport type { TypedClient } from './internal/client.ts'\nimport { pipesetup, uriEscape } from './internal/helper.ts'\n\n// TODO: type this\n\ntype Event = unknown\n\n// Base class for three supported configs.\nexport class TargetConfig {\n  private Filter?: { S3Key: { FilterRule: { Name: string; Value: string }[] } }\n  private Event?: Event[]\n  private Id: unknown\n\n  setId(id: unknown) {\n    this.Id = id\n  }\n\n  addEvent(newevent: Event) {\n    if (!this.Event) {\n      this.Event = []\n    }\n    this.Event.push(newevent)\n  }\n\n  addFilterSuffix(suffix: string) {\n    if (!this.Filter) {\n      this.Filter = { S3Key: { FilterRule: [] } }\n    }\n    this.Filter.S3Key.FilterRule.push({ Name: 'suffix', Value: suffix })\n  }\n\n  addFilterPrefix(prefix: string) {\n    if (!this.Filter) {\n      this.Filter = { S3Key: { FilterRule: [] } }\n    }\n    this.Filter.S3Key.FilterRule.push({ Name: 'prefix', Value: prefix })\n  }\n}\n\n// 1. Topic (simple notification service)\nexport class TopicConfig extends TargetConfig {\n  private Topic: string\n\n  constructor(arn: string) {\n    super()\n    this.Topic = arn\n  }\n}\n\n// 2. Queue (simple queue service)\nexport class QueueConfig extends TargetConfig {\n  private Queue: string\n\n  constructor(arn: string) {\n    super()\n    this.Queue = arn\n  }\n}\n\n// 3. CloudFront (lambda function)\nexport class CloudFunctionConfig extends TargetConfig {\n  private CloudFunction: string\n\n  constructor(arn: string) {\n    super()\n    this.CloudFunction = arn\n  }\n}\n\n// Notification config - array of target configs.\n// Target configs can be\n// 1. Topic (simple notification service)\n// 2. Queue (simple queue service)\n// 3. CloudFront (lambda function)\nexport class NotificationConfig {\n  private TopicConfiguration?: TargetConfig[]\n  private CloudFunctionConfiguration?: TargetConfig[]\n  private QueueConfiguration?: TargetConfig[]\n\n  add(target: TargetConfig) {\n    let instance: TargetConfig[] | undefined\n    if (target instanceof TopicConfig) {\n      instance = this.TopicConfiguration ??= []\n    }\n    if (target instanceof QueueConfig) {\n      instance = this.QueueConfiguration ??= []\n    }\n    if (target instanceof CloudFunctionConfig) {\n      instance = this.CloudFunctionConfiguration ??= []\n    }\n    if (instance) {\n      instance.push(target)\n    }\n  }\n}\n\nexport const buildARN = (partition: string, service: string, region: string, accountId: string, resource: string) => {\n  return 'arn:' + partition + ':' + service + ':' + region + ':' + accountId + ':' + resource\n}\nexport const ObjectCreatedAll = 's3:ObjectCreated:*'\nexport const ObjectCreatedPut = 's3:ObjectCreated:Put'\nexport const ObjectCreatedPost = 's3:ObjectCreated:Post'\nexport const ObjectCreatedCopy = 's3:ObjectCreated:Copy'\nexport const ObjectCreatedCompleteMultipartUpload = 's3:ObjectCreated:CompleteMultipartUpload'\nexport const ObjectRemovedAll = 's3:ObjectRemoved:*'\nexport const ObjectRemovedDelete = 's3:ObjectRemoved:Delete'\nexport const ObjectRemovedDeleteMarkerCreated = 's3:ObjectRemoved:DeleteMarkerCreated'\nexport const ObjectReducedRedundancyLostObject = 's3:ReducedRedundancyLostObject'\nexport type NotificationEvent =\n  | 's3:ObjectCreated:*'\n  | 's3:ObjectCreated:Put'\n  | 's3:ObjectCreated:Post'\n  | 's3:ObjectCreated:Copy'\n  | 's3:ObjectCreated:CompleteMultipartUpload'\n  | 's3:ObjectRemoved:*'\n  | 's3:ObjectRemoved:Delete'\n  | 's3:ObjectRemoved:DeleteMarkerCreated'\n  | 's3:ReducedRedundancyLostObject'\n  | 's3:TestEvent'\n  | 's3:ObjectRestore:Post'\n  | 's3:ObjectRestore:Completed'\n  | 's3:Replication:OperationFailedReplication'\n  | 's3:Replication:OperationMissedThreshold'\n  | 's3:Replication:OperationReplicatedAfterThreshold'\n  | 's3:Replication:OperationNotTracked'\n  | string // put string at least so auto-complete could work\n\n// TODO: type this\nexport type NotificationRecord = unknown\n// Poll for notifications, used in #listenBucketNotification.\n// Listening constitutes repeatedly requesting s3 whether or not any\n// changes have occurred.\nexport class NotificationPoller extends EventEmitter<{\n  notification: (event: NotificationRecord) => void\n  error: (error: unknown) => void\n}> {\n  private client: TypedClient\n  private bucketName: string\n  private prefix: string\n  private suffix: string\n  private events: NotificationEvent[]\n  private ending: boolean\n\n  constructor(client: TypedClient, bucketName: string, prefix: string, suffix: string, events: NotificationEvent[]) {\n    super()\n\n    this.client = client\n    this.bucketName = bucketName\n    this.prefix = prefix\n    this.suffix = suffix\n    this.events = events\n\n    this.ending = false\n  }\n\n  // Starts the polling.\n  start() {\n    this.ending = false\n\n    process.nextTick(() => {\n      this.checkForChanges()\n    })\n  }\n\n  // Stops the polling.\n  stop() {\n    this.ending = true\n  }\n\n  checkForChanges() {\n    // Don't continue if we're looping again but are cancelled.\n    if (this.ending) {\n      return\n    }\n\n    const method = 'GET'\n    const queries = []\n    if (this.prefix) {\n      const prefix = uriEscape(this.prefix)\n      queries.push(`prefix=${prefix}`)\n    }\n    if (this.suffix) {\n      const suffix = uriEscape(this.suffix)\n      queries.push(`suffix=${suffix}`)\n    }\n    if (this.events) {\n      this.events.forEach((s3event) => queries.push('events=' + uriEscape(s3event)))\n    }\n    queries.sort()\n\n    let query = ''\n    if (queries.length > 0) {\n      query = `${queries.join('&')}`\n    }\n    const region = this.client.region || DEFAULT_REGION\n\n    this.client.makeRequestAsync({ method, bucketName: this.bucketName, query }, '', [200], region).then(\n      (response) => {\n        const asm = jsonLineParser.make()\n\n        pipesetup(response, asm)\n          .on('data', (data) => {\n            // Data is flushed periodically (every 5 seconds), so we should\n            // handle it after flushing from the JSON parser.\n            let records = data.value.Records\n            // If null (= no records), change to an empty array.\n            if (!records) {\n              records = []\n            }\n\n            // Iterate over the notifications and emit them individually.\n            records.forEach((record: NotificationRecord) => {\n              this.emit('notification', record)\n            })\n\n            // If we're done, stop.\n            if (this.ending) {\n              response?.destroy()\n            }\n          })\n          .on('error', (e) => this.emit('error', e))\n          .on('end', () => {\n            // Do it again, if we haven't cancelled yet.\n            process.nextTick(() => {\n              this.checkForChanges()\n            })\n          })\n      },\n      (e) => {\n        return this.emit('error', e)\n      },\n    )\n  }\n}\n"],"mappings":"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"}

package/dist/esm/s3.d.mts

@@ -0,0 +1,40 @@
+import type { LEGAL_HOLD_STATUS, RETENTION_MODES, RETENTION_VALIDITY_UNITS } from "./helpers.mjs";
+import { TypedClient } from "./internal/client.mjs";
+import { CopyConditions } from "./internal/copy-conditions.mjs";
+import { PostPolicy } from "./internal/post-policy.mjs";
+export * from "./errors.mjs";
+export * from "./helpers.mjs";
+export * from "./notification.mjs";
+export { CopyConditions, PostPolicy };
+export { IamAwsProvider } from "./IamAwsProvider.mjs";
+export type { MakeBucketOpt } from "./internal/client.mjs";
+export type { ClientOptions, NoResultCallback, RemoveOptions } from "./internal/client.mjs";
+export type { Region } from "./internal/s3-endpoints.mjs";
+export type { BucketItem, BucketItemCopy, BucketItemFromList, BucketItemStat, BucketItemWithMetadata, BucketStream, EmptyObject, ExistingObjectReplication, GetObjectLegalHoldOptions, IncompleteUploadedBucketItem, InputSerialization, IsoDate, ItemBucketMetadata, ItemBucketMetadataList, LegalHoldStatus, LifecycleConfig, LifecycleRule, MetadataItem, ObjectLockInfo, OutputSerialization, PostPolicyResult, PutObjectLegalHoldOptions, ReplicaModifications, ReplicationConfig, ReplicationConfigOpts, ReplicationRule, ReplicationRuleAnd, ReplicationRuleDestination, ReplicationRuleFilter, ReplicationRuleStatus, Retention, RetentionOptions, ScanRange, SelectOptions, SelectProgress, SourceSelectionCriteria, Tag } from "./internal/type.mjs";
+/**
+ * @deprecated keep for backward compatible, use `RETENTION_MODES` instead
+ */
+export type Mode = RETENTION_MODES;
+/**
+ * @deprecated keep for backward compatible
+ */
+export type LockUnit = RETENTION_VALIDITY_UNITS;
+export type VersioningConfig = Record<string | number | symbol, unknown>;
+export type TagList = Record<string, string>;
+export interface LockConfig {
+  mode: RETENTION_MODES;
+  unit: RETENTION_VALIDITY_UNITS;
+  validity: number;
+}
+export interface LegalHoldOptions {
+  versionId: string;
+  status: LEGAL_HOLD_STATUS;
+}
+export interface SourceObjectStats {
+  size: number;
+  metaData: string;
+  lastModicied: Date;
+  versionId: string;
+  etag: string;
+}
+export declare class Client extends TypedClient {}

package/dist/esm/s3.mjs

@@ -0,0 +1,86 @@
+/*
+ * Hanzo S3 Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 Hanzo AI, Inc.
+ *
+ * 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.
+ */
+
+import { callbackify } from "./internal/callbackify.mjs";
+import { TypedClient } from "./internal/client.mjs";
+import { CopyConditions } from "./internal/copy-conditions.mjs";
+import { PostPolicy } from "./internal/post-policy.mjs";
+export * from "./errors.mjs";
+export * from "./helpers.mjs";
+export * from "./notification.mjs";
+export { CopyConditions, PostPolicy };
+export { IamAwsProvider } from "./IamAwsProvider.mjs";
+
+/**
+ * @deprecated keep for backward compatible, use `RETENTION_MODES` instead
+ */
+
+/**
+ * @deprecated keep for backward compatible
+ */
+
+export class Client extends TypedClient {}
+
+// refactored API use promise internally
+Client.prototype.makeBucket = callbackify(Client.prototype.makeBucket);
+Client.prototype.bucketExists = callbackify(Client.prototype.bucketExists);
+Client.prototype.removeBucket = callbackify(Client.prototype.removeBucket);
+Client.prototype.listBuckets = callbackify(Client.prototype.listBuckets);
+Client.prototype.getObject = callbackify(Client.prototype.getObject);
+Client.prototype.fGetObject = callbackify(Client.prototype.fGetObject);
+Client.prototype.getPartialObject = callbackify(Client.prototype.getPartialObject);
+Client.prototype.statObject = callbackify(Client.prototype.statObject);
+Client.prototype.putObjectRetention = callbackify(Client.prototype.putObjectRetention);
+Client.prototype.putObject = callbackify(Client.prototype.putObject);
+Client.prototype.fPutObject = callbackify(Client.prototype.fPutObject);
+Client.prototype.removeObject = callbackify(Client.prototype.removeObject);
+Client.prototype.removeBucketReplication = callbackify(Client.prototype.removeBucketReplication);
+Client.prototype.setBucketReplication = callbackify(Client.prototype.setBucketReplication);
+Client.prototype.getBucketReplication = callbackify(Client.prototype.getBucketReplication);
+Client.prototype.getObjectLegalHold = callbackify(Client.prototype.getObjectLegalHold);
+Client.prototype.setObjectLegalHold = callbackify(Client.prototype.setObjectLegalHold);
+Client.prototype.setObjectLockConfig = callbackify(Client.prototype.setObjectLockConfig);
+Client.prototype.getObjectLockConfig = callbackify(Client.prototype.getObjectLockConfig);
+Client.prototype.getBucketPolicy = callbackify(Client.prototype.getBucketPolicy);
+Client.prototype.setBucketPolicy = callbackify(Client.prototype.setBucketPolicy);
+Client.prototype.getBucketTagging = callbackify(Client.prototype.getBucketTagging);
+Client.prototype.getObjectTagging = callbackify(Client.prototype.getObjectTagging);
+Client.prototype.setBucketTagging = callbackify(Client.prototype.setBucketTagging);
+Client.prototype.removeBucketTagging = callbackify(Client.prototype.removeBucketTagging);
+Client.prototype.setObjectTagging = callbackify(Client.prototype.setObjectTagging);
+Client.prototype.removeObjectTagging = callbackify(Client.prototype.removeObjectTagging);
+Client.prototype.getBucketVersioning = callbackify(Client.prototype.getBucketVersioning);
+Client.prototype.setBucketVersioning = callbackify(Client.prototype.setBucketVersioning);
+Client.prototype.selectObjectContent = callbackify(Client.prototype.selectObjectContent);
+Client.prototype.setBucketLifecycle = callbackify(Client.prototype.setBucketLifecycle);
+Client.prototype.getBucketLifecycle = callbackify(Client.prototype.getBucketLifecycle);
+Client.prototype.removeBucketLifecycle = callbackify(Client.prototype.removeBucketLifecycle);
+Client.prototype.setBucketEncryption = callbackify(Client.prototype.setBucketEncryption);
+Client.prototype.getBucketEncryption = callbackify(Client.prototype.getBucketEncryption);
+Client.prototype.removeBucketEncryption = callbackify(Client.prototype.removeBucketEncryption);
+Client.prototype.getObjectRetention = callbackify(Client.prototype.getObjectRetention);
+Client.prototype.removeObjects = callbackify(Client.prototype.removeObjects);
+Client.prototype.removeIncompleteUpload = callbackify(Client.prototype.removeIncompleteUpload);
+Client.prototype.copyObject = callbackify(Client.prototype.copyObject);
+Client.prototype.composeObject = callbackify(Client.prototype.composeObject);
+Client.prototype.presignedUrl = callbackify(Client.prototype.presignedUrl);
+Client.prototype.presignedGetObject = callbackify(Client.prototype.presignedGetObject);
+Client.prototype.presignedPutObject = callbackify(Client.prototype.presignedPutObject);
+Client.prototype.presignedPostPolicy = callbackify(Client.prototype.presignedPostPolicy);
+Client.prototype.setBucketNotification = callbackify(Client.prototype.setBucketNotification);
+Client.prototype.getBucketNotification = callbackify(Client.prototype.getBucketNotification);
+Client.prototype.removeAllBucketNotification = callbackify(Client.prototype.removeAllBucketNotification);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["callbackify","TypedClient","CopyConditions","PostPolicy","IamAwsProvider","Client","prototype","makeBucket","bucketExists","removeBucket","listBuckets","getObject","fGetObject","getPartialObject","statObject","putObjectRetention","putObject","fPutObject","removeObject","removeBucketReplication","setBucketReplication","getBucketReplication","getObjectLegalHold","setObjectLegalHold","setObjectLockConfig","getObjectLockConfig","getBucketPolicy","setBucketPolicy","getBucketTagging","getObjectTagging","setBucketTagging","removeBucketTagging","setObjectTagging","removeObjectTagging","getBucketVersioning","setBucketVersioning","selectObjectContent","setBucketLifecycle","getBucketLifecycle","removeBucketLifecycle","setBucketEncryption","getBucketEncryption","removeBucketEncryption","getObjectRetention","removeObjects","removeIncompleteUpload","copyObject","composeObject","presignedUrl","presignedGetObject","presignedPutObject","presignedPostPolicy","setBucketNotification","getBucketNotification","removeAllBucketNotification"],"sources":["s3.ts"],"sourcesContent":["/*\n * Hanzo S3 Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 Hanzo AI, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { LEGAL_HOLD_STATUS, RETENTION_MODES, RETENTION_VALIDITY_UNITS } from './helpers.ts'\nimport { callbackify } from './internal/callbackify.ts'\nimport { TypedClient } from './internal/client.ts'\nimport { CopyConditions } from './internal/copy-conditions.ts'\nimport { PostPolicy } from './internal/post-policy.ts'\n\nexport * from './errors.ts'\nexport * from './helpers.ts'\nexport * from './notification.ts'\nexport { CopyConditions, PostPolicy }\nexport { IamAwsProvider } from './IamAwsProvider.ts'\nexport type { MakeBucketOpt } from './internal/client.ts'\nexport type { ClientOptions, NoResultCallback, RemoveOptions } from './internal/client.ts'\nexport type { Region } from './internal/s3-endpoints.ts'\nexport type {\n  BucketItem,\n  BucketItemCopy,\n  BucketItemFromList,\n  BucketItemStat,\n  BucketItemWithMetadata,\n  BucketStream,\n  EmptyObject,\n  ExistingObjectReplication,\n  GetObjectLegalHoldOptions,\n  IncompleteUploadedBucketItem,\n  InputSerialization,\n  IsoDate,\n  ItemBucketMetadata,\n  ItemBucketMetadataList,\n  LegalHoldStatus,\n  LifecycleConfig,\n  LifecycleRule,\n  MetadataItem,\n  ObjectLockInfo,\n  OutputSerialization,\n  PostPolicyResult,\n  PutObjectLegalHoldOptions,\n  ReplicaModifications,\n  ReplicationConfig,\n  ReplicationConfigOpts,\n  ReplicationRule,\n  ReplicationRuleAnd,\n  ReplicationRuleDestination,\n  ReplicationRuleFilter,\n  ReplicationRuleStatus,\n  Retention,\n  RetentionOptions,\n  ScanRange,\n  SelectOptions,\n  SelectProgress,\n  SourceSelectionCriteria,\n  Tag,\n} from './internal/type.ts'\n\n/**\n * @deprecated keep for backward compatible, use `RETENTION_MODES` instead\n */\nexport type Mode = RETENTION_MODES\n\n/**\n * @deprecated keep for backward compatible\n */\nexport type LockUnit = RETENTION_VALIDITY_UNITS\n\nexport type VersioningConfig = Record<string | number | symbol, unknown>\nexport type TagList = Record<string, string>\n\nexport interface LockConfig {\n  mode: RETENTION_MODES\n  unit: RETENTION_VALIDITY_UNITS\n  validity: number\n}\n\nexport interface LegalHoldOptions {\n  versionId: string\n  status: LEGAL_HOLD_STATUS\n}\n\nexport interface SourceObjectStats {\n  size: number\n  metaData: string\n  lastModicied: Date\n  versionId: string\n  etag: string\n}\n\nexport class Client extends TypedClient {}\n\n// refactored API use promise internally\nClient.prototype.makeBucket = callbackify(Client.prototype.makeBucket)\nClient.prototype.bucketExists = callbackify(Client.prototype.bucketExists)\nClient.prototype.removeBucket = callbackify(Client.prototype.removeBucket)\nClient.prototype.listBuckets = callbackify(Client.prototype.listBuckets)\n\nClient.prototype.getObject = callbackify(Client.prototype.getObject)\nClient.prototype.fGetObject = callbackify(Client.prototype.fGetObject)\nClient.prototype.getPartialObject = callbackify(Client.prototype.getPartialObject)\nClient.prototype.statObject = callbackify(Client.prototype.statObject)\nClient.prototype.putObjectRetention = callbackify(Client.prototype.putObjectRetention)\nClient.prototype.putObject = callbackify(Client.prototype.putObject)\nClient.prototype.fPutObject = callbackify(Client.prototype.fPutObject)\nClient.prototype.removeObject = callbackify(Client.prototype.removeObject)\n\nClient.prototype.removeBucketReplication = callbackify(Client.prototype.removeBucketReplication)\nClient.prototype.setBucketReplication = callbackify(Client.prototype.setBucketReplication)\nClient.prototype.getBucketReplication = callbackify(Client.prototype.getBucketReplication)\nClient.prototype.getObjectLegalHold = callbackify(Client.prototype.getObjectLegalHold)\nClient.prototype.setObjectLegalHold = callbackify(Client.prototype.setObjectLegalHold)\nClient.prototype.setObjectLockConfig = callbackify(Client.prototype.setObjectLockConfig)\nClient.prototype.getObjectLockConfig = callbackify(Client.prototype.getObjectLockConfig)\nClient.prototype.getBucketPolicy = callbackify(Client.prototype.getBucketPolicy)\nClient.prototype.setBucketPolicy = callbackify(Client.prototype.setBucketPolicy)\nClient.prototype.getBucketTagging = callbackify(Client.prototype.getBucketTagging)\nClient.prototype.getObjectTagging = callbackify(Client.prototype.getObjectTagging)\nClient.prototype.setBucketTagging = callbackify(Client.prototype.setBucketTagging)\nClient.prototype.removeBucketTagging = callbackify(Client.prototype.removeBucketTagging)\nClient.prototype.setObjectTagging = callbackify(Client.prototype.setObjectTagging)\nClient.prototype.removeObjectTagging = callbackify(Client.prototype.removeObjectTagging)\nClient.prototype.getBucketVersioning = callbackify(Client.prototype.getBucketVersioning)\nClient.prototype.setBucketVersioning = callbackify(Client.prototype.setBucketVersioning)\nClient.prototype.selectObjectContent = callbackify(Client.prototype.selectObjectContent)\nClient.prototype.setBucketLifecycle = callbackify(Client.prototype.setBucketLifecycle)\nClient.prototype.getBucketLifecycle = callbackify(Client.prototype.getBucketLifecycle)\nClient.prototype.removeBucketLifecycle = callbackify(Client.prototype.removeBucketLifecycle)\nClient.prototype.setBucketEncryption = callbackify(Client.prototype.setBucketEncryption)\nClient.prototype.getBucketEncryption = callbackify(Client.prototype.getBucketEncryption)\nClient.prototype.removeBucketEncryption = callbackify(Client.prototype.removeBucketEncryption)\nClient.prototype.getObjectRetention = callbackify(Client.prototype.getObjectRetention)\nClient.prototype.removeObjects = callbackify(Client.prototype.removeObjects)\nClient.prototype.removeIncompleteUpload = callbackify(Client.prototype.removeIncompleteUpload)\nClient.prototype.copyObject = callbackify(Client.prototype.copyObject)\nClient.prototype.composeObject = callbackify(Client.prototype.composeObject)\nClient.prototype.presignedUrl = callbackify(Client.prototype.presignedUrl)\nClient.prototype.presignedGetObject = callbackify(Client.prototype.presignedGetObject)\nClient.prototype.presignedPutObject = callbackify(Client.prototype.presignedPutObject)\nClient.prototype.presignedPostPolicy = callbackify(Client.prototype.presignedPostPolicy)\nClient.prototype.setBucketNotification = callbackify(Client.prototype.setBucketNotification)\nClient.prototype.getBucketNotification = callbackify(Client.prototype.getBucketNotification)\nClient.prototype.removeAllBucketNotification = callbackify(Client.prototype.removeAllBucketNotification)\n"],"mappings":"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"}

package/dist/esm/signing.d.mts

@@ -0,0 +1,5 @@
+import type { IRequest } from "./internal/type.mjs";
+export declare function postPresignSignatureV4(region: string, date: Date, secretKey: string, policyBase64: string): string;
+export declare function signV4(request: IRequest, accessKey: string, secretKey: string, region: string, requestDate: Date, sha256sum: string, serviceName?: string): string;
+export declare function signV4ByServiceName(request: IRequest, accessKey: string, secretKey: string, region: string, requestDate: Date, contentSha256: string, serviceName?: string): string;
+export declare function presignSignatureV4(request: IRequest, accessKey: string, secretKey: string, sessionToken: string | undefined, region: string, requestDate: Date, expires: number | undefined): string;