@contractspec/lib.files 1.56.1 → 1.58.0

package/dist/node/index.js

@@ -0,0 +1,1410 @@
+// src/contracts/index.ts
+import { ScalarTypeEnum, defineSchemaModel } from "@contractspec/lib.schema";
+import { defineCommand, defineQuery } from "@contractspec/lib.contracts";
+var OWNERS = ["platform.files"];
+var FileModel = defineSchemaModel({
+  name: "File",
+  description: "Represents an uploaded file",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    mimeType: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    size: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    storageProvider: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false
+    },
+    storagePath: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    checksum: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    status: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    isPublic: { type: ScalarTypeEnum.Boolean(), isOptional: false },
+    ownerId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    orgId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    metadata: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    width: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    height: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+    updatedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var FileVersionModel = defineSchemaModel({
+  name: "FileVersion",
+  description: "Represents a file version",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    fileId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    version: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    size: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    storagePath: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    checksum: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    comment: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    createdBy: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var AttachmentModel = defineSchemaModel({
+  name: "Attachment",
+  description: "Represents an attachment",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    fileId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    entityType: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    entityId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    attachmentType: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: true
+    },
+    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    description: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    order: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    metadata: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    createdBy: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+    file: { type: FileModel, isOptional: true }
+  }
+});
+var PresignedUrlModel = defineSchemaModel({
+  name: "PresignedUrl",
+  description: "A presigned URL for file operations",
+  fields: {
+    url: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    fields: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    expiresAt: { type: ScalarTypeEnum.DateTime(), isOptional: false },
+    fileId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    sessionId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true }
+  }
+});
+var UploadFileInput = defineSchemaModel({
+  name: "UploadFileInput",
+  description: "Input for uploading a file",
+  fields: {
+    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    mimeType: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    size: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    content: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    orgId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    isPublic: { type: ScalarTypeEnum.Boolean(), isOptional: true },
+    metadata: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    tags: { type: ScalarTypeEnum.JSON(), isOptional: true }
+  }
+});
+var UpdateFileInput = defineSchemaModel({
+  name: "UpdateFileInput",
+  description: "Input for updating a file",
+  fields: {
+    fileId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    isPublic: { type: ScalarTypeEnum.Boolean(), isOptional: true },
+    metadata: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    tags: { type: ScalarTypeEnum.JSON(), isOptional: true }
+  }
+});
+var DeleteFileInput = defineSchemaModel({
+  name: "DeleteFileInput",
+  description: "Input for deleting a file",
+  fields: {
+    fileId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false }
+  }
+});
+var GetFileInput = defineSchemaModel({
+  name: "GetFileInput",
+  description: "Input for getting a file",
+  fields: {
+    fileId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false }
+  }
+});
+var ListFilesInput = defineSchemaModel({
+  name: "ListFilesInput",
+  description: "Input for listing files",
+  fields: {
+    orgId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    ownerId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    mimeType: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    status: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    tags: { type: ScalarTypeEnum.JSON(), isOptional: true },
+    limit: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    offset: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true }
+  }
+});
+var ListFilesOutput = defineSchemaModel({
+  name: "ListFilesOutput",
+  description: "Output for listing files",
+  fields: {
+    files: { type: FileModel, isArray: true, isOptional: false },
+    total: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false }
+  }
+});
+var GetDownloadUrlInput = defineSchemaModel({
+  name: "GetDownloadUrlInput",
+  description: "Input for getting a download URL",
+  fields: {
+    fileId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    expiresInSeconds: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true }
+  }
+});
+var CreateVersionInput = defineSchemaModel({
+  name: "CreateVersionInput",
+  description: "Input for creating a file version",
+  fields: {
+    fileId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    content: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    comment: { type: ScalarTypeEnum.String_unsecure(), isOptional: true }
+  }
+});
+var GetVersionsInput = defineSchemaModel({
+  name: "GetVersionsInput",
+  description: "Input for getting file versions",
+  fields: {
+    fileId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    limit: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    offset: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true }
+  }
+});
+var GetVersionsOutput = defineSchemaModel({
+  name: "GetVersionsOutput",
+  description: "Output for getting file versions",
+  fields: {
+    versions: { type: FileVersionModel, isArray: true, isOptional: false },
+    total: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false }
+  }
+});
+var AttachFileInput = defineSchemaModel({
+  name: "AttachFileInput",
+  description: "Input for attaching a file to an entity",
+  fields: {
+    fileId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    entityType: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    entityId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    attachmentType: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: true
+    },
+    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    description: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    order: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true },
+    metadata: { type: ScalarTypeEnum.JSON(), isOptional: true }
+  }
+});
+var DetachFileInput = defineSchemaModel({
+  name: "DetachFileInput",
+  description: "Input for detaching a file",
+  fields: {
+    attachmentId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false }
+  }
+});
+var ListAttachmentsInput = defineSchemaModel({
+  name: "ListAttachmentsInput",
+  description: "Input for listing attachments",
+  fields: {
+    entityType: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    entityId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    attachmentType: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: true
+    }
+  }
+});
+var ListAttachmentsOutput = defineSchemaModel({
+  name: "ListAttachmentsOutput",
+  description: "Output for listing attachments",
+  fields: {
+    attachments: { type: AttachmentModel, isArray: true, isOptional: false },
+    total: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false }
+  }
+});
+var CreatePresignedUrlInput = defineSchemaModel({
+  name: "CreatePresignedUrlInput",
+  description: "Input for creating a presigned upload URL",
+  fields: {
+    fileName: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    mimeType: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    size: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    orgId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    expiresInSeconds: { type: ScalarTypeEnum.Int_unsecure(), isOptional: true }
+  }
+});
+var SuccessOutput = defineSchemaModel({
+  name: "SuccessOutput",
+  description: "Generic success output",
+  fields: {
+    success: { type: ScalarTypeEnum.Boolean(), isOptional: false }
+  }
+});
+var UploadFileContract = defineCommand({
+  meta: {
+    key: "file.upload",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["files", "upload"],
+    description: "Upload a new file.",
+    goal: "Store a file and create a file record.",
+    context: "Called when uploading files directly."
+  },
+  io: {
+    input: UploadFileInput,
+    output: FileModel,
+    errors: {
+      FILE_TOO_LARGE: {
+        description: "File exceeds size limit",
+        http: 413,
+        gqlCode: "FILE_TOO_LARGE",
+        when: "File size exceeds configured limit"
+      },
+      INVALID_MIME_TYPE: {
+        description: "MIME type not allowed",
+        http: 415,
+        gqlCode: "INVALID_MIME_TYPE",
+        when: "File type is not in allowed list"
+      }
+    }
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var UpdateFileContract = defineCommand({
+  meta: {
+    key: "file.update",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["files", "update"],
+    description: "Update file metadata.",
+    goal: "Modify file properties without replacing content.",
+    context: "Called when renaming or updating file metadata."
+  },
+  io: {
+    input: UpdateFileInput,
+    output: FileModel,
+    errors: {
+      FILE_NOT_FOUND: {
+        description: "File does not exist",
+        http: 404,
+        gqlCode: "FILE_NOT_FOUND",
+        when: "File ID is invalid"
+      }
+    }
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var DeleteFileContract = defineCommand({
+  meta: {
+    key: "file.delete",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["files", "delete"],
+    description: "Delete a file.",
+    goal: "Remove a file and all its versions and attachments.",
+    context: "Called when removing a file permanently."
+  },
+  io: {
+    input: DeleteFileInput,
+    output: SuccessOutput,
+    errors: {
+      FILE_NOT_FOUND: {
+        description: "File does not exist",
+        http: 404,
+        gqlCode: "FILE_NOT_FOUND",
+        when: "File ID is invalid"
+      }
+    }
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var GetFileContract = defineQuery({
+  meta: {
+    key: "file.get",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["files", "get"],
+    description: "Get a file by ID.",
+    goal: "Retrieve file metadata.",
+    context: "Called to inspect file details."
+  },
+  io: {
+    input: GetFileInput,
+    output: FileModel,
+    errors: {
+      FILE_NOT_FOUND: {
+        description: "File does not exist",
+        http: 404,
+        gqlCode: "FILE_NOT_FOUND",
+        when: "File ID is invalid"
+      }
+    }
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var ListFilesContract = defineQuery({
+  meta: {
+    key: "file.list",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["files", "list"],
+    description: "List files with filtering.",
+    goal: "Browse uploaded files.",
+    context: "Called to browse file library."
+  },
+  io: {
+    input: ListFilesInput,
+    output: ListFilesOutput
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var GetDownloadUrlContract = defineQuery({
+  meta: {
+    key: "file.downloadUrl",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["files", "download"],
+    description: "Get a presigned download URL.",
+    goal: "Generate a temporary URL for downloading.",
+    context: "Called when user wants to download a file."
+  },
+  io: {
+    input: GetDownloadUrlInput,
+    output: PresignedUrlModel,
+    errors: {
+      FILE_NOT_FOUND: {
+        description: "File does not exist",
+        http: 404,
+        gqlCode: "FILE_NOT_FOUND",
+        when: "File ID is invalid"
+      }
+    }
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var CreateVersionContract = defineCommand({
+  meta: {
+    key: "file.version.create",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["files", "version", "create"],
+    description: "Create a new version of a file.",
+    goal: "Upload a new version while preserving history.",
+    context: "Called when updating a document."
+  },
+  io: {
+    input: CreateVersionInput,
+    output: FileVersionModel,
+    errors: {
+      FILE_NOT_FOUND: {
+        description: "File does not exist",
+        http: 404,
+        gqlCode: "FILE_NOT_FOUND",
+        when: "File ID is invalid"
+      }
+    }
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var GetVersionsContract = defineQuery({
+  meta: {
+    key: "file.version.list",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["files", "version", "list"],
+    description: "Get file version history.",
+    goal: "View all versions of a file.",
+    context: "Called to browse file history."
+  },
+  io: {
+    input: GetVersionsInput,
+    output: GetVersionsOutput,
+    errors: {
+      FILE_NOT_FOUND: {
+        description: "File does not exist",
+        http: 404,
+        gqlCode: "FILE_NOT_FOUND",
+        when: "File ID is invalid"
+      }
+    }
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var AttachFileContract = defineCommand({
+  meta: {
+    key: "attachment.attach",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["files", "attachment", "attach"],
+    description: "Attach a file to an entity.",
+    goal: "Link a file to a business entity.",
+    context: "Called when associating files with entities."
+  },
+  io: {
+    input: AttachFileInput,
+    output: AttachmentModel,
+    errors: {
+      FILE_NOT_FOUND: {
+        description: "File does not exist",
+        http: 404,
+        gqlCode: "FILE_NOT_FOUND",
+        when: "File ID is invalid"
+      },
+      ATTACHMENT_EXISTS: {
+        description: "Attachment already exists",
+        http: 409,
+        gqlCode: "ATTACHMENT_EXISTS",
+        when: "File is already attached to this entity"
+      }
+    }
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var DetachFileContract = defineCommand({
+  meta: {
+    key: "attachment.detach",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["files", "attachment", "detach"],
+    description: "Detach a file from an entity.",
+    goal: "Remove a file association.",
+    context: "Called when removing file from entity."
+  },
+  io: {
+    input: DetachFileInput,
+    output: SuccessOutput,
+    errors: {
+      ATTACHMENT_NOT_FOUND: {
+        description: "Attachment does not exist",
+        http: 404,
+        gqlCode: "ATTACHMENT_NOT_FOUND",
+        when: "Attachment ID is invalid"
+      }
+    }
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var ListAttachmentsContract = defineQuery({
+  meta: {
+    key: "attachment.list",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["files", "attachment", "list"],
+    description: "List attachments for an entity.",
+    goal: "Get all files attached to an entity.",
+    context: "Called to display attached files."
+  },
+  io: {
+    input: ListAttachmentsInput,
+    output: ListAttachmentsOutput
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var CreatePresignedUrlContract = defineCommand({
+  meta: {
+    key: "file.presignedUrl.create",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["files", "presigned", "upload"],
+    description: "Create a presigned URL for direct upload.",
+    goal: "Enable direct-to-storage uploads.",
+    context: "Called for large file uploads."
+  },
+  io: {
+    input: CreatePresignedUrlInput,
+    output: PresignedUrlModel,
+    errors: {
+      FILE_TOO_LARGE: {
+        description: "File exceeds size limit",
+        http: 413,
+        gqlCode: "FILE_TOO_LARGE",
+        when: "Requested file size exceeds limit"
+      },
+      INVALID_MIME_TYPE: {
+        description: "MIME type not allowed",
+        http: 415,
+        gqlCode: "INVALID_MIME_TYPE",
+        when: "File type is not in allowed list"
+      }
+    }
+  },
+  policy: {
+    auth: "user"
+  }
+});
+
+// src/docs/files.docblock.ts
+import { registerDocBlocks } from "@contractspec/lib.contracts/docs";
+var filesDocBlocks = [
+  {
+    id: "docs.files.attachments",
+    title: "Files, Versions & Attachments",
+    summary: "Spec-first file management with storage adapters, versioning, presigned URLs, and polymorphic attachments for any entity.",
+    kind: "reference",
+    visibility: "public",
+    route: "/docs/files/attachments",
+    tags: ["files", "attachments", "storage", "versions"],
+    body: `## Capabilities
+
+- **Entities**: File, FileVersion, Attachment, UploadSession with retention, checksum, ACLs.
+- **Contracts**: upload/update/delete/list/get files; presigned upload/download; version create/list; attach/detach/list attachments.
+- **Storage**: pluggable adapters (Local, S3 placeholder + interface), in-memory for tests.
+- **Events**: file.uploaded/deleted, attachment.added/removed (see events export).
+
+## Usage
+
+1) Compose schema
+- Include \`filesSchemaContribution\` in your schema composition.
+
+2) Register contracts/events
+- Import contracts and events from \`@contractspec/lib.files\` in your spec registry.
+
+3) Wire storage
+- Provide a \`StorageAdapter\` implementation (local/in-memory or S3 via custom impl).
+- Use \`createStorageAdapter\` with config to instantiate.
+
+4) Attach to domain entities
+- Use \`attachment.attach\` with \`entityType/entityId\` to link files to deals, orders, runs, etc.
+
+## Example
+
+${"```"}ts
+import {
+  UploadFileContract,
+  AttachFileContract,
+  InMemoryStorageAdapter,
+} from '@contractspec/lib.files';
+
+// storage
+const storage = new InMemoryStorageAdapter();
+
+// upload
+const file = await storage.upload({
+  path: 'org-1/reports/r1.pdf',
+  content: Buffer.from(pdfBytes),
+  mimeType: 'application/pdf',
+});
+
+// attach
+await AttachFileContract; // register in spec to enable attach flows
+${"```"},
+
+## Guardrails
+
+- Enforce size/MIME limits in your handlers; avoid storing PII in paths.
+- Keep \`orgId\` scoped for multi-tenant isolation; prefer presigned URLs for public delivery.
+- Persist checksums for integrity; emit audit + events for access/retention changes.
+`
+  }
+];
+registerDocBlocks(filesDocBlocks);
+// src/entities/index.ts
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index
+} from "@contractspec/lib.schema";
+var StorageProviderEnum = defineEntityEnum({
+  name: "StorageProvider",
+  values: ["LOCAL", "S3", "GCS", "AZURE", "CLOUDFLARE"],
+  schema: "lssm_files",
+  description: "Storage backend provider."
+});
+var FileStatusEnum = defineEntityEnum({
+  name: "FileStatus",
+  values: [
+    "PENDING",
+    "UPLOADED",
+    "PROCESSING",
+    "READY",
+    "ERROR",
+    "DELETED"
+  ],
+  schema: "lssm_files",
+  description: "File processing status."
+});
+var FileEntity = defineEntity({
+  name: "File",
+  description: "An uploaded file.",
+  schema: "lssm_files",
+  map: "file",
+  fields: {
+    id: field.id({ description: "Unique file identifier" }),
+    name: field.string({ description: "Original file name" }),
+    mimeType: field.string({ description: "MIME type" }),
+    size: field.int({ description: "File size in bytes" }),
+    storageProvider: field.enum("StorageProvider", {
+      default: "LOCAL",
+      description: "Storage backend"
+    }),
+    storagePath: field.string({ description: "Path in storage backend" }),
+    storageKey: field.string({
+      isOptional: true,
+      description: "Storage key/bucket"
+    }),
+    checksum: field.string({
+      isOptional: true,
+      description: "SHA-256 checksum"
+    }),
+    etag: field.string({ isOptional: true, description: "Storage ETag" }),
+    status: field.enum("FileStatus", {
+      default: "PENDING",
+      description: "File status"
+    }),
+    isPublic: field.boolean({
+      default: false,
+      description: "Whether file is publicly accessible"
+    }),
+    expiresAt: field.dateTime({
+      isOptional: true,
+      description: "Auto-delete timestamp"
+    }),
+    ownerId: field.string({ description: "User who uploaded" }),
+    orgId: field.string({
+      isOptional: true,
+      description: "Organization scope"
+    }),
+    metadata: field.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    tags: field.json({
+      isOptional: true,
+      description: "Tags for categorization"
+    }),
+    width: field.int({
+      isOptional: true,
+      description: "Image width in pixels"
+    }),
+    height: field.int({
+      isOptional: true,
+      description: "Image height in pixels"
+    }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    versions: field.hasMany("FileVersion"),
+    attachments: field.hasMany("Attachment")
+  },
+  indexes: [
+    index.on(["ownerId"]),
+    index.on(["orgId"]),
+    index.on(["status"]),
+    index.on(["mimeType"]),
+    index.on(["storageProvider", "storagePath"])
+  ],
+  enums: [StorageProviderEnum, FileStatusEnum]
+});
+var FileVersionEntity = defineEntity({
+  name: "FileVersion",
+  description: "A version of a file.",
+  schema: "lssm_files",
+  map: "file_version",
+  fields: {
+    id: field.id({ description: "Unique version identifier" }),
+    fileId: field.foreignKey({ description: "Parent file" }),
+    version: field.int({ description: "Version number" }),
+    size: field.int({ description: "Version size in bytes" }),
+    storagePath: field.string({ description: "Path in storage backend" }),
+    checksum: field.string({
+      isOptional: true,
+      description: "SHA-256 checksum"
+    }),
+    comment: field.string({ isOptional: true, description: "Version comment" }),
+    changes: field.json({
+      isOptional: true,
+      description: "Change description"
+    }),
+    createdBy: field.string({ description: "User who created version" }),
+    createdAt: field.createdAt(),
+    file: field.belongsTo("File", ["fileId"], ["id"], { onDelete: "Cascade" })
+  },
+  indexes: [
+    index.on(["fileId", "version"]),
+    index.unique(["fileId", "version"], { name: "file_version_unique" })
+  ]
+});
+var AttachmentEntity = defineEntity({
+  name: "Attachment",
+  description: "Links a file to an entity.",
+  schema: "lssm_files",
+  map: "attachment",
+  fields: {
+    id: field.id({ description: "Unique attachment identifier" }),
+    fileId: field.foreignKey({ description: "Attached file" }),
+    entityType: field.string({
+      description: "Target entity type (deal, listing, etc.)"
+    }),
+    entityId: field.string({ description: "Target entity ID" }),
+    attachmentType: field.string({
+      isOptional: true,
+      description: "Type of attachment (document, image, avatar, etc.)"
+    }),
+    name: field.string({
+      isOptional: true,
+      description: "Display name (overrides file name)"
+    }),
+    description: field.string({
+      isOptional: true,
+      description: "Attachment description"
+    }),
+    order: field.int({ default: 0, description: "Display order" }),
+    metadata: field.json({
+      isOptional: true,
+      description: "Attachment-specific metadata"
+    }),
+    createdBy: field.string({ description: "User who created attachment" }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    file: field.belongsTo("File", ["fileId"], ["id"], { onDelete: "Cascade" })
+  },
+  indexes: [
+    index.on(["entityType", "entityId"]),
+    index.on(["fileId"]),
+    index.on(["entityType", "entityId", "attachmentType"]),
+    index.unique(["fileId", "entityType", "entityId"], {
+      name: "attachment_unique"
+    })
+  ]
+});
+var UploadSessionEntity = defineEntity({
+  name: "UploadSession",
+  description: "Tracks a multipart upload session.",
+  schema: "lssm_files",
+  map: "upload_session",
+  fields: {
+    id: field.id({ description: "Unique session identifier" }),
+    fileName: field.string({ description: "Target file name" }),
+    mimeType: field.string({ description: "Expected MIME type" }),
+    totalSize: field.int({ description: "Total file size" }),
+    uploadId: field.string({
+      isOptional: true,
+      description: "Storage upload ID"
+    }),
+    uploadedBytes: field.int({
+      default: 0,
+      description: "Bytes uploaded so far"
+    }),
+    uploadedParts: field.json({
+      isOptional: true,
+      description: "Completed part info"
+    }),
+    status: field.string({
+      default: '"pending"',
+      description: "Session status"
+    }),
+    error: field.string({
+      isOptional: true,
+      description: "Error message if failed"
+    }),
+    fileId: field.string({
+      isOptional: true,
+      description: "Resulting file ID"
+    }),
+    ownerId: field.string({ description: "User who initiated upload" }),
+    orgId: field.string({
+      isOptional: true,
+      description: "Organization scope"
+    }),
+    expiresAt: field.dateTime({ description: "Session expiry time" }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt()
+  },
+  indexes: [index.on(["status", "expiresAt"]), index.on(["ownerId"])]
+});
+var fileEntities = [
+  FileEntity,
+  FileVersionEntity,
+  AttachmentEntity,
+  UploadSessionEntity
+];
+var filesSchemaContribution = {
+  moduleId: "@contractspec/lib.files",
+  entities: fileEntities,
+  enums: [StorageProviderEnum, FileStatusEnum]
+};
+
+// src/events.ts
+import { ScalarTypeEnum as ScalarTypeEnum2, defineSchemaModel as defineSchemaModel2 } from "@contractspec/lib.schema";
+import { defineEvent } from "@contractspec/lib.contracts";
+var FileUploadedPayload = defineSchemaModel2({
+  name: "FileUploadedEventPayload",
+  description: "Payload when a file is uploaded",
+  fields: {
+    fileId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    mimeType: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    size: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+    storageProvider: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: false
+    },
+    ownerId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    orgId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    uploadedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
+  }
+});
+var FileUpdatedPayload = defineSchemaModel2({
+  name: "FileUpdatedEventPayload",
+  description: "Payload when a file is updated",
+  fields: {
+    fileId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    changes: { type: ScalarTypeEnum2.JSON(), isOptional: false },
+    updatedBy: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    updatedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
+  }
+});
+var FileDeletedPayload = defineSchemaModel2({
+  name: "FileDeletedEventPayload",
+  description: "Payload when a file is deleted",
+  fields: {
+    fileId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    storageProvider: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: false
+    },
+    storagePath: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    deletedBy: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    deletedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
+  }
+});
+var FileVersionCreatedPayload = defineSchemaModel2({
+  name: "FileVersionCreatedEventPayload",
+  description: "Payload when a file version is created",
+  fields: {
+    fileId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    versionId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    version: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    size: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+    createdBy: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    comment: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    createdAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
+  }
+});
+var AttachmentAttachedPayload = defineSchemaModel2({
+  name: "AttachmentAttachedEventPayload",
+  description: "Payload when a file is attached to an entity",
+  fields: {
+    attachmentId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    fileId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    entityType: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    entityId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    attachmentType: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: true
+    },
+    attachedBy: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    attachedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
+  }
+});
+var AttachmentDetachedPayload = defineSchemaModel2({
+  name: "AttachmentDetachedEventPayload",
+  description: "Payload when a file is detached from an entity",
+  fields: {
+    attachmentId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    fileId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    entityType: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    entityId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    detachedBy: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    detachedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
+  }
+});
+var UploadSessionStartedPayload = defineSchemaModel2({
+  name: "UploadSessionStartedEventPayload",
+  description: "Payload when an upload session starts",
+  fields: {
+    sessionId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    fileName: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    mimeType: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    totalSize: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+    ownerId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    startedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
+  }
+});
+var UploadSessionCompletedPayload = defineSchemaModel2({
+  name: "UploadSessionCompletedEventPayload",
+  description: "Payload when an upload session completes",
+  fields: {
+    sessionId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    fileId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    fileName: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    size: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+    completedAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
+  }
+});
+var FileUploadedEvent = defineEvent({
+  meta: {
+    key: "file.uploaded",
+    version: "1.0.0",
+    description: "A file has been uploaded.",
+    stability: "stable",
+    owners: ["@platform.files"],
+    tags: ["files", "upload"]
+  },
+  payload: FileUploadedPayload
+});
+var FileUpdatedEvent = defineEvent({
+  meta: {
+    key: "file.updated",
+    version: "1.0.0",
+    description: "A file has been updated.",
+    stability: "stable",
+    owners: ["@platform.files"],
+    tags: ["files", "update"]
+  },
+  payload: FileUpdatedPayload
+});
+var FileDeletedEvent = defineEvent({
+  meta: {
+    key: "file.deleted",
+    version: "1.0.0",
+    description: "A file has been deleted.",
+    stability: "stable",
+    owners: ["@platform.files"],
+    tags: ["files", "delete"]
+  },
+  payload: FileDeletedPayload
+});
+var FileVersionCreatedEvent = defineEvent({
+  meta: {
+    key: "file.version_created",
+    version: "1.0.0",
+    description: "A new file version has been created.",
+    stability: "stable",
+    owners: ["@platform.files"],
+    tags: ["files", "version", "create"]
+  },
+  payload: FileVersionCreatedPayload
+});
+var AttachmentAttachedEvent = defineEvent({
+  meta: {
+    key: "attachment.attached",
+    version: "1.0.0",
+    description: "A file has been attached to an entity.",
+    stability: "stable",
+    owners: ["@platform.files"],
+    tags: ["files", "attachment", "attach"]
+  },
+  payload: AttachmentAttachedPayload
+});
+var AttachmentDetachedEvent = defineEvent({
+  meta: {
+    key: "attachment.detached",
+    version: "1.0.0",
+    description: "A file has been detached from an entity.",
+    stability: "stable",
+    owners: ["@platform.files"],
+    tags: ["files", "attachment", "detach"]
+  },
+  payload: AttachmentDetachedPayload
+});
+var UploadSessionStartedEvent = defineEvent({
+  meta: {
+    key: "upload.session_started",
+    version: "1.0.0",
+    description: "An upload session has started.",
+    stability: "stable",
+    owners: ["@platform.files"],
+    tags: ["files", "upload", "session", "start"]
+  },
+  payload: UploadSessionStartedPayload
+});
+var UploadSessionCompletedEvent = defineEvent({
+  meta: {
+    key: "upload.session_completed",
+    version: "1.0.0",
+    description: "An upload session has completed.",
+    stability: "stable",
+    owners: ["@platform.files"],
+    tags: ["files", "upload", "session", "complete"]
+  },
+  payload: UploadSessionCompletedPayload
+});
+var FileEvents = {
+  FileUploadedEvent,
+  FileUpdatedEvent,
+  FileDeletedEvent,
+  FileVersionCreatedEvent,
+  AttachmentAttachedEvent,
+  AttachmentDetachedEvent,
+  UploadSessionStartedEvent,
+  UploadSessionCompletedEvent
+};
+
+// src/files.feature.ts
+import { defineFeature } from "@contractspec/lib.contracts";
+var FilesFeature = defineFeature({
+  meta: {
+    key: "files",
+    version: "1.0.0",
+    title: "File Management",
+    description: "File storage, attachments, and media processing with presigned URLs",
+    domain: "platform",
+    owners: ["@platform.files"],
+    tags: ["files", "upload", "attachments", "storage"],
+    stability: "stable"
+  },
+  operations: [
+    { key: "file.upload", version: "1.0.0" },
+    { key: "file.update", version: "1.0.0" },
+    { key: "file.delete", version: "1.0.0" },
+    { key: "file.get", version: "1.0.0" },
+    { key: "file.list", version: "1.0.0" },
+    { key: "file.downloadUrl", version: "1.0.0" },
+    { key: "file.presignedUrl.create", version: "1.0.0" },
+    { key: "file.version.create", version: "1.0.0" },
+    { key: "file.version.list", version: "1.0.0" },
+    { key: "attachment.attach", version: "1.0.0" },
+    { key: "attachment.detach", version: "1.0.0" },
+    { key: "attachment.list", version: "1.0.0" }
+  ],
+  events: [
+    { key: "file.uploaded", version: "1.0.0" },
+    { key: "file.updated", version: "1.0.0" },
+    { key: "file.deleted", version: "1.0.0" },
+    { key: "file.version_created", version: "1.0.0" },
+    { key: "attachment.attached", version: "1.0.0" },
+    { key: "attachment.detached", version: "1.0.0" },
+    { key: "upload.session_started", version: "1.0.0" },
+    { key: "upload.session_completed", version: "1.0.0" }
+  ],
+  presentations: [],
+  opToPresentation: [],
+  presentationsTargets: [],
+  capabilities: {
+    provides: [
+      { key: "files", version: "1.0.0" },
+      { key: "attachments", version: "1.0.0" }
+    ],
+    requires: [{ key: "identity", version: "1.0.0" }]
+  }
+});
+
+// src/storage/index.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as crypto from "node:crypto";
+
+class LocalStorageAdapter {
+  provider = "LOCAL";
+  basePath;
+  baseUrl;
+  constructor(options) {
+    this.basePath = options.basePath;
+    this.baseUrl = options.baseUrl;
+  }
+  async upload(options) {
+    const fullPath = path.join(this.basePath, options.path);
+    const dir = path.dirname(fullPath);
+    await fs.mkdir(dir, { recursive: true });
+    const content = typeof options.content === "string" ? Buffer.from(options.content, "base64") : options.content;
+    await fs.writeFile(fullPath, content);
+    const checksum = crypto.createHash("sha256").update(content).digest("hex");
+    return {
+      path: options.path,
+      size: content.length,
+      mimeType: options.mimeType,
+      checksum,
+      metadata: options.metadata
+    };
+  }
+  async download(filePath) {
+    const fullPath = path.join(this.basePath, filePath);
+    return fs.readFile(fullPath);
+  }
+  async delete(filePath) {
+    const fullPath = path.join(this.basePath, filePath);
+    await fs.unlink(fullPath);
+  }
+  async exists(filePath) {
+    const fullPath = path.join(this.basePath, filePath);
+    try {
+      await fs.access(fullPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getMetadata(filePath) {
+    const fullPath = path.join(this.basePath, filePath);
+    try {
+      const stat2 = await fs.stat(fullPath);
+      return {
+        path: filePath,
+        size: stat2.size,
+        mimeType: "application/octet-stream"
+      };
+    } catch {
+      return null;
+    }
+  }
+  async list(options) {
+    const dir = options?.prefix ? path.join(this.basePath, options.prefix) : this.basePath;
+    try {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+      const files = [];
+      for (const entry of entries) {
+        if (entry.isFile()) {
+          const filePath = options?.prefix ? path.join(options.prefix, entry.name) : entry.name;
+          const stat2 = await fs.stat(path.join(dir, entry.name));
+          files.push({
+            path: filePath,
+            size: stat2.size,
+            mimeType: "application/octet-stream"
+          });
+        }
+      }
+      const limit = options?.limit || files.length;
+      return {
+        files: files.slice(0, limit),
+        hasMore: files.length > limit
+      };
+    } catch {
+      return { files: [], hasMore: false };
+    }
+  }
+  async createPresignedUpload(options) {
+    const expiresIn = options.expiresIn || 3600;
+    const expiresAt = new Date(Date.now() + expiresIn * 1000);
+    return {
+      url: this.baseUrl ? `${this.baseUrl}/upload?path=${encodeURIComponent(options.path)}` : `/upload?path=${encodeURIComponent(options.path)}`,
+      fields: {
+        path: options.path,
+        mimeType: options.mimeType
+      },
+      expiresAt
+    };
+  }
+  async createPresignedDownload(options) {
+    const expiresIn = options.expiresIn || 3600;
+    const expiresAt = new Date(Date.now() + expiresIn * 1000);
+    return {
+      url: this.baseUrl ? `${this.baseUrl}/download/${options.path}` : `/download/${options.path}`,
+      expiresAt
+    };
+  }
+  getPublicUrl(filePath) {
+    if (!this.baseUrl)
+      return null;
+    return `${this.baseUrl}/${filePath}`;
+  }
+  async copy(sourcePath, destinationPath) {
+    const sourceFullPath = path.join(this.basePath, sourcePath);
+    const destFullPath = path.join(this.basePath, destinationPath);
+    const destDir = path.dirname(destFullPath);
+    await fs.mkdir(destDir, { recursive: true });
+    await fs.copyFile(sourceFullPath, destFullPath);
+    const stat2 = await fs.stat(destFullPath);
+    return {
+      path: destinationPath,
+      size: stat2.size,
+      mimeType: "application/octet-stream"
+    };
+  }
+}
+
+class S3StorageAdapter {
+  provider = "S3";
+  config;
+  constructor(options) {
+    this.config = options;
+  }
+  async upload(_options) {
+    throw new Error("S3 adapter requires @aws-sdk/client-s3. Install it and implement the upload method.");
+  }
+  async download(_filePath) {
+    throw new Error("S3 adapter requires @aws-sdk/client-s3. Install it and implement the download method.");
+  }
+  async delete(_filePath) {
+    throw new Error("S3 adapter requires @aws-sdk/client-s3. Install it and implement the delete method.");
+  }
+  async exists(_filePath) {
+    throw new Error("S3 adapter requires @aws-sdk/client-s3. Install it and implement the exists method.");
+  }
+  async getMetadata(_filePath) {
+    throw new Error("S3 adapter requires @aws-sdk/client-s3. Install it and implement the getMetadata method.");
+  }
+  async list(_options) {
+    throw new Error("S3 adapter requires @aws-sdk/client-s3. Install it and implement the list method.");
+  }
+  async createPresignedUpload(_options) {
+    throw new Error("S3 adapter requires @aws-sdk/client-s3. Install it and implement the createPresignedUpload method.");
+  }
+  async createPresignedDownload(_options) {
+    throw new Error("S3 adapter requires @aws-sdk/client-s3. Install it and implement the createPresignedDownload method.");
+  }
+  getPublicUrl(filePath) {
+    const { bucket, region, endpoint } = this.config;
+    if (endpoint) {
+      return `${endpoint}/${bucket}/${filePath}`;
+    }
+    return `https://${bucket}.s3.${region}.amazonaws.com/${filePath}`;
+  }
+  async copy(_sourcePath, _destinationPath) {
+    throw new Error("S3 adapter requires @aws-sdk/client-s3. Install it and implement the copy method.");
+  }
+}
+
+class InMemoryStorageAdapter {
+  provider = "LOCAL";
+  files = new Map;
+  async upload(options) {
+    const content = typeof options.content === "string" ? Buffer.from(options.content, "base64") : options.content;
+    const checksum = crypto.createHash("sha256").update(content).digest("hex");
+    const metadata = {
+      path: options.path,
+      size: content.length,
+      mimeType: options.mimeType,
+      checksum,
+      metadata: options.metadata
+    };
+    this.files.set(options.path, { content, metadata });
+    return metadata;
+  }
+  async download(filePath) {
+    const file = this.files.get(filePath);
+    if (!file) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    return file.content;
+  }
+  async delete(filePath) {
+    this.files.delete(filePath);
+  }
+  async exists(filePath) {
+    return this.files.has(filePath);
+  }
+  async getMetadata(filePath) {
+    const file = this.files.get(filePath);
+    return file?.metadata || null;
+  }
+  async list(options) {
+    const prefix = options?.prefix || "";
+    const files = [];
+    for (const [path2, file] of this.files) {
+      if (path2.startsWith(prefix)) {
+        files.push(file.metadata);
+      }
+    }
+    const limit = options?.limit || files.length;
+    return {
+      files: files.slice(0, limit),
+      hasMore: files.length > limit
+    };
+  }
+  async createPresignedUpload(options) {
+    const expiresAt = new Date(Date.now() + (options.expiresIn || 3600) * 1000);
+    return {
+      url: `/upload?path=${encodeURIComponent(options.path)}`,
+      fields: { path: options.path },
+      expiresAt
+    };
+  }
+  async createPresignedDownload(options) {
+    const expiresAt = new Date(Date.now() + (options.expiresIn || 3600) * 1000);
+    return {
+      url: `/download/${options.path}`,
+      expiresAt
+    };
+  }
+  getPublicUrl(filePath) {
+    return `/files/${filePath}`;
+  }
+  async copy(sourcePath, destinationPath) {
+    const source = this.files.get(sourcePath);
+    if (!source) {
+      throw new Error(`Source file not found: ${sourcePath}`);
+    }
+    const metadata = {
+      ...source.metadata,
+      path: destinationPath
+    };
+    this.files.set(destinationPath, { content: source.content, metadata });
+    return metadata;
+  }
+  clear() {
+    this.files.clear();
+  }
+}
+function createStorageAdapter(config) {
+  switch (config.provider) {
+    case "LOCAL":
+      if (!config.local) {
+        throw new Error("Local storage configuration required");
+      }
+      return new LocalStorageAdapter(config.local);
+    case "S3":
+      if (!config.s3) {
+        throw new Error("S3 storage configuration required");
+      }
+      return new S3StorageAdapter(config.s3);
+    default:
+      throw new Error(`Unsupported storage provider: ${config.provider}`);
+  }
+}
+export {
+  filesSchemaContribution,
+  fileEntities,
+  createStorageAdapter,
+  UploadSessionStartedEvent,
+  UploadSessionEntity,
+  UploadSessionCompletedEvent,
+  UploadFileContract,
+  UpdateFileContract,
+  StorageProviderEnum,
+  S3StorageAdapter,
+  PresignedUrlModel,
+  LocalStorageAdapter,
+  ListFilesContract,
+  ListAttachmentsContract,
+  InMemoryStorageAdapter,
+  GetVersionsContract,
+  GetFileContract,
+  GetDownloadUrlContract,
+  FilesFeature,
+  FileVersionModel,
+  FileVersionEntity,
+  FileVersionCreatedEvent,
+  FileUploadedEvent,
+  FileUpdatedEvent,
+  FileStatusEnum,
+  FileModel,
+  FileEvents,
+  FileEntity,
+  FileDeletedEvent,
+  DetachFileContract,
+  DeleteFileContract,
+  CreateVersionContract,
+  CreatePresignedUrlContract,
+  AttachmentModel,
+  AttachmentEntity,
+  AttachmentDetachedEvent,
+  AttachmentAttachedEvent,
+  AttachFileContract
+};