@webda/core 4.0.0-beta.1 → 4.0.0-beta.3

package/lib/services/binary.service.d.ts

@@ -0,0 +1,808 @@
+import { Readable } from "stream";
+import * as WebdaError from "../errors/errors.js";
+import { Service } from "./service.js";
+import { ServiceParameters } from "./serviceparameters.js";
+import { Counter } from "../metrics/metrics.js";
+import { IOperationContext } from "../contexts/icontext.js";
+import { IStore } from "../core/icore.js";
+import { MappingService } from "../stores/istore.js";
+import { type Model, type Storable, WEBDA_STORAGE } from "@webda/models";
+/**
+ * Represent basic EventBinary
+ */
+export interface EventBinary {
+    object: BinaryFileInfo;
+    service: BinaryService;
+}
+export interface EventBinaryUploadSuccess<T extends Storable = Storable> extends EventBinary {
+    target: T;
+}
+/**
+ * Sent before metadata are updated to allow alteration of the modification
+ */
+export interface EventBinaryMetadataUpdate<T extends Storable = Storable> extends EventBinaryUploadSuccess<T> {
+    target: T;
+    metadata: BinaryMetadata;
+}
+/**
+ * Emitted if binary does not exist
+ */
+export declare class BinaryNotFoundError extends WebdaError.CodeError {
+    /** Create a new BinaryNotFoundError
+     * @param hash - the binary hash
+     * @param storeName - the binary service name
+     */
+    constructor(hash: string, storeName: string);
+}
+export interface BinaryFileInfo<T extends object = {}> {
+    /**
+     * Hash of the binary
+     */
+    hash?: string;
+    /**
+     * Will be computed by the service
+     *
+     * hash of the content prefixed by 'WEBDA'
+     */
+    challenge?: string;
+    /**
+     * Size of the file
+     */
+    size: number;
+    /**
+     * Name of the file
+     */
+    name: string;
+    /**
+     * Mimetype
+     */
+    mimetype: string;
+    /**
+     * Metadatas stored along with the binary
+     */
+    metadata?: T;
+}
+/**
+ * Represent files attached to a model
+ */
+export type BinaryFiles<T extends object = {}> = BinaryFileInfo<T>[];
+/**
+ * Represent a file to store
+ * @WebdaSchema
+ */
+export declare abstract class BinaryFile<T extends object = {}> implements BinaryFileInfo<T> {
+    /**
+     * Current name
+     */
+    name: string;
+    /**
+     * Original name
+     */
+    originalname?: string;
+    /**
+     * Size of the binary
+     */
+    size: number;
+    /**
+     * Mimetype of the binary
+     */
+    mimetype: string;
+    /**
+     * Will be computed by the service
+     *
+     * hash of the content prefixed by 'WEBDA'
+     */
+    challenge?: string;
+    /**
+     * Will be computed by the service
+     *
+     * hash of the content
+     */
+    hash?: string;
+    /**
+     * Metadatas stored along with the binary
+     */
+    metadata?: T;
+    /** Create a new BinaryFile
+     * @param info - the binary file information
+     */
+    constructor(info: BinaryFileInfo<T>);
+    /**
+     * Set the information
+     * @param info - the information object
+     */
+    set(info: BinaryFileInfo<T>): void;
+    /**
+     * Retrieve a plain BinaryFileInfo object
+     * @returns the result
+     */
+    toBinaryFileInfo(): BinaryFileInfo<T>;
+    abstract get(): Promise<Readable>;
+    /**
+     * Create hashes
+     * @param buffer - the buffer
+     * @returns the result
+     */
+    getHashes(): Promise<{
+        hash: string;
+        challenge: string;
+    }>;
+}
+/** BinaryFile backed by a local filesystem path */
+export declare class LocalBinaryFile extends BinaryFile {
+    /**
+     * Path on the hard drive
+     */
+    path: string;
+    /** Create a new LocalBinaryFile
+     * @param filePath - path to the local file
+     */
+    constructor(filePath: string);
+    /**
+     * @override
+     */
+    get(): Promise<Readable>;
+}
+/** BinaryFile backed by an in-memory Buffer */
+export declare class MemoryBinaryFile extends BinaryFile {
+    /**
+     * Content
+     */
+    buffer: Buffer;
+    /** Create a new MemoryBinaryFile
+     * @param buffer - the binary content
+     * @param info - optional file information
+     */
+    constructor(buffer: Buffer | string, info?: Partial<BinaryFileInfo>);
+    /**
+     * @override
+     */
+    get(): Promise<Readable>;
+}
+/**
+ * Define the metadata for a Binary
+ */
+export type BinaryMetadata = any;
+/**
+ * This is a map used to retrieve binary
+ *
+ * @class BinaryMap
+ */
+export declare class BinaryMap<T extends object = {}> extends BinaryFile<T> {
+    /**
+     * Link to the binary store
+     */
+    [WEBDA_STORAGE]: {
+        service: BinaryService;
+    };
+    /** Create a new BinaryMap
+     * @param service - the binary service
+     * @param obj - the binary file information
+     */
+    constructor(service: BinaryService, obj: BinaryFileInfo<T>);
+    /**
+     * Get the binary data
+     *
+     * @returns the result
+     */
+    get(): Promise<Readable>;
+    /**
+     * Get into a buffer
+     * @returns the result
+     */
+    getAsBuffer(): Promise<Buffer>;
+    /**
+     * Download the binary to a path
+     *
+     * Shortcut to call {@link Binary.downloadTo} with current object
+     *
+     * @param filename - the filename
+     * @returns the result
+     */
+    downloadTo(filename: string): Promise<void>;
+}
+/**
+ * One Binary instance — single-cardinality binary attribute on a CoreModel.
+ *
+ * Tagged as a Behavior so the compiler picks it up via the same path as every
+ * other `@WebdaBehavior` class. Its `@Action`-decorated methods are exposed
+ * as model-scoped operations (`<Model>.<Attribute>.<Action>`) and routed by
+ * `RESTOperationsTransport.exposeBehaviorRoutes`.
+ *
+ * Constructor takes no required arguments because the transformer-emitted
+ * `__hydrateBehaviors` calls `new Binary()` with zero args before stamping
+ * the parent reference into `WEBDA_STORAGE["__parent__"]`. Legacy 2-arg
+ * usage (`new Binary(attribute, model)`) is still supported for direct
+ * callers and tests; when present, the constructor eagerly resolves the
+ * service and copies the existing model attribute value so callers can call
+ * `isEmpty()` and `hash`/`size` immediately.
+ *
+ * @readOnly
+ * @WebdaBehavior Webda/Binary
+ */
+export declare class Binary<T extends object = {}> extends BinaryMap<T> {
+    /** Create a new Binary.
+     *
+     * Callable with no arguments (the Behavior-hydration path the transformer
+     * emits) or with the legacy `(attribute, model)` pair for direct
+     * instantiation in tests / non-hydrated code.
+     * @param attribute - the model attribute name (legacy form)
+     * @param model - the parent model (legacy form)
+     */
+    constructor(attribute?: string, model?: Model);
+    /**
+     * Resolve the BinaryService lazily via the Behavior parent reference.
+     *
+     * The transformer-emitted `__hydrateBehaviors` writes
+     * `WEBDA_STORAGE["__parent__"]` after construction, and the per-Behavior
+     * `parent` getter (also emitted by the transformer) surfaces it as
+     * `this.parent`. We resolve the service on first call and cache it on the
+     * storage slot so subsequent calls don't re-walk the binary registry.
+     *
+     * @returns the BinaryService that owns this Binary's parent attribute
+     */
+    protected getService(): BinaryService;
+    /**
+     * Read the Behavior parent reference. The transformer-emitted `parent`
+     * getter on `@WebdaBehavior` classes returns the same slot, but Binary
+     * may also be used in code paths where the transformer hasn't run (e.g.
+     * unit tests that hand-roll instances), so we read the slot directly.
+     *
+     * @returns the parent reference or undefined
+     */
+    protected getParent(): {
+        instance: Storable;
+        attribute: string;
+    } | undefined;
+    /**
+     * isEmpty
+     * @returns the result
+     */
+    isEmpty(): any;
+    /**
+     * Ensure empty is set correctly.
+     *
+     * `BinaryFile`'s constructor calls `this.set(info)` before subclass class-field
+     * initializers run, so `this[WEBDA_STORAGE]` is still `undefined` the first
+     * time we get here when constructing a fresh `new Binary()` (the no-args
+     * path used by the transformer's `__hydrateBehaviors`). Initialize the
+     * slot lazily on the first set call to keep that boot path crash-free —
+     * the class-field initializer on `BinaryMap` will then OVERWRITE this on
+     * its way back from super, but that's fine because it preserves the
+     * shape `{ service?, empty?, ... }` and we've passed through `set` only
+     * once at this point.
+     *
+     * @param info - the information object
+     */
+    set(info: BinaryFileInfo<T>): void;
+    /**
+     * Replace the binary by uploading a new file. Direct programmatic use
+     * (non-HTTP). Equivalent to the `attach(...)` HTTP action minus the
+     * context handling.
+     * @param file - the binary file to upload
+     * @returns the result
+     */
+    upload(file: BinaryFile<T>): Promise<void>;
+    /**
+     * Delete this binary from storage and clear local state.
+     *
+     * Exposed as a Behavior `@Action` (DELETE on `{uuid}/<attribute>/{hash}`).
+     * The URL `{hash}` must match the current binary's hash; this guards
+     * against accidental deletes when the client raced a metadata update.
+     *
+     * Migrated from `DomainService.binaryAction` (action="delete",
+     * single-cardinality branch).
+     * @param hash - the URL-supplied hash; must match `this.hash`
+     */
+    delete(hash: string): Promise<void>;
+    /**
+     * Direct (multipart / raw) upload from an HTTP request.
+     *
+     * `POST /<plural>/{uuid}/<attribute>` — accepts the binary content as the
+     * request body, hashes it, stores it on the BinaryService, and updates
+     * this Binary's metadata. Returns early if the new content's hash matches
+     * what we already hold (idempotent on duplicate uploads).
+     *
+     * Migrated from `DomainService.binaryPut`; the parent-loading step is
+     * unnecessary here because the Behavior is already attached to its parent
+     * by `__hydrateBehaviors`.
+     */
+    attach(): Promise<void>;
+    /**
+     * Challenge-based upload handshake.
+     *
+     * `PUT /<plural>/{uuid}/<attribute>` — the client sends `{ hash, challenge,
+     * size?, name?, mimetype?, metadata? }`; we ask the BinaryService for a
+     * pre-signed upload URL (or a "done" flag if dedup matched) and return it.
+     *
+     * Migrated from `DomainService.binaryChallenge`.
+     * @param body - the challenge body forwarded by `resolveArguments`; falls
+     *   back to `context.getInput()` when undefined.
+     * @returns `{ url?, method?, headers?, done, md5 }`
+     */
+    attachChallenge(body?: BinaryFileInfo & {
+        hash: string;
+        challenge: string;
+    }): Promise<any>;
+    /**
+     * Stream the binary to the response, or 302-redirect to a signed URL.
+     *
+     * `GET /<plural>/{uuid}/<attribute>` — if the underlying BinaryService
+     * supports redirect URLs (e.g. S3) we 302 to the signed URL; otherwise we
+     * pipe the bytes directly through the response.
+     *
+     * Named `download` (not `get`) so the parent `BinaryMap.get(): Readable`
+     * accessor isn't shadowed — Behavior @Action methods can't change the
+     * parent type's contract, and a plain `get()` overload that returns
+     * `void` would break callers that consume the Readable.
+     *
+     * Migrated from `DomainService.binaryGet` (single-cardinality branch).
+     */
+    download(): Promise<void>;
+    /**
+     * Return a JSON `{ Location, Map }` describing where to fetch the binary.
+     *
+     * `GET /<plural>/{uuid}/<attribute>/url` — variant of `download()` that
+     * returns the URL as JSON instead of redirecting. Used by clients that
+     * want to discover the URL without following the redirect.
+     *
+     * Migrated from `DomainService.binaryGet`'s `returnUrl` branch.
+     * @returns `{ Location, Map }`
+     */
+    downloadUrl(): Promise<{
+        Location: string | undefined;
+        Map: BinaryMap<T>;
+    }>;
+    /**
+     * Update the metadata sidecar attached to this binary.
+     *
+     * `PUT /<plural>/{uuid}/<attribute>/{hash}` — verifies the URL `{hash}`
+     * matches the current binary, applies the new metadata, and persists via
+     * `parent.instance.patch(...)`. Metadata payload is capped at 4 KB to
+     * mirror the existing `DomainService.binaryAction` rule.
+     *
+     * Migrated from `DomainService.binaryAction` (action="metadata" branch).
+     * @param hash - the URL-supplied hash; must match `this.hash`
+     * @param metadata - the new metadata blob (≤ 4 KB JSON)
+     */
+    setMetadata(hash: string, metadata: T): Promise<void>;
+    /**
+     * Return undefined at runtime if no hash; the type annotation deliberately
+     * narrows to the populated shape so the schema generator follows
+     * `BinaryFileInfo<T>` for the Output/Stored schemas.
+     * @returns the result
+     */
+    toJSON(): BinaryFileInfo<T>;
+    get parent(): any;
+}
+/**
+ * Define a Binary map stored in a Binaries collection
+ */
+export declare class BinariesItem<T extends object = {}> extends BinaryMap<T> {
+    [WEBDA_STORAGE]: {
+        service: BinaryService;
+        parent: BinariesImpl<T>;
+    };
+    /** Create a new BinariesItem
+     * @param parent - the parent binaries collection
+     * @param info - the binary file information
+     */
+    constructor(parent: BinariesImpl<T>, info: BinaryFileInfo<T>);
+    /**
+     * Replace the binary
+     * @param id - the identifier
+     * @param ctx - the operation context
+     * @param file - the file path
+     * @returns the result
+     */
+    upload(file: BinaryFile<T>): Promise<void>;
+    /**
+     * Delete the binary, if you need to replace just use upload
+     * @returns the result
+     */
+    delete(): Promise<void>;
+}
+/**
+ * Define a collection of Binary — many-cardinality binary attribute.
+ *
+ * Tagged as a Behavior so its `@Action` methods register as
+ * `<Model>.<Attribute>.<Action>` operations alongside Single-Binary ones.
+ * Inherits from `Array<BinariesItem<T>>` so it preserves array semantics
+ * (iteration, indexed access, JSON.stringify-as-array). The transformer
+ * detects this Array-subclass shape and emits a push-based hydration
+ * coercion — see `behaviors.ts:createHydrationBlock`.
+ *
+ * @readOnly
+ * @WebdaBehavior Webda/BinariesImpl
+ */
+export declare class BinariesImpl<T extends object = {}> extends Array<BinariesItem<T>> {
+    protected [WEBDA_STORAGE]: {
+        service?: BinaryService;
+        [key: string]: any;
+    };
+    /**
+     * Bind this collection to a model and attribute, populating from existing binary data.
+     *
+     * Legacy entry-point used by code that constructs a `BinariesImpl()`
+     * directly (tests, manual instantiation). The Behavior-hydration path the
+     * transformer emits writes `WEBDA_STORAGE["__parent__"]` instead and
+     * never calls `assign`.
+     *
+     * @param model - the model to use
+     * @param attribute - the attribute name
+     * @returns this for chaining
+     */
+    assign(model: Model, attribute: string): this;
+    /**
+     * Resolve the BinaryService lazily via the Behavior parent reference.
+     *
+     * Mirrors `Binary.getService()`. The transformer-emitted parent slot
+     * (`WEBDA_STORAGE["__parent__"]`) is the source of truth.
+     *
+     * @returns the BinaryService for this collection's parent attribute
+     */
+    protected getService(): BinaryService;
+    /**
+     * Read the Behavior parent reference. Mirrors `Binary.getParent()`.
+     * @returns the parent reference or undefined
+     */
+    protected getParent(): {
+        instance: Storable;
+        attribute: string;
+    } | undefined;
+    /** @throws Readonly collection */
+    pop(): BinariesItem<T>;
+    /** @throws Readonly collection */
+    slice(): BinariesItem<T>[];
+    /** @throws Readonly collection */
+    unshift(): number;
+    /** @throws Readonly collection */
+    shift(): BinariesItem<T>;
+    /**
+     * Add binary items, wrapping plain objects in BinariesItem
+     * @param args - additional arguments
+     * @returns the result number
+     */
+    push(...args: any[]): number;
+    /**
+     * Upload a file to this model. Direct programmatic API (non-HTTP).
+     * @param file - the file path
+     * @param replace - whether to replace existing
+     */
+    upload(file: BinaryFile<T>, replace?: BinariesItem<T>): Promise<void>;
+    /**
+     * Delete an item by reference or index. Direct programmatic API (non-HTTP).
+     * @param item - the item to delete
+     */
+    delete(item: BinariesItem<T>): Promise<void>;
+    /**
+     * Direct (multipart / raw) upload from an HTTP request. Pushes a new item
+     * onto the collection.
+     *
+     * `POST /<plural>/{uuid}/<attribute>` — same shape as `Binary.attach` but
+     * pushes the new file rather than replacing the existing one.
+     * Migrated from `DomainService.binaryPut` (MANY-cardinality branch).
+     */
+    attach(): Promise<void>;
+    /**
+     * Challenge-based upload handshake for the next item.
+     *
+     * `PUT /<plural>/{uuid}/<attribute>` — request a pre-signed upload URL
+     * for a new item identified by `{ hash, challenge, ... }`. Returns the
+     * URL or a `done` flag if dedup matched.
+     *
+     * Migrated from `DomainService.binaryChallenge` (MANY-cardinality branch).
+     * @param body - the challenge body; falls back to `context.getInput()`
+     * @returns `{ url?, method?, headers?, done, md5 }`
+     */
+    attachChallenge(body?: BinaryFileInfo & {
+        hash: string;
+        challenge: string;
+    }): Promise<any>;
+    /**
+     * Stream a single item to the response, or 302-redirect to a signed URL.
+     *
+     * `GET /<plural>/{uuid}/<attribute>/{index}` — locates the item by `index`
+     * and behaves like `Binary.get` for that single entry.
+     *
+     * Migrated from `DomainService.binaryGet` (MANY-cardinality branch).
+     * @param index - the item position in the collection
+     */
+    get(index: number): Promise<void>;
+    /**
+     * Return a `{ Location, Map }` JSON for a single item.
+     *
+     * `GET /<plural>/{uuid}/<attribute>/{index}/url` — variant of `get` that
+     * returns the URL as JSON instead of redirecting / streaming.
+     *
+     * Migrated from `DomainService.binaryGet`'s `returnUrl` branch
+     * (MANY-cardinality).
+     * @param index - the item position in the collection
+     * @returns `{ Location, Map }`
+     */
+    getUrl(index: number): Promise<{
+        Location: string | undefined;
+        Map: BinaryMap<T>;
+    }>;
+    /**
+     * Delete a single item by `(index, hash)`.
+     *
+     * `DELETE /<plural>/{uuid}/<attribute>/{index}/{hash}` — the URL `{hash}`
+     * must match the item at `{index}`. Removes from storage and from the
+     * in-memory collection.
+     *
+     * Migrated from `DomainService.binaryAction` (action="delete",
+     * MANY-cardinality branch).
+     * @param index - the item position
+     * @param hash - the URL-supplied hash; must match `this[index].hash`
+     */
+    deleteAt(index: number, hash: string): Promise<void>;
+    /**
+     * Update the metadata sidecar of a single item.
+     *
+     * `PUT /<plural>/{uuid}/<attribute>/{index}/{hash}` — verifies the hash,
+     * applies the new metadata, and persists via `parent.instance.patch(...)`.
+     * Metadata payload capped at 4 KB.
+     *
+     * Migrated from `DomainService.binaryAction` (action="metadata",
+     * MANY-cardinality branch).
+     * @param index - the item position
+     * @param hash - the URL-supplied hash; must match `this[index].hash`
+     * @param metadata - the new metadata blob (≤ 4 KB JSON)
+     */
+    setMetadata(index: number, hash: string, metadata?: T): Promise<void>;
+    /**
+     * Native array serialization. The transformer adds a Behavior-style
+     * `toJSON` to every Behavior class unless the author defines one;
+     * we override it explicitly so JSON.stringify produces a plain array of
+     * items rather than an object keyed by indices.
+     * @returns the result array
+     */
+    toJSON(): BinariesItem<T>[];
+    get parent(): any;
+}
+/**
+ * Type-level alias for `BinariesImpl<T>`.
+ *
+ * Models declare `photos: Binaries<...>` rather than the more verbose
+ * `photos: BinariesImpl<...>`; the compiler resolves this alias to the
+ * `BinariesImpl` class declaration, picks up the `@WebdaBehavior` JSDoc
+ * tag there, and registers the attribute as a Behavior. The runtime
+ * shape (push/splice/index access plus `attach`, `attachChallenge`, `get`,
+ * `getUrl`, `deleteAt`, `setMetadata`, `upload`) comes from
+ * `BinariesImpl` directly.
+ */
+export type Binaries<T extends object = {}> = BinariesImpl<T>;
+/** Parameters for BinaryService, defining model mappings and max upload size */
+export declare class BinaryParameters extends ServiceParameters {
+    /**
+     * max file size
+     */
+    protected _maxFileSize: number;
+    /**
+     * Define the map of models
+     * * indicates all models
+     *
+     * key is a Store name
+     * the string[] represent all valids attributes to store files in * indicates all attributes
+     */
+    models: {
+        [key: string]: string[];
+    };
+    /**
+     * Define the maximum filesize to accept as direct upload
+     *
+     * @default 10 MB
+     */
+    set maxFileSize(value: number | string);
+    /**
+     * Get the max file size in bytes
+     * @returns the result number
+     */
+    get maxFileSize(): number;
+    /**
+     * Load parameters with defaults for model mappings and max file size
+     * @param params - the service parameters
+     * @returns this for chaining
+     */
+    load(params?: any): this;
+}
+export type BinaryEvents = {
+    /**
+     * Emitted when someone download a binary
+     */
+    "Binary.Get": EventBinary;
+    "Binary.UploadSuccess": EventBinaryUploadSuccess;
+    "Binary.MetadataUpdate": EventBinaryMetadataUpdate;
+    "Binary.MetadataUpdated": EventBinaryUploadSuccess;
+    "Binary.Create": EventBinaryUploadSuccess;
+    "Binary.Delete": EventBinary;
+};
+/**
+ * Define a BinaryModel with infinite field for binary map
+ */
+export type CoreModelWithBinary<T = {
+    [key: string]: BinaryMap[] | BinaryMap;
+}> = Model & T;
+/**
+ * This is an abstract service to represent a storage of files
+ * The binary allow you to expose this service as HTTP
+ *
+ * It supports two modes:
+ *  - attached to a CoreModel (attach, detach, reattach)
+ *  - pure storage with no managed id (read, write, delete)
+ *
+ * As we have deduplication builtin you can get some stats
+ * - getUsageCount(hash)
+ * - getUsageCountForRaw()
+ * - getUsageCountForMap()
+ *
+ * The Binary storage should store only once a binary and reference every object that are used by this binary, so it can be cleaned.
+ *
+ *
+ * @see FileBinary
+ * @see S3Binary
+ *
+ * @exports
+ * @abstract
+ * @WebdaModda Binary
+ */
+export declare abstract class BinaryService<T extends BinaryParameters = BinaryParameters, E extends BinaryEvents = BinaryEvents> extends Service<T, E> implements MappingService<BinaryMap> {
+    _lowercaseMaps: any;
+    metrics: {
+        upload: Counter;
+        download: Counter;
+        delete: Counter;
+        metadataUpdate: Counter;
+    };
+    /**
+     * @override
+     */
+    initMetrics(): void;
+    /**
+     * Get a UrlFromObject
+     *
+     * @param binaryMap - the binary map definition
+     * @param _context - the execution context
+     * @param _expires - the expiration time
+     * @returns the result
+     */
+    getRedirectUrlFromObject(binaryMap: BinaryMap, _context: IOperationContext, _expires?: number): Promise<null | string>;
+    /**
+     * Define if binary is managed by the store
+     * @param modelName - the model name
+     * @param attribute - the attribute name
+     * @returns -1 if not managed, 0 if managed but by default, 1 if managed and in the map, 2 if explicit with attribute and model
+     */
+    handleBinary(modelName: string, attribute: string): -1 | 0 | 1 | 2;
+    /**
+     * When you store a binary to be able to retrieve it you need to store the information into another object
+     *
+     * If you have a User object define like this : User = {'name': 'Remi', 'uuid': 'Loopingz'}
+     * You will call the `store(userStore, 'Loopingz', 'images', filedata, {'type':'profile'})`
+     * After a successful call the object will look like
+     * ```
+     * User = {
+     *  'name': 'Remi',
+     *  'uuid': 'Loopingz',
+     *  'images': [
+     *    {'type':'profile','hash':'a12545...','size':1245,'mime':'application/octet'}
+     *   ]
+     * }
+     * ```
+     *
+     *
+     * @param {CoreModel} object The object uuid to get from the store
+     * @param {String} property The object property to add the file to
+     * @param {Object} file The file by itself
+     * @param {Object} metadata to add to the binary object
+     * @emits 'binaryCreate'
+     */
+    abstract store(object: Storable, property: string, file: BinaryFile, metadata?: BinaryMetadata): Promise<void>;
+    /**
+     * The store can retrieve how many time a binary has been used
+     */
+    abstract getUsageCount(hash: string): Promise<number>;
+    /**
+     * Delete a binary
+     *
+     * @param {CoreModel} object The object uuid to get from the store
+     * @param {String} property The object property to add the file to
+     * @param {Number} index The index of the file to change in the property
+     * @emits 'binaryDelete'
+     */
+    abstract delete(object: Storable, property: string, index?: number): Promise<void>;
+    /**
+     * Get a binary
+     *
+     * @param {Object} info The reference stored in your target object
+     * @emits 'binaryGet'
+     * @returns the result
+     */
+    get(info: BinaryMap): Promise<Readable>;
+    /**
+     * Download a binary to a file
+     *
+     * @param {Object} info The reference stored in your target object
+     * @param {String} filepath to save the binary to
+     * @param filename - the filename
+     */
+    downloadTo(info: BinaryMap, filename: any): Promise<void>;
+    abstract _get(info: BinaryMap): Promise<Readable>;
+    /**
+     * Based on the raw Map init a BinaryMap
+     * @param obj - the target object
+     * @returns the result map
+     */
+    newModel(obj: any): BinaryMap;
+    /**
+     * Read a stream to a buffer
+     *
+     * @param stream - the stream
+     * @returns the result
+     */
+    static streamToBuffer(stream: Readable): Promise<Buffer>;
+    /**
+     * Check if a map is defined
+     *
+     * @param name - the name to use
+     * @param property - the property name
+     * @param object - the target object
+     */
+    protected checkMap(object: Model, property: string): void;
+    /**
+     * Ensure events are sent correctly after an upload and update the BinaryFileInfo in targetted object
+     * @param object - the target object
+     * @param property - the property name
+     * @param fileInfo - the file information
+     */
+    uploadSuccess(object: CoreModelWithBinary, property: string, fileInfo: BinaryFileInfo | {
+        toBinaryFileInfo: () => BinaryFileInfo;
+    }): Promise<void>;
+    /**
+     * Cascade delete the object
+     *
+     * @param info of the map
+     * @param uuid of the object
+     */
+    abstract cascadeDelete(info: BinaryMap, uuid: string): Promise<void>;
+    /**
+     *
+     * @param targetStore - the target store
+     * @param object - the target object
+     * @param property - the property name
+     * @param index - the index
+     * @returns the result
+     */
+    deleteSuccess(object: CoreModelWithBinary, property: string, index?: number): Promise<void>;
+    /**
+     * Get file either from multipart post or raw
+     * @param req - the request
+     * @returns the result
+     */
+    getFile(req: IOperationContext): Promise<BinaryFile>;
+    /**
+     * Return the name of the service for OpenAPI
+     * @returns the result string
+     */
+    protected getOperationName(): string;
+    /**
+     * Based on the request parameter verify it match a known mapping
+     * @param ctx - the operation context
+     * @returns the result
+     */
+    protected verifyMapAndStore(ctx: IOperationContext): IStore;
+    /**
+     * By default no challenge is managed so throws 404
+     *
+     * @param args - additional arguments
+     */
+    putRedirectUrl(...args: any): Promise<{
+        url: string;
+        method?: string;
+        headers?: {
+            [key: string]: string;
+        };
+    }>;
+}
+//# sourceMappingURL=binary.service.d.ts.map