@palmetto/media-sdk 0.1.0

package/README.md

@@ -0,0 +1,155 @@
+# Media API SDK
+
+## Installation
+
+Install the SDK and peer dependencies:
+
+```sh
+yarn add @palmetto/result @palmetto/base-sdk-client @palmetto/media-sdk
+```
+
+## Usage
+
+### Create a client instance
+
+```ts
+import { MediaClient } from "@palmetto/media-sdk";
+
+const client = new MediaClient({
+  apiUrl: app.config("media.api.url"),
+  authToken: app.config("media.api.userToken"),
+});
+```
+
+### Create a new media
+
+Public media and private media work similar ways. Use the `isPublic` flag to indicate if the media can be access publicly by any internet user.
+
+Properties of `CreateMediaInput`:
+
+- `filename`: name of the file to store. The name does not have to be unique. Media API creates unique names for all media.
+- `contentType`: the MIME type of the file. Valid types:
+  - application/pdf
+  - image/png
+  - image/jpeg
+  - image/gif
+  - image/svg+xml
+  - video/mp4
+- `isPublic: true`
+  - the file is stored in a publicly accessible bucket
+  - `publicUrl` is defined in the response with a URL that can be placed on any web page.
+- `isPublic: false`
+  - the file is stored in a separate private bucket
+  - `publicUrl` is undefined, and you must request a signed URL to access the media.
+- `expiresAfter`: (optional) the time after which the file should be deleted
+  - the cleanup process isn't exact. Files may live several hours after the expiresAfter value
+- `permissions`: (optional) an array of Users API grants (entity permissions) allowing access to the media
+  - eg: `["customer:customer"]` grants access to any user with `customer:customer` grant.
+- `associatedEntities`: (optional) an array of associated entities for the media
+
+```ts
+import { CreateMediaInput } from "@palmetto/media-sdk";
+
+const file: File = {}; // get a reference to the <input type="file"> from the browser form
+
+const media: CreateMediaInput = {
+  filename: file.name,
+  contentType: file.type as CreateMediaInput["contentType"],
+  isPublic: true,
+  expiresAfter: new Date(Date.now() + 24 * 3600 * 1000), // this media is deleted after 24 hours
+};
+
+// create the media itself
+const createdMedia = await client.createMedia(media);
+
+if (!createdMedia.ok) {
+  toast.error("Failed to create media:", createdMedia.error);
+  return;
+}
+
+try {
+  // next upload the media using the signed URL
+  const fetchResponse = await fetch(
+    new Request(createdMedia.data.signedUrlForUpload.url, {
+      headers: createdMedia.data.signedUrlForUpload.headers,
+      body: file,
+      method: "PUT",
+    }),
+  );
+
+  if (!fetchResponse.ok) {
+    toast.error("Failed to upload media. Please try again.");
+    return;
+  }
+} catch (error) {
+  toast.error("Failed to upload media. Please try again.");
+  return;
+}
+```
+
+### getMediaById
+
+Use `getMediaById` to access the media details and get a URL to download the file. See examples below.
+
+- `id` the media ID
+- `includeSignedUrl`: set to true to return the `signedUrlForDownload` in the response. (default: false)
+- `inline`: set to true so that the download is done inline, false crafts the file download as an attachment. (default: false)
+
+### Opening the media in a browser
+
+For public media, you can use the `publicUrl` property to access the media. Private media must use a signed URL to download.
+
+#### Public media
+
+Public media URLs never change. They are valid until the media is deleted.
+
+```ts
+const { publicUrl } = createdMedia.data;
+
+window.location.href = publicUrl;
+```
+
+#### Private media
+
+Private media you must access using a signed URL. The signed URL is only valid for a few minutes so you must download the file soon after requesting the URL.
+
+```ts
+const getMediaResult = await client.getMediaById({
+  id: createdMedia.data.id,
+  includeSignedUrl: true,
+  inline: false,
+});
+
+if (!getMediaResult.ok) {
+  toast.error("Failed to fetch media details:", getMediaResult.error);
+  return;
+}
+
+const { signedUrlForDownload } = getMediaResult.data;
+
+window.location.href = signedUrlForDownload;
+```
+
+### Permissions
+
+Media have permissions. By default, only the API user that created the media can update or delete the media.
+You can use the `permissions` property to allow other API users with that permission to modify or delete the media.
+
+```ts
+const media: CreateMediaInput = {
+  filename: file.name,
+  contentType: file.type as CreateMediaInput["contentType"],
+  isPublic: false,
+  permissions: ["customer:customer"],
+};
+```
+
+This example allows any user with `customer:customer` entity grant to access the media. This access is global, it doesn't know that the media belongs to a specific customer, for example. [This feature may be improved later on].
+
+### Update Media
+
+You can update a media's permissions, associatedEntities and expiresAfter using `updatedMediaById`. Your user must have created the media, or have the `write` operation for one of the permissions on the media.
+
+### Delete media
+
+You can delete a media using `deleteMediaById`. Your user must have created the media, or have the `delete` operation for one of the permissions on the media.

