import { IncomingHttpHeaders } from "node:http";
import * as node_stream0 from "node:stream";
import { Readable, Writable } from "node:stream";
import { ObjectCannedACL, PutObjectCommandInput, ServerSideEncryption, StorageClass } from "@aws-sdk/client-s3";

//#region src/types.d.ts
type MaybePromise<T> = T | Promise<T>;
interface HttpError extends Error {
  code?: string;
  limit?: number;
  status?: number;
  statusCode?: number;
}
type PromiseCallback<T> = ((error: HttpError | null, result?: T) => void) & {
  promise?: Promise<T>;
};
interface StorageContainer {
  createdAt?: Date;
  etag?: string;
  lastModified?: Date;
  name: string;
  size?: number;
  [key: string]: unknown;
}
interface StorageFile {
  acl?: string;
  container: string;
  etag?: string;
  field?: string;
  lastModified?: Date;
  name: string;
  originalFilename?: string;
  providerResponse?: unknown;
  size?: number;
  type?: string;
  versionId?: string;
  [key: string]: unknown;
}
interface StorageRequest extends Readable {
  destroy(error?: Error): this;
  headers: IncomingHttpHeaders;
  method?: string;
  params: Record<string, string>;
  query?: Record<string, unknown>;
  resume(): this;
  unpipe(destination?: NodeJS.WritableStream): this;
  url?: string;
}
interface StorageResponse extends Writable {
  redirect(url: string): this | void;
  set(field: string, value: number | string): this | void;
  status(code: number): this;
  type(value: string): this | void;
}
type SignedUrlStrategy = 'local' | 'provider';
interface SignedUrlOptions {
  baseUrl?: string;
  enabled?: boolean;
  expiresIn?: number;
  secret?: string;
  strategy?: SignedUrlStrategy;
  validateBeforeSign?: boolean;
}
interface DownloadResponseOptions {
  responseCacheControl?: string;
  responseContentEncoding?: string;
  responseContentType?: string;
}
interface SignedUrlRequestOptions extends DownloadResponseOptions {
  strategy?: SignedUrlStrategy;
}
interface UploadFileContext extends StorageFile {
  request: StorageRequest;
  response: StorageResponse;
}
type FilenameResolver = (file: UploadFileContext, request: StorageRequest, response: StorageResponse) => string;
type AllowedContentTypesResolver = (file: UploadFileContext, request: StorageRequest, response: StorageResponse) => readonly string[] | undefined;
type MaxFileSizeResolver = (file: UploadFileContext, request: StorageRequest, response: StorageResponse) => number | undefined;
type AclResolver = (file: UploadFileContext, request: StorageRequest, response: StorageResponse) => ObjectCannedACL | string | undefined;
interface AwsUploadOptions {
  CacheControl?: PutObjectCommandInput['CacheControl'];
  SSECustomerAlgorithm?: PutObjectCommandInput['SSECustomerAlgorithm'];
  SSECustomerKey?: PutObjectCommandInput['SSECustomerKey'];
  SSECustomerKeyMD5?: PutObjectCommandInput['SSECustomerKeyMD5'];
  SSEKMSKeyId?: PutObjectCommandInput['SSEKMSKeyId'];
  ServerSideEncryption?: ServerSideEncryption | string;
  StorageClass?: StorageClass | string;
}
interface StorageUploadOptions extends AwsUploadOptions {
  acl?: AclResolver | ObjectCannedACL | string;
  allowedContentTypes?: AllowedContentTypesResolver | readonly string[];
  container?: string;
  contentType?: string;
  getFilename?: FilenameResolver;
  maxFieldsSize?: number;
  maxFileSize?: MaxFileSizeResolver | number;
  nameConflict?: 'makeUnique' | 'overwrite';
}
interface ProviderUploadRequest extends AwsUploadOptions {
  acl?: ObjectCannedACL | string;
  container: string;
  contentType?: string;
  remote: string;
}
interface ProviderDownloadRequest extends DownloadResponseOptions {
  container: string;
  end?: number;
  remote: string;
  start?: number;
}
interface SignedUrlRequest extends DownloadResponseOptions {
  container: string;
  expiresIn?: number;
  remote: string;
  request?: StorageRequest;
  strategy?: SignedUrlStrategy;
  validateBeforeSign?: boolean;
}
interface UploadStream extends Writable {
  abortUpload?: (error?: Error) => MaybePromise<void>;
}
interface StorageProvider {
  readonly config?: {
    signedUrl?: SignedUrlOptions;
  };
  createContainer(options: {
    name: string;
  }): Promise<StorageContainer>;
  destroyContainer(container: string): Promise<void>;
  download(options: ProviderDownloadRequest): Readable;
  getContainer(container: string): Promise<StorageContainer>;
  getContainers(): Promise<StorageContainer[]>;
  getFile(container: string, file: string): Promise<StorageFile>;
  getFiles(container: string, options?: Record<string, unknown>): Promise<StorageFile[]>;
  getSignedUrl?(options: SignedUrlRequest): MaybePromise<string | null>;
  removeFile(container: string, file: string): Promise<void>;
  upload(options: ProviderUploadRequest): UploadStream;
}
interface FilesystemProviderOptions extends StorageUploadOptions {
  provider?: 'filesystem';
  root: string;
  signedUrl?: SignedUrlOptions;
}
interface S3ProviderOptions extends StorageUploadOptions {
  accessKeyId?: string;
  connectionTimeout?: number;
  endpoint?: string;
  forcePathStyle?: boolean;
  key?: string;
  keyId?: string;
  maxAttempts?: number;
  maxSockets?: number;
  provider: 'amazon' | 'aws' | 's3';
  region?: string;
  retryMode?: 'adaptive' | 'legacy' | 'standard';
  requestTimeout?: number;
  secretAccessKey?: string;
  sessionToken?: string;
  signedUrl?: SignedUrlOptions;
  socketTimeout?: number;
  throwOnRequestTimeout?: boolean;
  uploadPartSize?: number;
  uploadQueueSize?: number;
  useAccelerateEndpoint?: boolean;
}
type StorageComponentOptions = FilesystemProviderOptions | S3ProviderOptions;
interface DataSourceLike {
  connector?: StorageServiceConnector;
  settings?: StorageComponentOptions;
}
interface StorageServiceConnector {
  DataAccessObject?: Record<string, unknown>;
  dataSource?: DataSourceLike;
  define?: (model: string, properties?: Record<string, unknown>, settings?: Record<string, unknown>) => void;
}
//#endregion
//#region src/storage-connector.d.ts
declare function initialize(dataSource: DataSourceLike, callback?: (error?: Error | null) => void): void;
//#endregion
//#region src/storage-service.d.ts
declare class StorageService {
  static modelName: string;
  readonly client: StorageProvider;
  readonly provider: string;
  private readonly uploadDefaults;
  constructor(options: StorageComponentOptions);
  getContainers(cb?: PromiseCallback<StorageContainer[]>): Promise<StorageContainer[]> | undefined;
  createContainer(options?: {
    Name?: string;
    name?: string;
  }, cb?: PromiseCallback<StorageContainer>): Promise<StorageContainer> | undefined;
  destroyContainer(container: string, cb?: PromiseCallback<void>): Promise<void> | undefined;
  getContainer(container: string, cb?: PromiseCallback<StorageContainer>): Promise<StorageContainer> | undefined;
  uploadStream(container?: string, file?: string, options?: Partial<StorageUploadOptions>): UploadStream;
  downloadStream(container?: string, file?: string, options?: {
    end?: number;
    start?: number;
  }): node_stream0.Readable;
  getFiles(container: string, options?: Record<string, unknown> | PromiseCallback<StorageFile[]>, cb?: PromiseCallback<StorageFile[]>): Promise<StorageFile[]> | undefined;
  getFile(container: string, file: string, cb?: PromiseCallback<StorageFile>): Promise<StorageFile> | undefined;
  removeFile(container: string, file: string, cb?: PromiseCallback<void>): Promise<void> | undefined;
  upload(container: string | StorageRequest, req?: StorageRequest, res?: StorageResponse | StorageUploadOptions, options?: StorageUploadOptions | PromiseCallback<UploadResponse>, cb?: PromiseCallback<UploadResponse>): Promise<UploadResponse> | undefined;
  download(container: string, file: string, req: StorageRequest, res: StorageResponse, options?: PromiseCallback<void> | SignedUrlRequestOptions, cb?: PromiseCallback<void>): Promise<void> | undefined;
  downloadSigned(container: string, file: string, req: StorageRequest, res: StorageResponse, options?: PromiseCallback<void> | SignedUrlRequestOptions, cb?: PromiseCallback<void>): Promise<void> | undefined;
  getSignedUrl(container: string, file: string, req: StorageRequest, res: StorageResponse, options?: PromiseCallback<{
    url: string;
  } | null> | SignedUrlRequestOptions, cb?: PromiseCallback<{
    url: string;
  } | null>): Promise<{
    url: string;
  } | null> | undefined;
}
type UploadResponse = {
  fields: Record<string, string[]>;
  files: Record<string, StorageFile[]>;
};
//#endregion
//#region src/index.d.ts
declare const StorageConnector: {
  StorageService: typeof StorageService;
  initialize: typeof initialize;
};
export = StorageConnector;