@effect-kit/storage 0.0.0-stage → 0.1.0

package/dist/testing.d.ts

@@ -0,0 +1,6 @@
+import { MemoryOptions } from "./testing/memory-state.js";
+import { memory_d_exports } from "./testing/memory.js";
+import { FaultAttempt, FaultController, FaultDiagnostic, FaultStep, faults_d_exports } from "./testing/faults.js";
+import { ConformanceFailure } from "./testing/conformance/assertions.js";
+import { ConformanceResult, StorageConformanceCase, runStorageConformance, storageConformanceCases } from "./testing/conformance.js";
+export { ConformanceFailure, type ConformanceResult, type FaultAttempt, type FaultController, type FaultDiagnostic, type FaultStep, faults_d_exports as Faults, type MemoryOptions, memory_d_exports as MemoryStorage, type StorageConformanceCase, runStorageConformance, storageConformanceCases };

package/dist/testing.js

@@ -0,0 +1,6 @@
+import { memory_exports } from "./testing/memory.js";
+import { faults_exports } from "./testing/faults.js";
+import { ConformanceFailure } from "./testing/conformance/assertions.js";
+import { runStorageConformance, storageConformanceCases } from "./testing/conformance.js";
+
+export { ConformanceFailure, faults_exports as Faults, memory_exports as MemoryStorage, runStorageConformance, storageConformanceCases };

package/dist/tigris/events.d.ts

@@ -0,0 +1,42 @@
+import { StorageError } from "../core/errors.js";
+import "../index.js";
+import { Effect, Redacted } from "effect";
+export declare namespace TigrisEvents {
+  /** messageId must identify an authenticated delivery; native payloads have no stable event ID. */
+  const decode: (payload: unknown, options: {
+    readonly bucket: string;
+    readonly storeId: string;
+    readonly messageId: string;
+  }) => Effect.Effect<{
+    readonly provider: string;
+    readonly kind: "delete-marker-created" | "metadata-updated" | "object-created" | "object-deleted" | "other" | "restore-completed" | "version-archived";
+    readonly ref: {
+      readonly storeId: string;
+      readonly key: string;
+      readonly version?: {
+        readonly _tag: "S3Version";
+        readonly id: string;
+      } | {
+        readonly _tag: "GcsGeneration";
+        readonly id: string;
+        readonly metageneration?: string | undefined;
+      } | {
+        readonly _tag: "AzureVersion";
+        readonly id: string;
+      } | {
+        readonly _tag: "AzureSnapshot";
+        readonly id: string;
+      } | {
+        readonly _tag: "OpaqueVersion";
+        readonly provider: string;
+        readonly id: string;
+      } | undefined;
+    };
+    readonly occurredAt: import("effect/DateTime").Utc;
+    readonly id?: string | undefined;
+    readonly sequencer?: string | undefined;
+    readonly nativeType: string;
+    readonly native?: Redacted.Redacted<unknown> | undefined;
+  }[], StorageError, never>;
+}
+//# sourceMappingURL=events.d.ts.map

package/dist/tigris/events.js

@@ -0,0 +1,42 @@
+import { storageError } from "../core/errors.js";
+import { decodeRequest } from "../internal/request-validation.js";
+import { StorageEvent } from "../events.js";
+import { decodeResponse } from "../internal/provider-response.js";
+import { Effect, Redacted, Schema } from "effect";
+
+// src/providers/tigris/events.ts
+let TigrisEvents;
+(function(_TigrisEvents) {
+	_TigrisEvents.decode = Effect.fnUntraced(function* (payload, options) {
+		yield* decodeRequest(Schema.NonEmptyString, options.messageId, "decodeEvent", "tigris");
+		const batch = yield* decodeResponse(Schema.Struct({ events: Schema.Array(Schema.Struct({
+			eventVersion: Schema.NonEmptyString,
+			eventSource: Schema.Literal("tigris"),
+			eventName: Schema.NonEmptyString,
+			eventTime: Schema.DateTimeUtcFromString,
+			bucket: Schema.NonEmptyString,
+			object: Schema.Struct({ key: Schema.NonEmptyString })
+		})).check(Schema.isMaxLength(1e3)) }), payload, "decodeEvent", "tigris");
+		return yield* Effect.forEach(batch.events, (event, index) => Effect.gen(function* () {
+			if (event.bucket !== options.bucket) return yield* storageError("decodeEvent", "tigris", {
+				_tag: "InvalidInput",
+				field: "bucket"
+			});
+			return yield* decodeRequest(StorageEvent, {
+				provider: "tigris",
+				kind: event.eventName === "OBJECT_CREATED_PUT" ? "object-created" : event.eventName === "OBJECT_DELETED" ? "object-deleted" : "other",
+				ref: {
+					storeId: options.storeId,
+					key: event.object.key
+				},
+				occurredAt: event.eventTime,
+				id: `${options.messageId}:${String(index)}`,
+				nativeType: event.eventName,
+				native: Redacted.make(payload)
+			}, "decodeEvent", "tigris");
+		}));
+	});
+})(TigrisEvents || (TigrisEvents = {}));
+
+export { TigrisEvents };
+//# sourceMappingURL=events.js.map