package/dist/__generated__/schema.d.ts

@@ -0,0 +1,554 @@
+export interface paths {
+    "/api/health": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["HealthController_getHealth"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/media": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Create a new media */
+        post: operations["createMedia"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/media/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get a media by ID */
+        get: operations["getMediaById"];
+        put?: never;
+        post?: never;
+        /** Delete a media by ID */
+        delete: operations["deleteMediaById"];
+        options?: never;
+        head?: never;
+        /** Update a media by ID */
+        patch: operations["updateMediaById"];
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        InternalServerErrorDto: {
+            /**
+             * @example InternalServerError
+             * @constant
+             */
+            error: "InternalServerError";
+            /**
+             * @example 500
+             * @constant
+             */
+            statusCode: 500;
+            /** @example An unexpected service error occurred */
+            message: string;
+            /** @example Technical error description */
+            reason: string;
+        };
+        HealthStatusDto: {
+            ok: boolean;
+            checks: {
+                database: boolean;
+            };
+        };
+        UnauthorizedErrorDto: {
+            /**
+             * @example Unauthorized
+             * @constant
+             */
+            error: "Unauthorized";
+            /**
+             * @example 401
+             * @constant
+             */
+            statusCode: 401;
+            /** @example You must log in to perform that action */
+            message: string;
+            /** @example Technical error description */
+            reason: string;
+        };
+        CreateMediaDto: {
+            /** @description The name of the attachment file. */
+            filename: string;
+            /** @description Indicates whether the media is publicly accessible. */
+            isPublic: boolean;
+            /**
+             * @description The MIME type of the attachment content.
+             * @enum {string}
+             */
+            contentType: "application/pdf" | "image/png" | "image/jpeg" | "image/gif" | "image/svg+xml" | "video/mp4";
+            /** @description A list of entities associated with the media, specifying the type and ID of each associated entity. This field is optional and can be used to link the media to other entities in the system. */
+            associatedEntities?: {
+                /** @description The type of the associated entity */
+                type: string;
+                /** @description The id of the associated entity */
+                id: string;
+            }[];
+            /** @description The permissions for the media, specifying which users permissions are required. (eg: ["customers:customer"]) */
+            permissions?: string[];
+            /**
+             * Format: date-time
+             * @description The date and time after which the media should expire and be automatically deleted. This field is optional and can be used to set a specific expiration time for the media.
+             */
+            expiresAfter?: string;
+        };
+        CreatedMediaDto: {
+            filename: string;
+            contentType: string;
+            bucket: string;
+            bucketPath: string;
+            isPublic: boolean;
+            /** Format: uri */
+            publicUrl?: string;
+            owner: {
+                /** @description The type of the associated entity */
+                type: string;
+                /** @description The id of the associated entity */
+                id: string;
+            };
+            associatedEntities: {
+                /** @description The type of the associated entity */
+                type: string;
+                /** @description The id of the associated entity */
+                id: string;
+            }[];
+            /** @description The permissions for the media, specifying which users permissions are required. (eg: ["customers:customer"]) */
+            permissions: string[];
+            /**
+             * @description A MongoDB ObjectID
+             * @example 64f0cbbf2f4d3c6b8a1e9f0a
+             */
+            id: string;
+            meta: {
+                /**
+                 * Format: date-time
+                 * @description Created at timestamp
+                 * @example 2022-01-21T00:15:16.000Z
+                 */
+                createdAt: string;
+                createdBy: string;
+                /**
+                 * Format: date-time
+                 * @description Updated at timestamp
+                 * @example 2022-01-21T00:15:16.000Z
+                 */
+                updatedAt?: string;
+                updatedBy?: string;
+                /**
+                 * Format: date-time
+                 * @description Deleted at timestamp
+                 * @example 2022-01-21T00:15:16.000Z
+                 */
+                deletedAt?: string;
+                deletedBy?: string;
+            };
+            /** Format: date-time */
+            expiresAfter?: string;
+            signedUrlForUpload: {
+                /** Format: uri */
+                url: string;
+                headers: {
+                    [key: string]: string;
+                };
+            };
+        };
+        PermissionErrorDto: {
+            /**
+             * @example Forbidden
+             * @constant
+             */
+            error: "Forbidden";
+            /**
+             * @example 403
+             * @constant
+             */
+            statusCode: 403;
+            /** @example You are not allowed to perform that action */
+            message: string;
+            /** @example Technical error description */
+            reason: string;
+            grants: {
+                entity: string;
+                operation: string;
+                /** @enum {string} */
+                scope: "@self" | "@org" | "@admin";
+            }[];
+        };
+        MediaResponseDto: {
+            filename: string;
+            contentType: string;
+            bucket: string;
+            bucketPath: string;
+            isPublic: boolean;
+            /** Format: uri */
+            publicUrl?: string;
+            owner: {
+                /** @description The type of the associated entity */
+                type: string;
+                /** @description The id of the associated entity */
+                id: string;
+            };
+            associatedEntities: {
+                /** @description The type of the associated entity */
+                type: string;
+                /** @description The id of the associated entity */
+                id: string;
+            }[];
+            /** @description The permissions for the media, specifying which users permissions are required. (eg: ["customers:customer"]) */
+            permissions: string[];
+            /**
+             * @description A MongoDB ObjectID
+             * @example 64f0cbbf2f4d3c6b8a1e9f0a
+             */
+            id: string;
+            meta: {
+                /**
+                 * Format: date-time
+                 * @description Created at timestamp
+                 * @example 2022-01-21T00:15:16.000Z
+                 */
+                createdAt: string;
+                createdBy: string;
+                /**
+                 * Format: date-time
+                 * @description Updated at timestamp
+                 * @example 2022-01-21T00:15:16.000Z
+                 */
+                updatedAt?: string;
+                updatedBy?: string;
+                /**
+                 * Format: date-time
+                 * @description Deleted at timestamp
+                 * @example 2022-01-21T00:15:16.000Z
+                 */
+                deletedAt?: string;
+                deletedBy?: string;
+            };
+            /** Format: date-time */
+            expiresAfter?: string;
+            /**
+             * Format: uri
+             * @description A signed URL that can be used to download the attachment content. This field is optional and will only be included if the request asks for it.
+             */
+            signedUrlForDownload?: string;
+        };
+        NotFoundErrorDto: {
+            /**
+             * @example NotFound
+             * @constant
+             */
+            error: "NotFound";
+            /**
+             * @example 404
+             * @constant
+             */
+            statusCode: 404;
+            /** @example The requested entity was not found */
+            message: string;
+            /** @example Technical error description */
+            reason: string;
+        };
+        PatchMediaDto: {
+            /** @description The permissions for the media, specifying which users permissions are required. (eg: ["customers:customer"]) */
+            permissions?: string[];
+            expiresAfter?: string | null;
+            /** @description A list of entities associated with the media, specifying the type and ID of each associated entity. This field is optional and can be used to link the media to other entities in the system. */
+            associatedEntities?: {
+                /** @description The type of the associated entity */
+                type: string;
+                /** @description The id of the associated entity */
+                id: string;
+            }[];
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export interface operations {
+    HealthController_getHealth: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HealthStatusDto"];
+                };
+            };
+            /** @description When the request is valid, but something goes wrong on the server */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["InternalServerErrorDto"];
+                };
+            };
+        };
+    };
+    createMedia: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateMediaDto"];
+            };
+        };
+        responses: {
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CreatedMediaDto"];
+                };
+            };
+            /** @description When authentication fails */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UnauthorizedErrorDto"];
+                };
+            };
+            /** @description When the requesting user is not allowed to perform this action */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PermissionErrorDto"];
+                };
+            };
+            /** @description When the request is valid, but something goes wrong on the server */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["InternalServerErrorDto"];
+                };
+            };
+        };
+    };
+    getMediaById: {
+        parameters: {
+            query?: {
+                /** @description Whether to include a signed URL for downloading the media in the response. Defaults to false. */
+                includeSignedUrl?: boolean;
+                /** @description Whether the signed URL for downloading the media should be for inline display (true) or for attachment download (false). Defaults to false. */
+                inline?: boolean;
+            };
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MediaResponseDto"];
+                };
+            };
+            /** @description When authentication fails */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UnauthorizedErrorDto"];
+                };
+            };
+            /** @description When the requesting user is not allowed to perform this action */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PermissionErrorDto"];
+                };
+            };
+            /** @description When the media is not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["NotFoundErrorDto"];
+                };
+            };
+            /** @description When the request is valid, but something goes wrong on the server */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["InternalServerErrorDto"];
+                };
+            };
+        };
+    };
+    deleteMediaById: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description When authentication fails */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UnauthorizedErrorDto"];
+                };
+            };
+            /** @description When the requesting user is not allowed to perform this action */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PermissionErrorDto"];
+                };
+            };
+            /** @description When the media is not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["NotFoundErrorDto"];
+                };
+            };
+            /** @description When the request is valid, but something goes wrong on the server */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["InternalServerErrorDto"];
+                };
+            };
+        };
+    };
+    updateMediaById: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["PatchMediaDto"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CreatedMediaDto"];
+                };
+            };
+            /** @description When authentication fails */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["UnauthorizedErrorDto"];
+                };
+            };
+            /** @description When the requesting user is not allowed to perform this action */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PermissionErrorDto"];
+                };
+            };
+            /** @description When the media is not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["NotFoundErrorDto"];
+                };
+            };
+            /** @description When the request is valid, but something goes wrong on the server */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["InternalServerErrorDto"];
+                };
+            };
+        };
+    };
+}

