@stackshift-cloud/sdk 0.1.0 → 0.1.2

package/README.md

@@ -8,6 +8,129 @@ Official JavaScript and TypeScript SDK for StackShift.
 npm install @stackshift-cloud/sdk
 ```
 
+Set your API key:
+
+```bash
+STACKSHIFT_API_KEY=sk_live_xxx
+```
+
+## Send email
+
+```ts
+import { StackShift } from '@stackshift-cloud/sdk'
+
+const stackshift = new StackShift()
+
+await stackshift.mail.send({
+  from: 'StackShift <noreply@mail.stackshift.cloud>',
+  to: 'ada@example.com',
+  subject: 'Welcome',
+  text: 'Welcome to StackShift.',
+})
+```
+
+HTML and idempotency keys are supported:
+
+```ts
+const message = await stackshift.mail.send({
+  from: { email: 'noreply@mail.stackshift.cloud', name: 'StackShift' },
+  to: ['ada@example.com'],
+  subject: 'Verify your email',
+  html: '<p>Your code is 123456</p>',
+  text: 'Your code is 123456',
+  idempotencyKey: 'verify-email:user_123',
+})
+
+console.log(message.id, message.status, message.idempotencyStatus)
+```
+
+Inspect sent messages:
+
+```ts
+const messages = await stackshift.mail.messages.list({ status: 'sent', limit: 20 })
+const detail = await stackshift.mail.messages.get(messages.data[0].id)
+const attempts = await stackshift.mail.messages.attempts(detail.id)
+const logs = await stackshift.mail.messages.logs(detail.id)
+```
+
+In this MVP, `sent` means the message was accepted by StackShift's outbound MTA. It does not mean inbox delivery, opens, clicks, or spam placement. A `sent` message can later become `bounced` if StackShift receives a delivery-status notification.
+
+## Send a template
+
+Templates are created and rendered by the StackShift backend. Variables use `{{name}}` syntax, and missing variables fail before a message is queued.
+
+```ts
+await stackshift.mail.templates.create({
+  name: 'Welcome Email',
+  slug: 'welcome-email',
+  subject: 'Welcome, {{name}}',
+  html: '<h1>Welcome, {{name}}</h1>',
+  text: 'Welcome, {{name}}',
+})
+
+const preview = await stackshift.mail.templates.preview('welcome-email', {
+  data: { name: 'Ada' },
+})
+
+const message = await stackshift.mail.sendTemplate({
+  template: 'welcome-email',
+  to: 'ada@example.com',
+  from: 'Acme <noreply@acme.com>',
+  data: { name: 'Ada' },
+  idempotencyKey: 'welcome:user_123',
+})
+
+console.log(preview.subject, message.id)
+```
+
+Updating template content creates a new version. You can inspect or reactivate versions with `templates.versions()`, `templates.getVersion()`, and `templates.activateVersion()`.
+
+## Bounces and suppressions
+
+Hard bounces are automatically suppressed to protect sender reputation. Suppressions are workspace scoped and enforced by the StackShift backend before a message is queued.
+
+```ts
+const suppressions = await stackshift.mail.suppressions.list()
+
+await stackshift.mail.suppressions.create({
+  email: 'bad@example.com',
+  reason: 'manual',
+})
+
+await stackshift.mail.suppressions.delete('sup_123')
+
+const bounces = await stackshift.mail.bounces.list({
+  type: 'hard',
+  limit: 20,
+})
+
+const messageBounces = await stackshift.mail.messages.bounces('msg_123')
+```
+
+`bounced` means StackShift detected a delivery failure after handoff. Hard-bounced recipients are automatically suppressed; removing a suppression allows future sends to be queued again.
+
+## Verify a sending domain
+
+Custom domains are workspace/API-key scoped. You do not pass a project ID or deploy an app first.
+
+```ts
+const domain = await stackshift.mail.domains.create('acme.com')
+
+console.log(domain.records)
+
+await stackshift.mail.domains.verify(domain.id)
+
+await stackshift.mail.send({
+  from: 'Acme <noreply@acme.com>',
+  to: 'user@example.com',
+  subject: 'Welcome',
+  html: '<h1>Welcome</h1>',
+  text: 'Welcome',
+})
+```
+
+Add the returned SPF, DKIM, and return-path DNS records before verifying. DMARC is recommended by default and may be required if your StackShift environment sets `MAIL_DMARC_REQUIRED=true`. DNS propagation can take time, so a missing or pending status usually means you should wait and verify again.
+
 ## Upload an asset
 
 ```ts
