@marteye/studiojs 1.1.48-beta.1 → 1.1.49-beta.0

package/dist/media-crate-client.d.ts

@@ -0,0 +1,285 @@
+export declare const MEDIA_CRATE_V2_BASE_URL_ENV_VARS: readonly ["MEDIA_CRATE_V2_BASE_URL", "NEXT_PUBLIC_MEDIA_CRATE_BASE_URL"];
+export type MediaCrateProjectEnv = Record<string, string | undefined>;
+export declare const MEDIA_CRATE_SINGLE_UPLOAD_MAX_BYTES: number;
+export declare const MEDIA_CRATE_MULTIPART_MAX_CHUNK_BYTES: number;
+export declare const MEDIA_CRATE_DEFAULT_CHUNK_BYTES: number;
+export declare const MEDIA_CRATE_MEDIA_STATUSES: readonly ["uploading", "processing", "done", "error", "deleted", "partial", "expired", "indeterminate"];
+/** @deprecated Use MEDIA_CRATE_MEDIA_STATUSES. */
+export declare const MEDIA_CRATE_ASSET_STATUSES: readonly ["uploading", "processing", "done", "error", "deleted", "partial", "expired", "indeterminate"];
+export type MediaCrateUploadMode = "lot" | "transform" | "direct";
+export type MediaCrateMediaMode = Exclude<MediaCrateUploadMode, "lot">;
+export type MediaCrateMediaStatus = (typeof MEDIA_CRATE_MEDIA_STATUSES)[number];
+/** @deprecated Use MediaCrateUploadMode. */
+export type MediaCrateAssetMode = MediaCrateUploadMode;
+/** @deprecated Use MediaCrateMediaStatus. */
+export type MediaCrateAssetStatus = MediaCrateMediaStatus;
+export type MediaCrateUploadStrategy = "auto" | "single" | "multipart";
+export type MediaCrateExpectedVariant = {
+    url: string;
+    key: string;
+    ready: boolean;
+};
+export type MediaCrateExpectedUrls = {
+    original: MediaCrateExpectedVariant;
+    variants?: Record<string, MediaCrateExpectedVariant>;
+};
+export type MediaCrateStatusUrls = MediaCrateExpectedUrls;
+export type MediaCrateVariantSource = MediaCrateExpectedUrls | MediaCrateStatusUrls | {
+    expected: MediaCrateExpectedUrls;
+} | {
+    urls: MediaCrateStatusUrls;
+};
+export type MediaCrateVariantSelectionOptions = {
+    /** Only return the variant if Media Crate marks it as ready. */
+    requireReady?: boolean;
+    /** Fall back to the original URL when the named variant is absent. */
+    fallbackToOriginal?: boolean;
+};
+export declare function getMediaCrateVariant(source: MediaCrateVariantSource, variantName: string, opts?: MediaCrateVariantSelectionOptions): MediaCrateExpectedVariant | undefined;
+export declare function getMediaCrateVariantUrl(source: MediaCrateVariantSource, variantName: string, opts?: MediaCrateVariantSelectionOptions): string | undefined;
+export declare function requireMediaCrateVariantUrl(source: MediaCrateVariantSource, variantName: string, opts?: MediaCrateVariantSelectionOptions): string;
+export type MediaCrateUploadResult = {
+    message?: string;
+    assetId: string;
+    statusUrl: string;
+    status: MediaCrateMediaStatus;
+    expected: MediaCrateExpectedUrls;
+    retryAfterMs?: number;
+};
+export type MediaCrateStatusResult = {
+    assetId: string;
+    marketId: string;
+    mode: MediaCrateUploadMode;
+    status: MediaCrateMediaStatus;
+    urls: MediaCrateStatusUrls;
+    error?: string;
+    retryAfterMs?: number;
+    attemptCount?: number;
+    subStatus?: "queued-for-capacity";
+    queuedSince?: string;
+};
+export type MediaCrateDuplicateResult = MediaCrateUploadResult;
+export type MediaCrateMultipartStartResult = {
+    message: string;
+    data: {
+        parsedFilePath: string;
+        uploadId: string;
+        key: string;
+        assetId: string;
+        generation: number;
+        status: "started";
+    };
+};
+export type MediaCrateMultipartChunkResult = {
+    message: string;
+    data: {
+        partNumber: number;
+        eTag?: string | null;
+    };
+};
+export type MediaCrateStandaloneMultipartStartResult = MediaCrateUploadResult & {
+    uploadId: string;
+    targetKey: string;
+};
+export type MediaCrateStandaloneMultipartChunkResult = {
+    partNumber: number;
+    eTag?: string | null;
+};
+export type MediaCrateErrorResponse = {
+    message: string;
+    collidingKeys?: string[];
+};
+export type MediaCrateMultipartSection = {
+    partNumber: string;
+    eTag: string;
+};
+export type MediaCrateUploadProgressPhase = "starting" | "resuming" | "uploading" | "retrying" | "finishing" | "uploaded" | "error";
+export type MediaCrateUploadProgress = {
+    phase: MediaCrateUploadProgressPhase;
+    bytesUploaded: number;
+    totalBytes: number;
+    partNumber?: number;
+    totalParts?: number;
+    attempt?: number;
+    uploadId?: string;
+};
+export type ReactNativeFormDataFile = {
+    uri: string;
+    type?: string;
+    name?: string;
+};
+export type MediaCrateUploadPartBody = Blob | ArrayBuffer | Uint8Array | string | ReactNativeFormDataFile;
+export type MediaCrateUploadPartRequest = {
+    start: number;
+    end: number;
+    partNumber: number;
+};
+export type MediaCrateUploadSource = {
+    name: string;
+    type?: string;
+    size: number;
+    lastModified?: number;
+    fingerprint?: string;
+    /**
+     * Set this to false for adapters that can only upload through multipart
+     * form-data, for example some React Native URI-backed sources.
+     */
+    canUseSingleUpload?: boolean;
+    getPart: (request: MediaCrateUploadPartRequest) => Promise<MediaCrateUploadPartBody>;
+};
+export type MediaCrateMultipartSession = {
+    key: string;
+    mode: MediaCrateUploadMode;
+    path: string;
+    marketId: string;
+    uploadId: string;
+    chunkSize: number;
+    totalBytes: number;
+    totalParts: number;
+    sourceFingerprint: string;
+    overwrite: boolean;
+    sections: MediaCrateMultipartSection[];
+    targetKey?: string;
+    startResult?: MediaCrateUploadResult;
+    createdAt: number;
+    updatedAt: number;
+};
+export type MediaCrateMultipartSessionStore = {
+    get: (key: string) => Promise<MediaCrateMultipartSession | null>;
+    set: (key: string, session: MediaCrateMultipartSession) => Promise<void>;
+    delete: (key: string) => Promise<void>;
+};
+export type MediaCrateClientOptions = {
+    baseUrl?: string;
+    marketId: string;
+    getFirebaseToken: () => Promise<string>;
+    fetchImpl?: typeof fetch;
+    sessionStore?: MediaCrateMultipartSessionStore;
+    chunkSizeBytes?: number;
+    maxPartAttempts?: number;
+    maxFinishAttempts?: number;
+    retryBaseDelayMs?: number;
+    maxConcurrentParts?: number;
+    defaultUploadStrategy?: MediaCrateUploadStrategy;
+    sleep?: (durationMs: number) => Promise<void>;
+    now?: () => number;
+    random?: () => number;
+};
+export type MediaCrateUploadOptions = {
+    overwrite?: boolean;
+    strategy?: MediaCrateUploadStrategy;
+    chunkSizeBytes?: number;
+    maxConcurrentParts?: number;
+    sessionKey?: string;
+    onProgress?: (progress: MediaCrateUploadProgress) => void;
+};
+export type MediaCrateLotMediaUploadOptions = MediaCrateUploadOptions & {
+    saleId: string;
+    lotId: string;
+    attributeId: string;
+    source: MediaCrateUploadSource;
+    fileName?: string;
+};
+export type MediaCrateMediaUploadOptions = MediaCrateUploadOptions & {
+    mode: MediaCrateMediaMode;
+    path: string;
+    source: MediaCrateUploadSource;
+};
+export type MediaCrateDeleteOptions = {
+    fileUrl: string;
+};
+export type MediaCrateDuplicateOptions = {
+    sourceUrl: string;
+    targetFilePath: string;
+    targetFileName?: string;
+    overwrite?: boolean;
+};
+type ParsedErrorBody = Partial<MediaCrateErrorResponse> & {
+    [key: string]: unknown;
+};
+export declare class MediaCrateHttpError extends Error {
+    status: number;
+    method: string;
+    url: string;
+    body: ParsedErrorBody | string | null;
+    collidingKeys?: string[];
+    constructor(args: {
+        status: number;
+        method: string;
+        url: string;
+        message: string;
+        body: ParsedErrorBody | string | null;
+        collidingKeys?: string[];
+    });
+}
+export declare class MediaCrateUploadSourceError extends Error {
+    constructor(message: string);
+}
+export declare class InMemoryMediaCrateMultipartSessionStore implements MediaCrateMultipartSessionStore {
+    private sessions;
+    get(key: string): Promise<MediaCrateMultipartSession | null>;
+    set(key: string, session: MediaCrateMultipartSession): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+export declare function createWebUploadSource(file: Blob, opts?: {
+    name?: string;
+    type?: string;
+    lastModified?: number;
+    fingerprint?: string;
+}): MediaCrateUploadSource;
+export declare class MediaCrateClient {
+    readonly baseUrl: string;
+    readonly marketId: string;
+    private getFirebaseToken;
+    private fetchImpl;
+    private sessionStore;
+    private chunkSizeBytes;
+    private maxPartAttempts;
+    private maxFinishAttempts;
+    private retryBaseDelayMs;
+    private maxConcurrentParts;
+    private defaultUploadStrategy;
+    private sleep;
+    private now;
+    private random;
+    constructor(opts: MediaCrateClientOptions);
+    createMediaPath(...segments: string[]): string;
+    createLotMediaPath(args: {
+        saleId: string;
+        lotId: string;
+        attributeId: string;
+        fileName: string;
+    }): string;
+    uploadLotMedia(opts: MediaCrateLotMediaUploadOptions): Promise<MediaCrateUploadResult>;
+    uploadMedia(opts: MediaCrateMediaUploadOptions): Promise<MediaCrateUploadResult>;
+    private upload;
+    getStatus(statusUrl: string): Promise<MediaCrateStatusResult>;
+    delete(opts: MediaCrateDeleteOptions): Promise<void>;
+    duplicate(opts: MediaCrateDuplicateOptions): Promise<MediaCrateDuplicateResult>;
+    cancelMultipartUpload(args: {
+        mode: MediaCrateUploadMode;
+        path: string;
+        uploadId: string;
+        fileName?: string;
+        sessionKey?: string;
+    }): Promise<void>;
+    private resolveUploadStrategy;
+    private uploadSingle;
+    private uploadMultipart;
+    private getOrStartMultipartSession;
+    private startMultipartUpload;
+    private uploadPartWithRetry;
+    private uploadMultipartPart;
+    private finishMultipartUploadWithRetry;
+    private finishMultipartUpload;
+    private cancelDirectMultipartUpload;
+    private cancelProcessedMultipartUpload;
+    private runWithRetry;
+    private getRetryDelay;
+    private createBaseHeaders;
+    private createUploadHeaders;
+    private assertPathMatchesMarket;
+    private urlFor;
+}
+export declare function getMediaCrateBaseUrlFromEnv(env?: MediaCrateProjectEnv): string;
+export {};

package/dist/net/http.d.ts

@@ -1,7 +1,7 @@
 export default function SimpleHttpClient(baseUrl: string, apiKey: string, fetch: any, defaultTimeout: number, debug?: boolean): {
     get: <T>(path: string, queryParams?: any) => Promise<T>;
-    post: <T_1>(path: string, body: any) => Promise<T_1>;
-    patch: <T_2>(path: string, body: any) => Promise<T_2>;
-    delete: <T_3>(path: string) => Promise<T_3>;
+    post: <T>(path: string, body: any) => Promise<T>;
+    patch: <T>(path: string, body: any) => Promise<T>;
+    delete: <T>(path: string) => Promise<T>;
 };
 export type HttpClient = ReturnType<typeof SimpleHttpClient>;

package/dist/resources/actions.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { HttpClient } from "../net/http";
 export default function create(_: HttpClient): {
     /***

package/dist/resources/customerLists.d.ts

@@ -1,6 +1,7 @@
 import { HttpClient } from "../net/http";
 export type CustomerListType = "simple" | "smart";
 export type CustomerListRole = "buyer" | "seller" | "both";
+export type CustomerListSourceCustomerType = Exclude<CustomerListRole, "both">;
 export interface GeoBounds {
     north: number;
     south: number;
@@ -17,11 +18,16 @@ export interface CustomerListQuery {
     filter?: string;
     excludeFilters?: string[];
     bounds?: GeoBounds;
+    sourceCustomerType?: CustomerListSourceCustomerType | null;
+    sourceSaleId?: string | null;
+    sourceCustomerIds?: string[];
     rollingDateConfig?: RollingDateConfig;
     secondaryFilter?: {
         role: CustomerListRole;
         filter?: string;
         bounds?: GeoBounds;
+        sourceCustomerType?: CustomerListSourceCustomerType | null;
+        sourceCustomerIds?: string[];
         rollingDateConfig?: RollingDateConfig;
     };
 }
@@ -62,10 +68,13 @@ export interface CustomerListMember {
     phoneNumber?: string;
 }
 export interface CustomerListFilterGroup {
-    role: CustomerListRole;
+    role?: CustomerListRole | null;
     dateStart?: string | null;
     dateEnd?: string | null;
     productCodes?: string[];
+    sourceCustomerType?: CustomerListSourceCustomerType | null;
+    sourceCustomerIds?: string[];
+    sourceSaleId?: string | null;
     geoBounds?: GeoBounds | null;
     rollingDateConfig?: RollingDateConfig;
 }
@@ -74,6 +83,9 @@ export interface CustomerListFilters {
     dateStart?: string | null;
     dateEnd?: string | null;
     productCodes?: string[];
+    sourceCustomerType?: CustomerListSourceCustomerType | null;
+    sourceCustomerIds?: string[];
+    sourceSaleId?: string | null;
     excludeDateStart?: string | null;
     excludeDateEnd?: string | null;
     excludedProductCodes?: string[];
@@ -155,6 +167,10 @@ export interface CustomerListMembersResponse {
 export interface CustomerListPreviewResponse {
     rows: CustomerListReportRow[];
     summary: CustomerListReportSummary;
+    sourceGroups?: Array<{
+        source: CustomerListReportRow;
+        targets: CustomerListReportRow[];
+    }>;
 }
 export interface CustomerListProductCodesResponse {
     uniqueProductCodes: string[];

package/dist/resources/payouts.d.ts

@@ -29,6 +29,10 @@ export interface CreatePayoutRequest {
     sortCode?: string;
     /** Name on cheque (Cheque only). Falls back to customer display name. */
     chequeMadePayableTo?: string;
+    /** True when the cheque has already been issued and should not be queued for Studio printing. */
+    chequeIsPrinted?: boolean;
+    /** True when the cheque was written or printed outside Studio. */
+    chequeIssuedManually?: boolean;
 }
 export default function create(httpClient: HttpClient): {
     /**

package/dist/resources/productCodes.d.ts

@@ -1,9 +1,13 @@
 import { HttpClient } from "../net/http";
 import { ProductCodeConfiguration, ReadOptions } from "../types";
+type ProductCodeListOptions = {
+    includeArchived?: boolean;
+};
 export default function create(httpClient: HttpClient): {
-    list: (marketId: string) => Promise<ProductCodeConfiguration[]>;
+    list: (marketId: string, options?: ProductCodeListOptions) => Promise<ProductCodeConfiguration[]>;
     get: (marketId: string, id: string, options?: ReadOptions) => Promise<ProductCodeConfiguration>;
     create: (marketId: string, data: Partial<ProductCodeConfiguration>) => Promise<ProductCodeConfiguration>;
     update: (marketId: string, id: string, data: Partial<ProductCodeConfiguration>) => Promise<ProductCodeConfiguration>;
 };
 export type ProductCodes = ReturnType<typeof create>;
+export {};

package/dist/resources/webhooks.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { HttpClient } from "../net/http";
 import { WebhookEvent } from "../types";
 export default function create(_: HttpClient): {