package/dist/__generated__/schema.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=schema.js.map

package/dist/__generated__/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/__generated__/schema.ts"],"names":[],"mappings":""}

package/dist/client.d.ts

@@ -0,0 +1,26 @@
+import { ApiInput, BaseSdkClient, CreateSdkClientInput, RequestOptions, SdkResult } from "@palmetto/base-sdk-client";
+import { ExtractResultData } from "@palmetto/result";
+import type { paths } from "./__generated__/schema.ts";
+export type CreateMediaClientInput = Omit<CreateSdkClientInput, "sdkVersion">;
+export declare class MediaClient extends BaseSdkClient<paths> {
+    constructor(input: CreateMediaClientInput);
+    createMedia(input: CreateMediaInput, options?: RequestOptions): Promise<CreateMediaResult>;
+    getMediaById({ id, ...query }: GetMediaByIdInput, options?: RequestOptions): Promise<GetMediaByIdResult>;
+    deleteMediaById(input: DeleteMediaByIdInput, options?: RequestOptions): Promise<DeleteMediaByIdResult>;
+    updateMediaById({ id, ...input }: UpdateMediaByIdInput, options?: RequestOptions): Promise<UpdateMediaByIdResult>;
+    healthCheck(_input?: HealthCheckInput, options?: RequestOptions): Promise<HealthCheckResult>;
+}
+export type HealthCheckInput = ApiInput<paths["/api/health"]["get"]>;
+export type HealthCheckResult = SdkResult<paths["/api/health"]["get"]>;
+export type HealthCheckResponse = ExtractResultData<HealthCheckResult>;
+export type CreateMediaInput = ApiInput<paths["/api/media"]["post"]>;
+export type CreateMediaResult = SdkResult<paths["/api/media"]["post"]>;
+export type CreateMediaResponse = ExtractResultData<CreateMediaResult>;
+export type GetMediaByIdInput = ApiInput<paths["/api/media/{id}"]["get"]>;
+export type GetMediaByIdResult = SdkResult<paths["/api/media/{id}"]["get"]>;
+export type GetMediaByIdResponse = ExtractResultData<GetMediaByIdResult>;
+export type DeleteMediaByIdInput = ApiInput<paths["/api/media/{id}"]["delete"]>;
+export type DeleteMediaByIdResult = SdkResult<paths["/api/media/{id}"]["delete"]>;
+export type UpdateMediaByIdInput = ApiInput<paths["/api/media/{id}"]["patch"]>;
+export type UpdateMediaByIdResult = SdkResult<paths["/api/media/{id}"]["patch"]>;
+export type UpdateMediaByIdResponse = ExtractResultData<UpdateMediaByIdResult>;