package/dist/tigris/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","names":[],"sources":["../../src/providers/tigris/events.ts"],"sourcesContent":["import { Effect, Redacted, Schema } from \"effect\";\n\nimport { storageError } from \"../../core/errors.js\";\nimport { decodeResponse } from \"../../internal/provider-response.js\";\nimport { decodeRequest } from \"../../internal/request-validation.js\";\nimport { StorageEvent } from \"../../lifecycle/events.js\";\n\nexport namespace TigrisEvents {\n  /** messageId must identify an authenticated delivery; native payloads have no stable event ID. */\n  export const decode = Effect.fnUntraced(function* (\n    payload: unknown,\n    options: { readonly bucket: string; readonly storeId: string; readonly messageId: string },\n  ) {\n    yield* decodeRequest(Schema.NonEmptyString, options.messageId, \"decodeEvent\", \"tigris\");\n    const batch = yield* decodeResponse(\n      Schema.Struct({\n        events: Schema.Array(\n          Schema.Struct({\n            eventVersion: Schema.NonEmptyString,\n            eventSource: Schema.Literal(\"tigris\"),\n            eventName: Schema.NonEmptyString,\n            eventTime: Schema.DateTimeUtcFromString,\n            bucket: Schema.NonEmptyString,\n            object: Schema.Struct({ key: Schema.NonEmptyString }),\n          }),\n        ).check(Schema.isMaxLength(1000)),\n      }),\n      payload,\n      \"decodeEvent\",\n      \"tigris\",\n    );\n    return yield* Effect.forEach(batch.events, (event, index) =>\n      Effect.gen(function* () {\n        if (event.bucket !== options.bucket)\n          return yield* storageError(\"decodeEvent\", \"tigris\", {\n            _tag: \"InvalidInput\",\n            field: \"bucket\",\n          });\n        return yield* decodeRequest(\n          StorageEvent,\n          {\n            provider: \"tigris\",\n            kind:\n              event.eventName === \"OBJECT_CREATED_PUT\"\n                ? \"object-created\"\n                : event.eventName === \"OBJECT_DELETED\"\n                  ? \"object-deleted\"\n                  : \"other\",\n            ref: { storeId: options.storeId, key: event.object.key },\n            occurredAt: event.eventTime,\n            id: `${options.messageId}:${String(index)}`,\n            nativeType: event.eventName,\n            native: Redacted.make(payload),\n          },\n          \"decodeEvent\",\n          \"tigris\",\n        );\n      }),\n    );\n  });\n}\n"],"mappings":";;;;;;;AAOO,IAAU;CAAV;wBAEiB,OAAO,WAAW,WACtC,SACA,SACA;EACA,OAAO,cAAc,OAAO,gBAAgB,QAAQ,WAAW,eAAe,QAAQ;EACtF,MAAM,QAAQ,OAAO,eACnB,OAAO,OAAO,EACZ,QAAQ,OAAO,MACb,OAAO,OAAO;GACZ,cAAc,OAAO;GACrB,aAAa,OAAO,QAAQ,QAAQ;GACpC,WAAW,OAAO;GAClB,WAAW,OAAO;GAClB,QAAQ,OAAO;GACf,QAAQ,OAAO,OAAO,EAAE,KAAK,OAAO,eAAe,CAAC;EACtD,CAAC,CACH,CAAC,CAAC,MAAM,OAAO,YAAY,GAAI,CAAC,EAClC,CAAC,GACD,SACA,eACA,QACF;EACA,OAAO,OAAO,OAAO,QAAQ,MAAM,SAAS,OAAO,UACjD,OAAO,IAAI,aAAa;GACtB,IAAI,MAAM,WAAW,QAAQ,QAC3B,OAAO,OAAO,aAAa,eAAe,UAAU;IAClD,MAAM;IACN,OAAO;GACT,CAAC;GACH,OAAO,OAAO,cACZ,cACA;IACE,UAAU;IACV,MACE,MAAM,cAAc,uBAChB,mBACA,MAAM,cAAc,mBAClB,mBACA;IACR,KAAK;KAAE,SAAS,QAAQ;KAAS,KAAK,MAAM,OAAO;IAAI;IACvD,YAAY,MAAM;IAClB,IAAI,GAAG,QAAQ,UAAU,GAAG,OAAO,KAAK;IACxC,YAAY,MAAM;IAClB,QAAQ,SAAS,KAAK,OAAO;GAC/B,GACA,eACA,QACF;EACF,CAAC,CACH;CACF,CAAC;EACF,oCAAD"}