@@ -46,6 +169,57 @@ const signed = await stackshift.assets.signedUrl(asset.id, {
 console.log(signed.url)
 ```
 
+## Image transformations
+
+Use built-in presets or create your own named transformations.
+
+```ts
+import { StackShift, assetTransformOptions, getAssetTransformPreset } from '@stackshift-cloud/sdk'
+
+const stackshift = new StackShift()
+const hero = getAssetTransformPreset('hero')!
+const heroOptions = assetTransformOptions(hero)
+
+await stackshift.assets.createTransformation({ name: hero.name, ...heroOptions })
+
+const named = stackshift.assets.namedUrl('asset_123', hero.name)
+const signed = await stackshift.assets.signedTransformUrl('asset_123', {
+  ...heroOptions,
+  expiresIn: '10m',
+})
+
+await stackshift.assets.deleteTransformation('old-preset')
+console.log(named, signed.url)
+```
+
+## NestJS
+
+```ts
+import { Injectable } from '@nestjs/common'
+import { StackShift } from '@stackshift-cloud/sdk'
+
+@Injectable()
+export class AssetsService {
+  private readonly stackshift = new StackShift({
+    apiKey: process.env.STACKSHIFT_API_KEY!,
+  })
+
+  upload(file: Express.Multer.File) {
+    return this.stackshift.assets.upload(
+      new Blob([file.buffer], { type: file.mimetype }),
+      {
+        bucket: 'uploads',
+        key: file.originalname,
+        visibility: 'private',
+        metadata: { originalName: file.originalname },
+      },
+    )
+  }
+}
+```
+
+For larger uploads, create a signed upload URL on your NestJS server and let the browser upload directly.
+
 ## Direct browser uploads
 
 Create a signed upload URL on your server:
@@ -70,4 +244,6 @@ await fetch(upload.url, {
 })
 ```
 
+This is the recommended pattern for React, Next.js, TanStack Start, and any browser app. The browser never receives your StackShift API key.
+
 StackShift chooses storage nodes, writes to StackShift-owned disks, replicates internally, and returns CDN-ready asset URLs. SDK users never choose storage nodes and never receive disk paths.

package/dist/assets.d.ts

@@ -1,5 +1,9 @@
-import type { StackShift } from './client';
-import type { Asset, AssetListOptions, AssetListResult, AssetSignedUploadUrl, AssetSignedUploadUrlOptions, AssetSignedUrl, AssetSignedUrlOptions, AssetUploadOptions } from './types';
+import type { StackShift } from './client.js';
+import type { Asset, AssetAIInfo, AssetCollection, AssetContentPolicy, AssetNamedTransformInput, AssetListOptions, AssetListResult, AssetSavedSearch, AssetTranscript, AssetUploadProgressCallbacks, AssetVersion, AssetSignedUploadUrl, AssetSignedUploadUrlOptions, AssetSignedTransformOptions, AssetSignedUrl, AssetSignedUrlOptions, AssetTransformOptions, AssetTransformPreset, AssetUploadOptions } from './types.js';
+export declare const assetTransformPresets: AssetTransformPreset[];
+export declare function getAssetTransformPreset(name: string): AssetTransformPreset | undefined;
+export declare function assetTransformOptions(preset: AssetTransformPreset): AssetTransformOptions;
+export declare function assetTransformSpec(options: AssetTransformOptions): string;
 export declare class AssetsClient {
     private readonly client;
     constructor(client: StackShift);
@@ -13,4 +17,84 @@ export declare class AssetsClient {
     signedUrl(assetId: string, options: AssetSignedUrlOptions): Promise<AssetSignedUrl>;
     signedUploadUrl(options?: AssetSignedUploadUrlOptions): Promise<AssetSignedUploadUrl>;
     createUploadSession(options?: AssetSignedUploadUrlOptions): Promise<AssetSignedUploadUrl>;
+    createChunkedUploadSession(options: AssetSignedUploadUrlOptions): Promise<AssetSignedUploadUrl>;
+    uploadChunk(uploadUrlOrToken: string, partNumber: number, chunk: Blob, callbacks?: AssetUploadProgressCallbacks): Promise<void>;
+    resumeUploadSession(sessionId: string): Promise<AssetSignedUploadUrl>;
+    completeUploadSession(sessionId: string): Promise<Asset>;
+    cancelUploadSession(sessionId: string): Promise<{
+        cancelled: boolean;
+    }>;
+    uploadWithProgress(file: Blob, options?: AssetSignedUploadUrlOptions, callbacks?: AssetUploadProgressCallbacks): Promise<Asset | AssetSignedUploadUrl>;
+    url(assetId: string, options: AssetTransformOptions): string;
+    namedUrl(assetId: string, name: string): string;
+    videoUrl(assetId: string, kind: 'hls' | 'poster' | 'mp4', profile?: string, token?: string): string;
+    versionUrl(assetId: string, versionId: string, token?: string): string;
+    branchUrl(assetId: string, branch: string, token?: string): string;
+    ai(assetId: string): Promise<AssetAIInfo>;
+    analyze(assetId: string): Promise<{
+        analysis_queued: boolean;
+    }>;
+    moderate(assetId: string): Promise<{
+        moderation_queued: boolean;
+    }>;
+    transcript(assetId: string): Promise<AssetTranscript>;
+    requestTranscript(assetId: string): Promise<{
+        transcript_queued: boolean;
+    }>;
+    requestSmartCrop(assetId: string): Promise<{
+        smart_crop_queued: boolean;
+    }>;
+    requestBackgroundRemoval(assetId: string): Promise<{
+        background_remove_queued: boolean;
+    }>;
+    versions(assetId: string): Promise<{
+        versions: AssetVersion[];
+    }>;
+    createBranch(assetId: string, name: string, fromVersionId?: string): Promise<unknown>;
+    restoreVersion(assetId: string, versionId: string): Promise<{
+        restored: boolean;
+    }>;
+    promoteBranch(assetId: string, branch: string): Promise<{
+        promoted: boolean;
+    }>;
+    collections(): Promise<{
+        collections: AssetCollection[];
+    }>;
+    createCollection(input: {
+        name: string;
+        description?: string;
+        asset_ids?: string[];
+    }): Promise<AssetCollection>;
+    updateCollection(collectionId: string, input: {
+        name: string;
+        description?: string;
+        asset_ids?: string[];
+    }): Promise<AssetCollection>;
+    deleteCollection(collectionId: string): Promise<{
+        deleted: boolean;
+    }>;
+    savedSearches(): Promise<{
+        saved_searches: AssetSavedSearch[];
+    }>;
+    saveSearch(input: {
+        name: string;
+        filters: Record<string, unknown>;
+    }): Promise<AssetSavedSearch>;
+    updateSavedSearch(searchId: string, input: {
+        name: string;
+        filters: Record<string, unknown>;
+    }): Promise<AssetSavedSearch>;
+    deleteSavedSearch(searchId: string): Promise<{
+        deleted: boolean;
+    }>;
+    getPolicy(): Promise<AssetContentPolicy>;
+    updatePolicy(policy: AssetContentPolicy): Promise<AssetContentPolicy>;
+    createTransformation(input: AssetNamedTransformInput): Promise<unknown>;
+    listTransformations(): Promise<unknown>;
+    deleteTransformation(name: string): Promise<{
+        deleted: boolean;
+    }>;
+    signedTransformUrl(assetId: string, options: AssetSignedTransformOptions): Promise<AssetSignedUrl>;
+    private originBaseUrl;
+    private uploadSingleWithProgress;
 }

package/dist/assets.js

@@ -1,3 +1,44 @@
+export const assetTransformPresets = [
+    preset('web-thumbnail', 'responsive-web', 'Compact grid thumbnail for libraries and dashboards.', 320, 180, 'fill', 'webp', 78),
+    preset('web-card', 'responsive-web', 'Balanced card image for product and content listings.', 640, 360, 'fill', 'webp', 82),
+    preset('feature-image', 'responsive-web', 'Wide content feature image with enough detail for retina screens.', 1200, 675, 'fill', 'webp', 84),
+    preset('hero', 'responsive-web', 'Large hero image for landing pages and page headers.', 1600, 900, 'fill', 'webp', 84),
+    preset('full-width-banner', 'responsive-web', 'Extra-wide banner for app shells and marketing sections.', 1920, 720, 'fill', 'webp', 82),
+    preset('open-graph', 'social', 'Share preview image for Open Graph cards.', 1200, 630, 'fill', 'jpeg', 85),
+    preset('square-post', 'social', 'Square image for social feeds.', 1080, 1080, 'fill', 'webp', 84),
+    preset('story', 'social', 'Vertical story format for mobile social placements.', 1080, 1920, 'fill', 'webp', 82),
+    preset('x-twitter-card', 'social', 'Landscape card optimized for X and Twitter previews.', 1200, 675, 'fill', 'jpeg', 84),
+    preset('linkedin-share', 'social', 'LinkedIn share preview dimensions.', 1200, 627, 'fill', 'jpeg', 84),
+    preset('product-square', 'product', 'Square product image with clean containment.', 1024, 1024, 'fit', 'webp', 86),
+    preset('product-card', 'product', 'Product listing image for commerce grids.', 640, 640, 'fit', 'webp', 84),
+    preset('product-zoom', 'product', 'High-detail product image for zoom interactions.', 2000, 2000, 'fit', 'jpeg', 90),
+    preset('gallery-thumb', 'product', 'Compact gallery thumbnail for product detail pages.', 400, 400, 'fill', 'webp', 82),
+    preset('avatar-small', 'avatar-profile', 'Small circular avatar source for dense UI.', 128, 128, 'fill', 'webp', 82),
+    preset('avatar-retina', 'avatar-profile', 'Retina avatar source for account and profile UI.', 256, 256, 'fill', 'webp', 84),
+    preset('profile-cover', 'avatar-profile', 'Wide profile cover image.', 1500, 500, 'fill', 'webp', 82),
+    preset('webp-auto', 'performance', 'Auto-sized WebP delivery with browser-friendly compression.', 1280, undefined, 'fit', 'webp', 78),
+    preset('avif-compressed', 'performance', 'Highly compressed AVIF for modern browsers.', 1280, undefined, 'fit', 'avif', 62),
+    preset('lqip', 'performance', 'Tiny low-quality placeholder for progressive image loading.', 48, undefined, 'fit', 'jpeg', 35),
+    preset('blur-placeholder', 'performance', 'Small placeholder candidate for blurred loading states.', 32, 32, 'fill', 'jpeg', 30),
+    preset('email-safe-600', 'email-docs', 'Email-safe content image with conservative width.', 600, undefined, 'fit', 'jpeg', 82),
+    preset('markdown-image', 'email-docs', 'Documentation image that fits most reading columns.', 800, undefined, 'fit', 'webp', 82),
+    preset('docs-screenshot', 'email-docs', 'Crisp screenshot size for guides and changelogs.', 1440, 900, 'fit', 'webp', 84),
+];
+export function getAssetTransformPreset(name) {
+    return assetTransformPresets.find((preset) => preset.name === name);
+}
+export function assetTransformOptions(preset) {
+    return {
+        width: preset.width,
+        height: preset.height,
+        crop: preset.crop,
+        format: preset.format,
+        quality: preset.quality,
+    };
+}
+export function assetTransformSpec(options) {
+    return transformSpec(options);
+}
 export class AssetsClient {
     client;
     constructor(client) {
@@ -14,6 +55,12 @@ export class AssetsClient {
         append(query, 'bucket', options.bucket);
         append(query, 'prefix', options.prefix);
         append(query, 'visibility', options.visibility);
+        append(query, 'query', options.query);
+        append(query, 'tag', options.tag);
+        append(query, 'mimeType', options.mimeType);
+        append(query, 'type', options.type);
+        append(query, 'folder', options.folder);
+        append(query, 'checksum', options.checksum);
         append(query, 'limit', options.limit);
         append(query, 'cursor', options.cursor);
         const suffix = query.toString();
@@ -55,11 +102,190 @@ export class AssetsClient {
                 visibility: options.visibility,
                 cacheControl: options.cacheControl,
                 metadata: options.metadata,
+                mode: options.mode,
+                fileName: options.fileName,
+                fileSize: options.fileSize,
+                mimeType: options.mimeType,
+                checksumSHA256: options.checksumSHA256,
+                partSize: options.partSize,
                 expiresIn: options.expiresIn,
                 maxBytes: options.maxBytes,
             },
         });
     }
+    createChunkedUploadSession(options) {
+        return this.createUploadSession({ ...options, mode: 'chunked' });
+    }
+    uploadChunk(uploadUrlOrToken, partNumber, chunk, callbacks = {}) {
+        const target = uploadUrlOrToken.startsWith('http')
+            ? `${uploadUrlOrToken.replace(/\/$/, '')}/parts/${partNumber}`
+            : `${this.originBaseUrl()}/uploads/${encodeURIComponent(uploadUrlOrToken)}/parts/${partNumber}`;
+        return uploadBlob(target, chunk, callbacks, partNumber);
+    }
+    resumeUploadSession(sessionId) {
+        return this.client.request(`/assets/upload-sessions/${encodeURIComponent(sessionId)}`);
+    }
+    completeUploadSession(sessionId) {
+        return this.client.request(`/assets/upload-sessions/${encodeURIComponent(sessionId)}/complete`, {
+            method: 'POST',
+        });
+    }
+    cancelUploadSession(sessionId) {
+        return this.client.request(`/assets/upload-sessions/${encodeURIComponent(sessionId)}`, {
+            method: 'DELETE',
+        });
+    }
+    async uploadWithProgress(file, options = {}, callbacks = {}) {
+        const size = options.fileSize ?? file.size;
+        if (size <= defaultPartSize) {
+            return this.uploadSingleWithProgress(file, options, callbacks);
+        }
+        const session = await this.createChunkedUploadSession({
+            ...options,
+            fileSize: size,
+            fileName: options.fileName ?? blobName(file),
+            mimeType: options.mimeType ?? file.type,
+        });
+        const partSize = session.part_size ?? defaultPartSize;
+        for (let offset = 0, part = 1; offset < size; offset += partSize, part += 1) {
+            await this.uploadChunk(session.upload_session_id, part, file.slice(offset, offset + partSize), callbacks);
+        }
+        if (!session.session_id) {
+            throw new Error('Chunked upload session did not include a resumable session id');
+        }
+        return this.completeUploadSession(session.session_id);
+    }
+    url(assetId, options) {
+        return `${this.client.cdnBaseUrl}/assets/${encodeURIComponent(assetId)}/tr/${encodeURIComponent(transformSpec(options))}`;
+    }
+    namedUrl(assetId, name) {
+        return `${this.client.cdnBaseUrl}/t/${encodeURIComponent(name)}/assets/${encodeURIComponent(assetId)}`;
+    }
+    videoUrl(assetId, kind, profile = 'default', token) {
+        const visibilityPath = token ? '/private/assets' : '/assets';
+        const url = [
+            this.client.cdnBaseUrl,
+            visibilityPath,
+            '/',
+            encodeURIComponent(assetId),
+            '/video/',
+            encodeURIComponent(kind),
+            '/',
+            encodeURIComponent(profile),
+        ].join('');
+        return token ? `${url}?token=${encodeURIComponent(token)}` : url;
+    }
+    versionUrl(assetId, versionId, token) {
+        const prefix = token ? '/private/assets' : '/assets';
+        const value = `${this.client.cdnBaseUrl}${prefix}/${encodeURIComponent(assetId)}/versions/${encodeURIComponent(versionId)}`;
+        return token ? `${value}?token=${encodeURIComponent(token)}` : value;
+    }
+    branchUrl(assetId, branch, token) {
+        const prefix = token ? '/private/assets' : '/assets';
+        const value = `${this.client.cdnBaseUrl}${prefix}/${encodeURIComponent(assetId)}/branches/${encodeURIComponent(branch)}`;
+        return token ? `${value}?token=${encodeURIComponent(token)}` : value;
+    }
+    ai(assetId) {
+        return this.client.request(`/assets/${encodeURIComponent(assetId)}/ai`);
+    }
+    analyze(assetId) {
+        return this.client.request(`/assets/${encodeURIComponent(assetId)}/ai/analyze`, { method: 'POST' });
+    }
+    moderate(assetId) {
+        return this.client.request(`/assets/${encodeURIComponent(assetId)}/moderation`, { method: 'POST' });
+    }
+    transcript(assetId) {
+        return this.client.request(`/assets/${encodeURIComponent(assetId)}/transcript`);
+    }
+    requestTranscript(assetId) {
+        return this.client.request(`/assets/${encodeURIComponent(assetId)}/transcript`, { method: 'POST' });
+    }
+    requestSmartCrop(assetId) {
+        return this.client.request(`/assets/${encodeURIComponent(assetId)}/smart-crop`, { method: 'POST' });
+    }
+    requestBackgroundRemoval(assetId) {
+        return this.client.request(`/assets/${encodeURIComponent(assetId)}/background-remove`, { method: 'POST' });
+    }
+    versions(assetId) {
+        return this.client.request(`/assets/${encodeURIComponent(assetId)}/versions`);
+    }
+    createBranch(assetId, name, fromVersionId) {
+        return this.client.request(`/assets/${encodeURIComponent(assetId)}/branches`, {
+            method: 'POST',
+            body: { name, from_version_id: fromVersionId },
+        });
+    }
+    restoreVersion(assetId, versionId) {
+        return this.client.request(`/assets/${encodeURIComponent(assetId)}/versions/${encodeURIComponent(versionId)}/restore`, { method: 'POST' });
+    }
+    promoteBranch(assetId, branch) {
+        return this.client.request(`/assets/${encodeURIComponent(assetId)}/branches/${encodeURIComponent(branch)}/promote`, { method: 'POST' });
+    }
+    collections() {
+        return this.client.request('/assets/collections');
+    }
+    createCollection(input) {
+        return this.client.request('/assets/collections', { method: 'POST', body: input });
+    }
+    updateCollection(collectionId, input) {
+        return this.client.request(`/assets/collections/${encodeURIComponent(collectionId)}`, { method: 'PUT', body: input });
+    }
+    deleteCollection(collectionId) {
+        return this.client.request(`/assets/collections/${encodeURIComponent(collectionId)}`, { method: 'DELETE' });
+    }
+    savedSearches() {
+        return this.client.request('/assets/saved-searches');
+    }
+    saveSearch(input) {
+        return this.client.request('/assets/saved-searches', { method: 'POST', body: input });
+    }
+    updateSavedSearch(searchId, input) {
+        return this.client.request(`/assets/saved-searches/${encodeURIComponent(searchId)}`, { method: 'PUT', body: input });
+    }
+    deleteSavedSearch(searchId) {
+        return this.client.request(`/assets/saved-searches/${encodeURIComponent(searchId)}`, { method: 'DELETE' });
+    }
+    getPolicy() {
+        return this.client.request('/assets/policy');
+    }
+    updatePolicy(policy) {
+        return this.client.request('/assets/policy', {
+            method: 'PUT',
+            body: policy,
+        });
+    }
+    createTransformation(input) {
+        return this.client.request('/assets/transformations', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    listTransformations() {
+        return this.client.request('/assets/transformations');
+    }
+    deleteTransformation(name) {
+        return this.client.request(`/assets/transformations/${encodeURIComponent(name)}`, {
+            method: 'DELETE',
+        });
+    }
+    signedTransformUrl(assetId, options) {
+        return this.client.request(`/assets/${encodeURIComponent(assetId)}/transform-url`, {
+            method: 'POST',
+            body: transformBody(options),
+        });
+    }
+    originBaseUrl() {
+        return this.client.baseUrl.replace(/\/api\/v1$/, '');
+    }
+    async uploadSingleWithProgress(file, options, callbacks) {
+        const session = await this.createUploadSession({
+            ...options,
+            mode: 'single',
+            maxBytes: options.maxBytes ?? file.size,
+        });
+        await uploadBlob(session.url, file, callbacks);
+        return session;
+    }
 }
 function assetForm(file, options) {
     const body = new FormData();
@@ -79,3 +305,58 @@ function append(target, key, value) {
         target.append(key, String(value));
     }
 }
+function transformSpec(options) {
+    const parts = [];
+    if (options.width)
+        parts.push(`w_${options.width}`);
+    if (options.height)
+        parts.push(`h_${options.height}`);
+    parts.push(`c_${options.crop ?? 'fit'}`);
+    parts.push(`f_${options.format ?? 'auto'}`);
+    parts.push(`q_${options.quality ?? 'auto'}`);
+    return parts.join(',');
+}
+function preset(name, category, description, width, height, crop = 'fit', format = 'auto', quality = 'auto') {
+    return { id: name, name, category, description, width, height, crop, format, quality };
+}
+function transformBody(options) {
+    return {
+        width: options.width,
+        height: options.height,
+        crop: options.crop,
+        format: options.format,
+        quality: options.quality,
+        expiresIn: options.expiresIn,
+    };
+}
+const defaultPartSize = 5 * 1024 * 1024;
+function blobName(file) {
+    return file.name;
+}
+function uploadBlob(url, blob, callbacks, partNumber) {
+    if (typeof XMLHttpRequest === 'undefined') {
+        return fetch(url, { method: 'PUT', body: blob }).then((response) => {
+            if (!response.ok)
+                throw new Error(`Upload failed with ${response.status}`);
+        });
+    }
+    return new Promise((resolve, reject) => {
+        const xhr = new XMLHttpRequest();
+        xhr.open('PUT', url);
+        xhr.upload.onprogress = (event) => {
+            const total = event.total || blob.size;
+            const progress = { loaded: event.loaded, total, percent: total ? Math.round((event.loaded / total) * 100) : 0 };
+            callbacks.onProgress?.(progress);
+            if (partNumber)
+                callbacks.onPartProgress?.(partNumber, progress);
+        };
+        xhr.onload = () => {
+            if (xhr.status >= 200 && xhr.status < 300)
+                resolve();
+            else
+                reject(new Error(`Upload failed with ${xhr.status}`));
+        };
+        xhr.onerror = () => reject(new Error('Upload failed'));
+        xhr.send(blob);
+    });
+}

package/dist/client.d.ts

@@ -1,11 +1,15 @@
-import { AssetsClient } from './assets';
-import { ProjectsClient } from './projects';
-import type { StackShiftOptions } from './types';
+import { AssetsClient } from './assets.js';
+import { MailClient } from './mail.js';
+import { ProjectsClient } from './projects.js';
+import type { StackShiftOptions } from './types.js';
 export declare class StackShift {
     readonly apiKey: string;
     readonly baseUrl: string;
+    readonly mailBaseUrl: string;
+    readonly cdnBaseUrl: string;
     readonly projects: ProjectsClient;
     readonly assets: AssetsClient;
+    readonly mail: MailClient;
     private readonly fetcher;
     constructor(options?: StackShiftOptions);
     request<T>(path: string, init?: {
@@ -13,4 +17,16 @@ export declare class StackShift {
         body?: unknown;
         headers?: Record<string, string>;
     }): Promise<T>;
+    mailRequest<T>(path: string, init?: {
+        method?: string;
+        body?: unknown;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    private requestFrom;
+}
+export declare class StackShiftAPIError extends Error {
+    readonly status: number;
+    readonly code?: string | undefined;
+    readonly details?: unknown | undefined;
+    constructor(message: string, status: number, code?: string | undefined, details?: unknown | undefined);
 }