package/dist/client.js

@@ -0,0 +1,98 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MediaClient = void 0;
+const base_sdk_client_1 = require("@palmetto/base-sdk-client");
+const result_1 = require("@palmetto/result");
+const SDK_VERSION_SLUG = "palmetto-media-sdk/0.1.0";
+class MediaClient extends base_sdk_client_1.BaseSdkClient {
+    constructor(input) {
+        super(Object.assign(Object.assign({}, input), { sdkVersion: SDK_VERSION_SLUG }));
+    }
+    createMedia(input, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data, error, response } = yield this.client.POST("/api/media", {
+                headers: this.generateHeaders(options),
+                body: input,
+            });
+            if (data) {
+                return (0, result_1.Ok)(data);
+            }
+            return this.handleErrorResponse(error, response);
+        });
+    }
+    getMediaById(_a, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var { id } = _a, query = __rest(_a, ["id"]);
+            const { data, error, response } = yield this.client.GET(`/api/media/{id}`, {
+                params: {
+                    path: { id },
+                    query,
+                },
+                headers: this.generateHeaders(options),
+            });
+            if (data) {
+                return (0, result_1.Ok)(data);
+            }
+            return this.handleErrorResponse(error, response);
+        });
+    }
+    deleteMediaById(input, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { error, response } = yield this.client.DELETE(`/api/media/{id}`, {
+                params: { path: { id: input.id } },
+                headers: this.generateHeaders(options),
+            });
+            if (!error) {
+                return (0, result_1.Ok)(undefined);
+            }
+            return this.handleErrorResponse(error, response);
+        });
+    }
+    updateMediaById(_a, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var { id } = _a, input = __rest(_a, ["id"]);
+            const { data, error, response } = yield this.client.PATCH(`/api/media/{id}`, {
+                params: { path: { id } },
+                headers: this.generateHeaders(options),
+                body: input,
+            });
+            if (data) {
+                return (0, result_1.Ok)(data);
+            }
+            return this.handleErrorResponse(error, response);
+        });
+    }
+    healthCheck(_input, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data, error, response } = yield this.client.GET("/api/health", {
+                headers: this.generateHeaders(options),
+            });
+            if (data) {
+                return (0, result_1.Ok)(data);
+            }
+            return this.handleErrorResponse(error, response);
+        });
+    }
+}
+exports.MediaClient = MediaClient;
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAAA,+DAMmC;AACnC,6CAAyD;AAIzD,MAAM,gBAAgB,GAAG,0BAA0B,CAAC;AAIpD,MAAa,WAAY,SAAQ,+BAAoB;IACnD,YAAY,KAA6B;QACvC,KAAK,iCAAM,KAAK,KAAE,UAAU,EAAE,gBAAgB,IAAG,CAAC;IACpD,CAAC;IAEK,WAAW,CACf,KAAuB,EACvB,OAAwB;;YAExB,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,EAAE;gBACrE,OAAO,EAAE,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC;gBACtC,IAAI,EAAE,KAAK;aACZ,CAAC,CAAC;YAEH,IAAI,IAAI,EAAE,CAAC;gBACT,OAAO,IAAA,WAAE,EAAC,IAAI,CAAC,CAAC;YAClB,CAAC;YAED,OAAO,IAAI,CAAC,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QACnD,CAAC;KAAA;IAEK,YAAY,CAChB,EAAmC,EACnC,OAAwB;;gBADxB,EAAE,EAAE,OAA+B,EAA1B,KAAK,cAAd,MAAgB,CAAF;YAGd,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,iBAAiB,EAAE;gBACzE,MAAM,EAAE;oBACN,IAAI,EAAE,EAAE,EAAE,EAAE;oBACZ,KAAK;iBACN;gBACD,OAAO,EAAE,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC;aACvC,CAAC,CAAC;YAEH,IAAI,IAAI,EAAE,CAAC;gBACT,OAAO,IAAA,WAAE,EAAC,IAAI,CAAC,CAAC;YAClB,CAAC;YAED,OAAO,IAAI,CAAC,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QACnD,CAAC;KAAA;IAEK,eAAe,CACnB,KAA2B,EAC3B,OAAwB;;YAExB,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,iBAAiB,EAAE;gBACtE,MAAM,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,EAAE;gBAClC,OAAO,EAAE,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC;aACvC,CAAC,CAAC;YAEH,IAAI,CAAC,KAAK,EAAE,CAAC;gBACX,OAAO,IAAA,WAAE,EAAC,SAAS,CAAC,CAAC;YACvB,CAAC;YAED,OAAO,IAAI,CAAC,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QACnD,CAAC;KAAA;IAEK,eAAe,CACnB,EAAsC,EACtC,OAAwB;;gBADxB,EAAE,EAAE,OAAkC,EAA7B,KAAK,cAAd,MAAgB,CAAF;YAGd,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CACvD,iBAAiB,EACjB;gBACE,MAAM,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE;gBACxB,OAAO,EAAE,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC;gBACtC,IAAI,EAAE,KAAK;aACZ,CACF,CAAC;YAEF,IAAI,IAAI,EAAE,CAAC;gBACT,OAAO,IAAA,WAAE,EAAC,IAAI,CAAC,CAAC;YAClB,CAAC;YAED,OAAO,IAAI,CAAC,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QACnD,CAAC;KAAA;IAEK,WAAW,CACf,MAAyB,EACzB,OAAwB;;YAExB,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,aAAa,EAAE;gBACrE,OAAO,EAAE,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC;aACvC,CAAC,CAAC;YAEH,IAAI,IAAI,EAAE,CAAC;gBACT,OAAO,IAAA,WAAE,EAAC,IAAI,CAAC,CAAC;YAClB,CAAC;YAED,OAAO,IAAI,CAAC,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QACnD,CAAC;KAAA;CACF;AA1FD,kCA0FC"}