package/dist/tigris/native.d.ts

@@ -0,0 +1,438 @@
+import { StorageError } from "../core/errors.js";
+import { ArchiveService, VersionRef } from "../lifecycle.js";
+import "../index.js";
+import { S3Storage, S3StorageService } from "../s3.js";
+import { Context, Effect, Layer, Redacted } from "effect";
+import * as Tigris from "@tigrisdata/storage";
+export interface TigrisNativeConfig {
+  readonly endpoint: string;
+  readonly organizationId?: string;
+  readonly credentials: NonNullable<Tigris.TigrisConfig["credentialProvider"]>;
+}
+declare const TigrisAdministration_base: Context.ServiceClass<TigrisAdministration, "@effect-kit/storage/tigris/TigrisAdministration", {
+  configuration: {
+    update: (input: {
+      readonly bucket: string;
+      readonly settings: {
+        readonly access?: "private" | "public" | undefined;
+        readonly allowObjectAcl?: boolean | undefined;
+        readonly defaultTier?: "GLACIER" | "GLACIER_IR" | "STANDARD" | "STANDARD_IA" | undefined;
+        readonly disableDirectoryListing?: boolean | undefined;
+        readonly cacheControl?: string | undefined;
+        readonly customDomain?: string | undefined;
+        readonly enableAdditionalHeaders?: boolean | undefined;
+        readonly softDelete?: {
+          readonly enabled: true;
+          readonly retentionDays: number;
+        } | {
+          readonly enabled: false;
+        } | undefined;
+      };
+      readonly intent: "change-storage-protection";
+    }) => Effect.Effect<Tigris.UpdateBucketResponse, StorageError, never>;
+    setCors: (input: {
+      readonly bucket: string;
+      readonly rules: ReadonlyArray<{
+        readonly allowedOrigins: string | readonly string[];
+        readonly allowedMethods?: string | readonly string[] | undefined;
+        readonly allowedHeaders?: string | readonly string[] | undefined;
+        readonly exposeHeaders?: string | readonly string[] | undefined;
+        readonly maxAge?: number | undefined;
+      }>;
+    }) => Effect.Effect<Tigris.UpdateBucketResponse, StorageError, never>;
+    setLifecycle: (input: {
+      readonly bucket: string;
+      readonly rules: ReadonlyArray<{
+        readonly id?: string | undefined;
+        readonly enabled?: boolean | undefined;
+        readonly storageClass?: "GLACIER" | "GLACIER_IR" | "STANDARD_IA" | undefined;
+        readonly days?: number | undefined;
+        readonly date?: string | undefined;
+        readonly expiration?: {
+          readonly days?: number | undefined;
+          readonly date?: string | undefined;
+        } | undefined;
+        readonly filter?: {
+          readonly prefix: string;
+        } | undefined;
+      }>;
+      readonly intent: "change-storage-protection";
+    }) => Effect.Effect<Tigris.UpdateBucketResponse, StorageError, never>;
+    setNotifications: (input: {
+      readonly bucket: string;
+      readonly enabled: boolean;
+      readonly url?: string;
+      readonly filter?: string;
+      readonly token?: Redacted.Redacted<string>;
+    }) => Effect.Effect<Tigris.UpdateBucketResponse, StorageError, never>;
+  };
+  listPage: (input?: {
+    readonly cursor?: string;
+    readonly limit?: number;
+    readonly deleted?: boolean;
+  }) => Effect.Effect<Tigris.ListBucketsResponse, StorageError, never>;
+  head: (input: {
+    readonly bucket: string;
+  }) => Effect.Effect<{
+    regions: string[];
+    locations: Tigris.BucketLocations;
+    isSnapshotEnabled: boolean;
+    forkInfo: {
+      hasChildren: boolean;
+      parents: Array<{
+        bucketName: string;
+        forkCreatedAt: Date;
+        snapshot: string;
+        snapshotCreatedAt: Date;
+      }>;
+    } | undefined;
+    sizeInfo: {
+      numberOfObjects: number | undefined;
+      size: number | undefined;
+      numberOfObjectsAllVersions: number | undefined;
+    };
+    settings: Redacted.Redacted<{
+      allowObjectAcl: boolean;
+      defaultTier: Tigris.StorageClass;
+      lifecycleRules?: Tigris.BucketLifecycleRule[];
+      dataMigration?: Omit<Tigris.BucketMigration, 'enabled'>;
+      ttlConfig?: Tigris.BucketTtl;
+      customDomain?: string;
+      softDelete: {
+        enabled: true;
+        retentionDays: number;
+      } | {
+        enabled: false;
+      };
+      deleteProtection: boolean;
+      corsRules: Tigris.BucketCorsRule[];
+      additionalHeaders?: {
+        'X-Content-Type-Options': 'nosniff';
+      } | null | undefined;
+      notifications?: Tigris.BucketNotification;
+      shares: Tigris.BucketShares;
+    }>;
+  }, StorageError, never>;
+  create: (input: {
+    readonly bucket: string;
+  }) => Effect.Effect<{
+    _tag: "Accepted";
+    bucket: string;
+  }, StorageError, never>;
+  deleteEmpty: (input: {
+    readonly bucket: string;
+  }) => Effect.Effect<void, StorageError, never>;
+  restoreDeleted: (input: {
+    readonly bucket: string;
+  }) => Effect.Effect<Tigris.RestoreBucketResponse, StorageError, never>;
+  snapshots: {
+    create: (input: {
+      readonly bucket: string;
+      readonly name?: string;
+    }) => Effect.Effect<{
+      snapshotVersion: string;
+    }, StorageError, never>;
+    listPage: (input: {
+      readonly bucket: string;
+      readonly cursor?: string;
+      readonly limit?: number;
+    }) => Effect.Effect<{
+      snapshots: {
+        version: string | undefined;
+        name: string | undefined;
+        createdAt: Date | undefined;
+      }[];
+      cursor: string | undefined;
+    }, StorageError, never>;
+    delete: (input: {
+      readonly bucket: string;
+      readonly version: string;
+      readonly intent: "delete-snapshot";
+    }) => Effect.Effect<void, StorageError, never>;
+    enable: (input: {
+      readonly bucket: string;
+    }) => Effect.Effect<Tigris.UpdateBucketResponse, StorageError, never>;
+  };
+  forks: {
+    listPage: (input: {
+      readonly bucket: string;
+      readonly cursor?: string;
+      readonly limit?: number;
+    }) => Effect.Effect<Tigris.ListForksResponse, StorageError, never>;
+    create: (input: {
+      readonly bucket: string;
+      readonly sourceBucket: string;
+      readonly snapshot: string;
+    }) => Effect.Effect<{
+      _tag: "Accepted";
+      bucket: string;
+    }, StorageError, never>;
+    merge: (input: {
+      readonly fork: string;
+      readonly destination: string;
+      readonly intent: "merge-fork";
+    }) => Effect.Effect<Tigris.MergeForkResponse, StorageError, never>;
+    rebase: (input: {
+      readonly fork: string;
+      readonly intent: "rebase-fork";
+    }) => Effect.Effect<Tigris.RebaseForkResponse, StorageError, never>;
+  };
+}>;
+export declare class TigrisAdministration extends TigrisAdministration_base {
+  static readonly make: (settings: TigrisNativeConfig) => Effect.Effect<{
+    configuration: {
+      update: (input: {
+        readonly bucket: string;
+        readonly settings: {
+          readonly access?: "private" | "public" | undefined;
+          readonly allowObjectAcl?: boolean | undefined;
+          readonly defaultTier?: "GLACIER" | "GLACIER_IR" | "STANDARD" | "STANDARD_IA" | undefined;
+          readonly disableDirectoryListing?: boolean | undefined;
+          readonly cacheControl?: string | undefined;
+          readonly customDomain?: string | undefined;
+          readonly enableAdditionalHeaders?: boolean | undefined;
+          readonly softDelete?: {
+            readonly enabled: true;
+            readonly retentionDays: number;
+          } | {
+            readonly enabled: false;
+          } | undefined;
+        };
+        readonly intent: "change-storage-protection";
+      }) => Effect.Effect<Tigris.UpdateBucketResponse, StorageError, never>;
+      setCors: (input: {
+        readonly bucket: string;
+        readonly rules: ReadonlyArray<{
+          readonly allowedOrigins: string | readonly string[];
+          readonly allowedMethods?: string | readonly string[] | undefined;
+          readonly allowedHeaders?: string | readonly string[] | undefined;
+          readonly exposeHeaders?: string | readonly string[] | undefined;
+          readonly maxAge?: number | undefined;
+        }>;
+      }) => Effect.Effect<Tigris.UpdateBucketResponse, StorageError, never>;
+      setLifecycle: (input: {
+        readonly bucket: string;
+        readonly rules: ReadonlyArray<{
+          readonly id?: string | undefined;
+          readonly enabled?: boolean | undefined;
+          readonly storageClass?: "GLACIER" | "GLACIER_IR" | "STANDARD_IA" | undefined;
+          readonly days?: number | undefined;
+          readonly date?: string | undefined;
+          readonly expiration?: {
+            readonly days?: number | undefined;
+            readonly date?: string | undefined;
+          } | undefined;
+          readonly filter?: {
+            readonly prefix: string;
+          } | undefined;
+        }>;
+        readonly intent: "change-storage-protection";
+      }) => Effect.Effect<Tigris.UpdateBucketResponse, StorageError, never>;
+      setNotifications: (input: {
+        readonly bucket: string;
+        readonly enabled: boolean;
+        readonly url?: string;
+        readonly filter?: string;
+        readonly token?: Redacted.Redacted<string>;
+      }) => Effect.Effect<Tigris.UpdateBucketResponse, StorageError, never>;
+    };
+    listPage: (input?: {
+      readonly cursor?: string;
+      readonly limit?: number;
+      readonly deleted?: boolean;
+    }) => Effect.Effect<Tigris.ListBucketsResponse, StorageError, never>;
+    head: (input: {
+      readonly bucket: string;
+    }) => Effect.Effect<{
+      regions: string[];
+      locations: Tigris.BucketLocations;
+      isSnapshotEnabled: boolean;
+      forkInfo: {
+        hasChildren: boolean;
+        parents: Array<{
+          bucketName: string;
+          forkCreatedAt: Date;
+          snapshot: string;
+          snapshotCreatedAt: Date;
+        }>;
+      } | undefined;
+      sizeInfo: {
+        numberOfObjects: number | undefined;
+        size: number | undefined;
+        numberOfObjectsAllVersions: number | undefined;
+      };
+      settings: Redacted.Redacted<{
+        allowObjectAcl: boolean;
+        defaultTier: Tigris.StorageClass;
+        lifecycleRules?: Tigris.BucketLifecycleRule[];
+        dataMigration?: Omit<Tigris.BucketMigration, 'enabled'>;
+        ttlConfig?: Tigris.BucketTtl;
+        customDomain?: string;
+        softDelete: {
+          enabled: true;
+          retentionDays: number;
+        } | {
+          enabled: false;
+        };
+        deleteProtection: boolean;
+        corsRules: Tigris.BucketCorsRule[];
+        additionalHeaders?: {
+          'X-Content-Type-Options': 'nosniff';
+        } | null | undefined;
+        notifications?: Tigris.BucketNotification;
+        shares: Tigris.BucketShares;
+      }>;
+    }, StorageError, never>;
+    create: (input: {
+      readonly bucket: string;
+    }) => Effect.Effect<{
+      _tag: "Accepted";
+      bucket: string;
+    }, StorageError, never>;
+    deleteEmpty: (input: {
+      readonly bucket: string;
+    }) => Effect.Effect<void, StorageError, never>;
+    restoreDeleted: (input: {
+      readonly bucket: string;
+    }) => Effect.Effect<Tigris.RestoreBucketResponse, StorageError, never>;
+    snapshots: {
+      create: (input: {
+        readonly bucket: string;
+        readonly name?: string;
+      }) => Effect.Effect<{
+        snapshotVersion: string;
+      }, StorageError, never>;
+      listPage: (input: {
+        readonly bucket: string;
+        readonly cursor?: string;
+        readonly limit?: number;
+      }) => Effect.Effect<{
+        snapshots: {
+          version: string | undefined;
+          name: string | undefined;
+          createdAt: Date | undefined;
+        }[];
+        cursor: string | undefined;
+      }, StorageError, never>;
+      delete: (input: {
+        readonly bucket: string;
+        readonly version: string;
+        readonly intent: "delete-snapshot";
+      }) => Effect.Effect<void, StorageError, never>;
+      enable: (input: {
+        readonly bucket: string;
+      }) => Effect.Effect<Tigris.UpdateBucketResponse, StorageError, never>;
+    };
+    forks: {
+      listPage: (input: {
+        readonly bucket: string;
+        readonly cursor?: string;
+        readonly limit?: number;
+      }) => Effect.Effect<Tigris.ListForksResponse, StorageError, never>;
+      create: (input: {
+        readonly bucket: string;
+        readonly sourceBucket: string;
+        readonly snapshot: string;
+      }) => Effect.Effect<{
+        _tag: "Accepted";
+        bucket: string;
+      }, StorageError, never>;
+      merge: (input: {
+        readonly fork: string;
+        readonly destination: string;
+        readonly intent: "merge-fork";
+      }) => Effect.Effect<Tigris.MergeForkResponse, StorageError, never>;
+      rebase: (input: {
+        readonly fork: string;
+        readonly intent: "rebase-fork";
+      }) => Effect.Effect<Tigris.RebaseForkResponse, StorageError, never>;
+    };
+  }, StorageError, import("effect/Scope").Scope>;
+  static layer(config: TigrisNativeConfig): Layer.Layer<TigrisAdministration, StorageError, never>;
+}
+declare const recovery: (storage: S3StorageService) => {
+  restoreDeleted: (input: {
+    readonly ref: VersionRef;
+  }) => Effect.Effect<{
+    _tag: "Accepted";
+    source: {
+      readonly storeId: string;
+      readonly key: string;
+      readonly version: {
+        readonly _tag: "S3Version";
+        readonly id: string;
+      } | {
+        readonly _tag: "GcsGeneration";
+        readonly id: string;
+        readonly metageneration?: string | undefined;
+      } | {
+        readonly _tag: "AzureVersion";
+        readonly id: string;
+      } | {
+        readonly _tag: "AzureSnapshot";
+        readonly id: string;
+      } | {
+        readonly _tag: "OpaqueVersion";
+        readonly provider: string;
+        readonly id: string;
+      };
+    };
+  }, StorageError, never>;
+  purgeDeleted: (input: {
+    readonly ref: VersionRef;
+    readonly intent: "purge-deleted-version";
+  }) => Effect.Effect<undefined, StorageError, never>;
+  archive: ArchiveService<{
+    readonly days: number;
+    readonly tier: "Bulk" | "Expedited" | "Standard";
+  } | {
+    readonly storage: "intelligent-tiering";
+    readonly tier: "Bulk" | "Expedited" | "Standard";
+  }>;
+};
+declare const TigrisRecovery_base: Context.ServiceClass<TigrisRecovery, "@effect-kit/storage/tigris/TigrisRecovery", {
+  restoreDeleted: (input: {
+    readonly ref: VersionRef;
+  }) => Effect.Effect<{
+    _tag: "Accepted";
+    source: {
+      readonly storeId: string;
+      readonly key: string;
+      readonly version: {
+        readonly _tag: "S3Version";
+        readonly id: string;
+      } | {
+        readonly _tag: "GcsGeneration";
+        readonly id: string;
+        readonly metageneration?: string | undefined;
+      } | {
+        readonly _tag: "AzureVersion";
+        readonly id: string;
+      } | {
+        readonly _tag: "AzureSnapshot";
+        readonly id: string;
+      } | {
+        readonly _tag: "OpaqueVersion";
+        readonly provider: string;
+        readonly id: string;
+      };
+    };
+  }, StorageError, never>;
+  purgeDeleted: (input: {
+    readonly ref: VersionRef;
+    readonly intent: "purge-deleted-version";
+  }) => Effect.Effect<undefined, StorageError, never>;
+  archive: ArchiveService<{
+    readonly days: number;
+    readonly tier: "Bulk" | "Expedited" | "Standard";
+  } | {
+    readonly storage: "intelligent-tiering";
+    readonly tier: "Bulk" | "Expedited" | "Standard";
+  }>;
+}>;
+export declare class TigrisRecovery extends TigrisRecovery_base {
+  static readonly make: typeof recovery;
+  static readonly layer: Layer.Layer<TigrisRecovery, never, S3Storage>;
+}
+export {};
+//# sourceMappingURL=native.d.ts.map