package/dist/main.d.ts

@@ -0,0 +1 @@
+export * from "./client.js";

package/dist/main.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client.js"), exports);
+//# sourceMappingURL=main.js.map

package/dist/main.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.js","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,8CAA4B"}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@palmetto/media-sdk",
+  "version": "0.1.0",
+  "main": "./dist/main.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/palmetto/media"
+  },
+  "files": [
+    "dist/**/*",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "lint": "yarn run -T eslint . --fix --cache",
+    "format": "yarn run -T prettier --write --list-different src/",
+    "format:check": "yarn run -T prettier --check --log-level=warn src/",
+    "tc": "yarn run -T tsc --noEmit",
+    "build": "yarn run -T tsc",
+    "generate": "node ./scripts/generateApiSchema.mjs",
+    "prepublishOnly": "yarn build",
+    "hook:lint": "yarn run -T eslint --cache --fix",
+    "hook:format": "yarn run -T prettier --write --log-level warn",
+    "hook:type-check": "yarn tc",
+    "ci:build": "yarn build",
+    "ci:lint": "yarn lint && yarn run -T prettier --check --log-level warn ./src",
+    "ci:tc": "yarn tc"
+  },
+  "devDependencies": {
+    "@palmetto/base-sdk-client": "^1.2.3",
+    "@palmetto/result": "^1.2.1",
+    "@types/node": "^25.9.1",
+    "openapi-typescript": "^7.13.0",
+    "openapi-typescript-helpers": "^0.1.0",
+    "typescript": "6.0.3"
+  },
+  "dependencies": {
+    "openapi-fetch": "^0.17.0"
+  },
+  "peerDependencies": {
+    "@palmetto/base-sdk-client": "^1.2",
+    "@palmetto/result": "^1.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}