@sogni-ai/sogni-client 4.0.0-alpha.37 → 4.0.0-alpha.38

package/src/Projects/index.ts

@@ -11,7 +11,15 @@ import {
   SupportedModel,
   ImageProjectParams,
   VideoProjectParams,
-  VideoEstimateRequest
+  VideoEstimateRequest,
+  SupportedComfySamplers,
+  SupportedForgeSamplers,
+  SupportedComfySchedulers,
+  SupportedForgeSchedulers,
+  ComfyScheduler,
+  ForgeScheduler,
+  ComfySampler,
+  ForgeSampler
 } from './types';
 import {
   JobErrorData,
@@ -39,7 +47,7 @@ import {
   VIDEO_WORKFLOW_ASSETS
 } from './utils';
 import { TokenType } from '../types/token';
-import { validateSampler } from '../lib/validation';
+import { isComfyModel, validateSampler } from '../lib/validation';
 
 const sizePresetCache = new Cache<SizePreset[]>(10 * 60 * 1000);
 const GARBAGE_COLLECT_TIMEOUT = 30000;
@@ -61,17 +69,17 @@ function getFileContentType(file: File | Buffer | Blob): string | undefined {
  * Convert file to a format compatible with fetch body.
  * Converts Node.js Buffer to Blob for cross-platform compatibility.
  */
-function toFetchBody(file: File | Buffer | Blob) {
+function toFetchBody(file: File | Buffer | Blob): BodyInit {
   // Node.js Buffer is not supported in browsers, so we can skip this conversion
   if (typeof Buffer === 'undefined') {
-    return file;
+    return file as BodyInit;
   }
   if (Buffer.isBuffer(file)) {
     // Copy Buffer data to a new ArrayBuffer to ensure type compatibility
     const arrayBuffer = file.buffer.slice(file.byteOffset, file.byteOffset + file.byteLength);
     return new Blob([arrayBuffer as ArrayBuffer]);
   }
-  return file;
+  return file as BodyInit;
 }
 
 function mapErrorCodes(code: string): number {
@@ -126,7 +134,11 @@ class ProjectsApi extends ApiGroup<ProjectApiEvents> {
     this.client.socket.on('jobProgress', this.handleJobProgress.bind(this));
     this.client.socket.on('jobETA', this.handleJobETA.bind(this));
     this.client.socket.on('jobError', this.handleJobError.bind(this));
-    this.client.socket.on('jobResult', this.handleJobResult.bind(this));
+    this.client.socket.on('jobResult', (data: any) => {
+      this.handleJobResult(data).catch((err) => {
+        this.client.logger.error('Error in handleJobResult:', err);
+      });
+    });
     // Listen to the server disconnect event
     this.client.on('disconnected', this.handleServerDisconnected.bind(this));
     // Listen to project and job events and update project and job instances
@@ -245,27 +257,47 @@ class ProjectsApi extends ApiGroup<ProjectApiEvents> {
   private async handleJobResult(data: JobResultData) {
     const project = this.projects.find((p) => p.id === data.jobID);
     const passNSFWCheck = !data.triggeredNSFWFilter || !project || project.params.disableNSFWFilter;
-    let downloadUrl = null;
-    // If NSFW filter is triggered, image will be only available for download if user explicitly
-    // disabled the filter for this project
-    if (passNSFWCheck && !data.userCanceled) {
+    let downloadUrl = data.resultUrl || null; // Use resultUrl from event if provided
+
+    // If no resultUrl provided and NSFW check passes, generate download URL
+    if (!downloadUrl && passNSFWCheck && !data.userCanceled) {
       // Use media endpoint for video models, image endpoint for image models
       const isVideo = project && this.isVideoModelId(project.params.modelId);
-      if (isVideo) {
-        downloadUrl = await this.mediaDownloadUrl({
-          jobId: data.jobID,
-          id: data.imgID,
-          type: 'complete'
-        });
-      } else {
-        downloadUrl = await this.downloadUrl({
-          jobId: data.jobID,
-          imageId: data.imgID,
-          type: 'complete'
+      try {
+        if (isVideo) {
+          downloadUrl = await this.mediaDownloadUrl({
+            jobId: data.jobID,
+            id: data.imgID,
+            type: 'complete'
+          });
+        } else {
+          downloadUrl = await this.downloadUrl({
+            jobId: data.jobID,
+            imageId: data.imgID,
+            type: 'complete'
+          });
+        }
+      } catch (error: any) {
+        // Continue with null downloadUrl - the event will indicate failure
+      }
+    }
+
+    // Update the job directly with the result URL to prevent duplicate API calls
+    if (project) {
+      const job = project.job(data.imgID);
+      if (job) {
+        job._update({
+          status: data.userCanceled ? 'canceled' : 'completed',
+          step: data.performedStepCount,
+          seed: Number(data.lastSeed),
+          resultUrl: downloadUrl,
+          isNSFW: data.triggeredNSFWFilter,
+          userCanceled: data.userCanceled
         });
       }
     }
 
+    // Emit job completion event with the generated download URL
     this.emit('job', {
       type: 'completed',
       projectId: data.jobID,
@@ -494,6 +526,7 @@ class ProjectsApi extends ApiGroup<ProjectApiEvents> {
   async create(data: ProjectParams): Promise<Project> {
     const project = new Project({ ...data }, { api: this, logger: this.client.logger });
     const request = createJobRequestMessage(project.id, data);
+
     switch (data.type) {
       case 'image':
         await this._processImageAssets(project, data);
@@ -650,9 +683,10 @@ class ProjectsApi extends ApiGroup<ProjectApiEvents> {
       jobId: projectId,
       type: `contextImage${imageIndex}`
     });
+    const body = toFetchBody(file);
     const res = await fetch(presignedUrl, {
       method: 'PUT',
-      body: toFetchBody(file)
+      body
     });
     if (!res.ok) {
       throw new ApiError(res.status, {
@@ -825,7 +859,7 @@ class ProjectsApi extends ApiGroup<ProjectApiEvents> {
     if (sampler) {
       apiVersion = 3;
       pathParams.push(guidance || 0);
-      pathParams.push(validateSampler(sampler)!);
+      pathParams.push(validateSampler(model, sampler)!);
       pathParams.push(contextImages || 0);
     }
     const r = await this.client.socket.get<EstimationResponse>(
@@ -922,6 +956,9 @@ class ProjectsApi extends ApiGroup<ProjectApiEvents> {
       `/v1/image/downloadUrl`,
       params
     );
+    if (!r?.data?.downloadUrl) {
+      throw new Error(`API returned no downloadUrl: ${JSON.stringify(r)}`);
+    }
     return r.data.downloadUrl;
   }
 
@@ -946,6 +983,9 @@ class ProjectsApi extends ApiGroup<ProjectApiEvents> {
       `/v1/media/downloadUrl`,
       params
     );
+    if (!r?.data?.downloadUrl) {
+      throw new Error(`API returned no downloadUrl: ${JSON.stringify(r)}`);
+    }
     return r.data.downloadUrl;
   }
 
@@ -1064,6 +1104,20 @@ class ProjectsApi extends ApiGroup<ProjectApiEvents> {
       };
     });
   }
+
+  async getSamplers(modelId: string) {
+    if (isComfyModel(modelId)) {
+      return Object.keys(SupportedComfySamplers) as ComfySampler[];
+    }
+    return Object.keys(SupportedForgeSamplers) as ForgeSampler[];
+  }
+
+  async getSchedulers(modelId: string) {
+    if (isComfyModel(modelId)) {
+      return Object.keys(SupportedComfySchedulers) as ComfyScheduler[];
+    }
+    return Object.keys(SupportedForgeSchedulers) as ForgeScheduler[];
+  }
 }
 
 export default ProjectsApi;

package/src/Projects/types/ComfySamplerParams.ts

@@ -0,0 +1,31 @@
+/**
+ * ComfyUI sampler parameters for video models and ComfyUI-based image models.
+ * These use lowercase underscore format directly matching ComfyUI's internal names.
+ */
+export const SupportedComfySamplers = {
+  euler: 'euler',
+  euler_ancestral: 'euler_ancestral',
+  heun: 'heun',
+  dpmpp_2m: 'dpmpp_2m',
+  dpmpp_2m_sde: 'dpmpp_2m_sde',
+  dpmpp_sde: 'dpmpp_sde',
+  dpmpp_3m_sde: 'dpmpp_3m_sde',
+  uni_pc: 'uni_pc',
+  lcm: 'lcm',
+  // Additional ComfyUI samplers
+  lms: 'lms',
+  dpm_2: 'dpm_2',
+  dpm_2_ancestral: 'dpm_2_ancestral',
+  dpm_fast: 'dpm_fast',
+  dpm_adaptive: 'dpm_adaptive',
+  dpmpp_2s_ancestral: 'dpmpp_2s_ancestral',
+  ddpm: 'ddpm',
+  ddim: 'ddim',
+  uni_pc_bh2: 'uni_pc_bh2'
+};
+
+export function isComfySampler(sampler: string): sampler is ComfySampler {
+  return sampler in SupportedComfySamplers;
+}
+
+export type ComfySampler = keyof typeof SupportedComfySamplers;

package/src/Projects/types/ComfySchedulerParams.ts

@@ -0,0 +1,21 @@
+/**
+ * ComfyUI scheduler parameters for video models and ComfyUI-based image models.
+ * These use lowercase underscore format directly matching ComfyUI's internal names.
+ */
+export const SupportedComfySchedulers = {
+  simple: 'simple',
+  normal: 'normal',
+  karras: 'karras',
+  exponential: 'exponential',
+  sgm_uniform: 'sgm_uniform',
+  ddim_uniform: 'ddim_uniform',
+  beta: 'beta',
+  linear_quadratic: 'linear_quadratic',
+  kl_optimal: 'kl_optimal'
+};
+
+export function isComfyScheduler(scheduler: string): scheduler is ComfyScheduler {
+  return scheduler in SupportedComfySchedulers;
+}
+
+export type ComfyScheduler = keyof typeof SupportedComfySchedulers;

package/src/Projects/types/ForgeSamplerParams.ts

@@ -0,0 +1,37 @@
+export const SupportedForgeSamplers = {
+  euler: 'Euler',
+  euler_ancestral: 'Euler Ancestral',
+  heun: 'Heun',
+  dpmpp_2m: 'DPM++ 2M',
+  dpmpp_2m_sde: 'DPM++ 2M SDE',
+  dpmpp_sde: 'DPM++ SDE',
+  dpmpp_3m_sde: 'DPM++ 3M SDE',
+  uni_pc: 'UniPC',
+  lcm: 'LCM (Latent Consistency Model)',
+  // Legacy/other supported samplers
+  lms: 'LMS',
+  dpm_2: 'DPM 2',
+  dpm_2_ancestral: 'DPM 2 Ancestral',
+  dpm_fast: 'DPM Fast',
+  dpm_adaptive: 'DPM Adaptive',
+  dpmpp_2s_ancestral: 'DPM++ 2S Ancestral',
+  ddpm: 'DDPM',
+  // SDK compatibility aliases
+  dfs_sd3: 'Discrete Flow Scheduler (SD3)',
+  dpm_pp: 'DPM Solver Multistep (DPM-Solver++)',
+  dpm_pp_sde: 'DPM++ SDE',
+  dpm_pp_2m: 'DPM++ 2M',
+  euler_a: 'Euler a',
+  pndm_plms: 'PNDM (Pseudo-linear multi-step)'
+};
+
+export function isForgeSampler(sampler: string): sampler is ForgeSampler {
+  return sampler in SupportedForgeSamplers;
+}
+
+export function isRawForgeSampler(sampler: string): boolean {
+  const samplers = Object.values(SupportedForgeSamplers);
+  return samplers.includes(sampler);
+}
+
+export type ForgeSampler = keyof typeof SupportedForgeSamplers;

package/src/Projects/types/ForgeSchedulerParams.ts

@@ -0,0 +1,26 @@
+export const SupportedForgeSchedulers = {
+  simple: 'Simple',
+  normal: 'Normal',
+  karras: 'Karras',
+  exponential: 'Exponential',
+  sgm_uniform: 'SGM Uniform',
+  ddim_uniform: 'DDIM Uniform',
+  beta: 'Beta',
+  linear_quadratic: 'Linear Quadratic',
+  kl_optimal: 'KL Optimal',
+  // Legacy aliases
+  ddim: 'DDIM',
+  leading: 'Leading',
+  linear: 'Linear'
+};
+
+export function isForgeScheduler(scheduler: string): scheduler is ForgeScheduler {
+  return scheduler in SupportedForgeSchedulers;
+}
+
+export function isRawForgeScheduler(scheduler: string): boolean {
+  const schedulers = Object.values(SupportedForgeSchedulers);
+  return schedulers.includes(scheduler);
+}
+
+export type ForgeScheduler = keyof typeof SupportedForgeSchedulers;

package/src/Projects/types/index.ts

@@ -1,8 +1,10 @@
 import { SupernetType } from '../../ApiClient/WebSocketClient/types';
 import { ControlNetParams } from './ControlNetParams';
 import { TokenType } from '../../types/token';
-import { Sampler, SupportedSamplers } from './SamplerParams';
-import { Scheduler, SupportedSchedulers } from './SchedulerParams';
+import { ForgeSampler, SupportedForgeSamplers } from './ForgeSamplerParams';
+import { ForgeScheduler, SupportedForgeSchedulers } from './ForgeSchedulerParams';
+import { ComfySampler, SupportedComfySamplers } from './ComfySamplerParams';
+import { ComfyScheduler, SupportedComfySchedulers } from './ComfySchedulerParams';
 
 export interface SupportedModel {
   id: string;
@@ -33,9 +35,18 @@ export interface SizePreset {
   aspect: string;
 }
 
-export type { Sampler, Scheduler };
+export type Sampler = ForgeSampler | ComfySampler;
 
-export { SupportedSamplers, SupportedSchedulers };
+export type Scheduler = ForgeScheduler | ComfyScheduler;
+
+export type { ForgeSampler, ForgeScheduler, ComfySampler, ComfyScheduler };
+
+export {
+  SupportedForgeSamplers,
+  SupportedForgeSchedulers,
+  SupportedComfySamplers,
+  SupportedComfySchedulers
+};
 
 export type ImageOutputFormat = 'png' | 'jpg';
 export type VideoOutputFormat = 'mp4';
@@ -152,6 +163,18 @@ export interface VideoProjectParams extends BaseProjectParams {
    * Output video height. Only used if `sizePreset` is "custom"
    */
   height?: number;
+  /**
+   * ComfyUI sampler for video generation.
+   * Uses ComfyUI's native lowercase format: euler, euler_ancestral, dpmpp_2m, etc.
+   * Default: euler (or uni_pc for s2v models)
+   */
+  sampler?: ComfySampler;
+  /**
+   * ComfyUI scheduler for video generation.
+   * Uses ComfyUI's native lowercase format: simple, normal, karras, sgm_uniform, etc.
+   * Default: simple
+   */
+  scheduler?: ComfyScheduler;
   /**
    * Output video format. For now only 'mp4' is supported, defaults to 'mp4'.
    */
@@ -184,11 +207,13 @@ export interface ImageProjectParams extends BaseProjectParams {
    */
   contextImages?: InputMedia[];
   /**
-   * Scheduler to use
+   * Legacy sampler for non-ComfyUI models (Automatic1111 workers).
+   * Not supported for ComfyUI models - use comfySampler instead.
    */
   sampler?: Sampler;
   /**
-   * Time step spacing method
+   * Legacy scheduler for non-ComfyUI models (Automatic1111 workers).
+   * Not supported for ComfyUI models - use comfyScheduler instead.
    */
   scheduler?: Scheduler;
   /**

package/src/index.ts

@@ -19,8 +19,10 @@ import {
   ProjectParams,
   Sampler,
   Scheduler,
-  SupportedSamplers,
-  SupportedSchedulers,
+  SupportedForgeSamplers,
+  SupportedForgeSchedulers,
+  SupportedComfySamplers,
+  SupportedComfySchedulers,
   VideoProjectParams,
   AudioFormat,
   VideoFormat,
@@ -56,7 +58,16 @@ export type {
   VideoWorkflowType
 };
 
-export { ApiError, CurrentAccount, Job, Project, SupportedSamplers, SupportedSchedulers };
+export {
+  ApiError,
+  CurrentAccount,
+  Job,
+  Project,
+  SupportedComfySchedulers,
+  SupportedComfySamplers,
+  SupportedForgeSchedulers,
+  SupportedForgeSamplers
+};
 
 export interface SogniClientConfig {
   /**

package/src/lib/RestClient.ts

@@ -30,7 +30,21 @@ class RestClient<E extends EventMap = never> extends TypedEventEmitter<E> {
 
   private async request<T = JSONValue>(url: string, options: RequestInit = {}): Promise<T> {
     const init = await this.auth.authenticateRequest(options);
-    return fetch(url, init).then((r) => this.processResponse(r) as T);
+
+    // Add a timeout to detect hanging requests
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => {
+      controller.abort();
+    }, 30000);
+
+    try {
+      const response = await fetch(url, { ...init, signal: controller.signal });
+      clearTimeout(timeoutId);
+      return this.processResponse(response) as T;
+    } catch (fetchError: any) {
+      clearTimeout(timeoutId);
+      throw fetchError;
+    }
   }
 
   private async processResponse(response: Response): Promise<JSONValue> {
@@ -52,7 +66,7 @@ class RestClient<E extends EventMap = never> extends TypedEventEmitter<E> {
   }
 
   get<T = JSONValue>(path: string, query: Record<string, any> = {}): Promise<T> {
-    return this.request<T>(this.formatUrl(path, query), query);
+    return this.request<T>(this.formatUrl(path, query));
   }
 
   post<T = JSONValue>(path: string, body: Record<string, unknown> = {}): Promise<T> {

package/src/lib/validation.ts

@@ -1,5 +1,15 @@
-import { isRawSampler, isSampler, SupportedSamplers } from '../Projects/types/SamplerParams';
-import { isScheduler, SupportedSchedulers } from '../Projects/types/SchedulerParams';
+import {
+  isRawForgeSampler,
+  isForgeSampler,
+  SupportedForgeSamplers
+} from '../Projects/types/ForgeSamplerParams';
+import {
+  isForgeScheduler,
+  isRawForgeScheduler,
+  SupportedForgeSchedulers
+} from '../Projects/types/ForgeSchedulerParams';
+import { isComfySampler, SupportedComfySamplers } from '../Projects/types/ComfySamplerParams';
+import { isComfyScheduler, SupportedComfySchedulers } from '../Projects/types/ComfySchedulerParams';
 
 export function validateCustomImageSize(value: any): number {
   return validateNumber(value, { min: 256, max: 2048, propertyName: 'Width and height' });
@@ -54,33 +64,33 @@ export function validateNumber(
   return number;
 }
 
-export function validateSampler(value?: string) {
+export function validateForgeSampler(value?: string) {
   if (!value) {
     return null;
   }
-  if (isRawSampler(value)) {
+  if (isRawForgeSampler(value)) {
     return value;
   }
-  if (isSampler(value)) {
-    return SupportedSamplers[value];
+  if (isForgeSampler(value)) {
+    return SupportedForgeSamplers[value];
   }
   throw new Error(
-    `Invalid sampler: ${value}. Supported options: ${Object.keys(SupportedSamplers).join(', ')}`
+    `Invalid sampler: ${value}. Supported options: ${Object.keys(SupportedForgeSamplers).join(', ')}`
   );
 }
 
-export function validateScheduler(value?: string) {
+export function validateForgeScheduler(value?: string) {
   if (!value) {
     return null;
   }
-  if (isRawSampler(value)) {
+  if (isRawForgeScheduler(value)) {
     return value;
   }
-  if (isScheduler(value)) {
-    return SupportedSchedulers[value];
+  if (isForgeScheduler(value)) {
+    return SupportedForgeSchedulers[value];
   }
   throw new Error(
-    `Invalid scheduler: ${value}. Supported options: ${Object.keys(SupportedSchedulers).join(', ')}`
+    `Invalid scheduler: ${value}. Supported options: ${Object.keys(SupportedForgeSchedulers).join(', ')}`
   );
 }
 
@@ -101,3 +111,54 @@ export function validateTeacacheThreshold(value?: number): number | undefined {
   }
   return num;
 }
+
+/**
+ * Validate ComfyUI sampler for video models.
+ * Returns the sampler string directly (no mapping needed).
+ */
+export function validateComfySampler(value?: string): string | undefined {
+  if (!value) {
+    return undefined;
+  }
+  if (isComfySampler(value)) {
+    return SupportedComfySamplers[value];
+  }
+  throw new Error(
+    `Invalid comfySampler: ${value}. Supported options: ${Object.keys(SupportedComfySamplers).join(', ')}`
+  );
+}
+
+/**
+ * Validate ComfyUI scheduler for video models.
+ * Returns the scheduler string directly (no mapping needed).
+ */
+export function validateComfyScheduler(value?: string): string | undefined {
+  if (!value) {
+    return undefined;
+  }
+  if (isComfyScheduler(value)) {
+    return SupportedComfySchedulers[value];
+  }
+  throw new Error(
+    `Invalid comfyScheduler: ${value}. Supported options: ${Object.keys(SupportedComfySchedulers).join(', ')}`
+  );
+}
+
+export function isComfyModel(modelId: string): boolean {
+  const COMFY_PREFIXES = ['z_image_', 'qwen_image_', 'flux2_', 'wan_'];
+  return COMFY_PREFIXES.some((prefix) => modelId.startsWith(prefix));
+}
+
+export function validateSampler(modelId: string, sampler: string) {
+  if (isComfyModel(modelId)) {
+    return validateComfySampler(sampler);
+  }
+  return validateForgeSampler(sampler);
+}
+
+export function validateScheduler(modelId: string, scheduler: string) {
+  if (isComfyModel(modelId)) {
+    return validateComfyScheduler(scheduler);
+  }
+  return validateForgeScheduler(scheduler);
+}

package/dist/Projects/types/SamplerParams.d.ts

@@ -1,13 +0,0 @@
-export declare const SupportedSamplers: {
-    dfs_sd3: string;
-    dpm_pp: string;
-    dpm_pp_sde: string;
-    dpm_pp_2m: string;
-    euler: string;
-    euler_a: string;
-    lcm: string;
-    pndm_plms: string;
-};
-export declare function isSampler(sampler: string): sampler is Sampler;
-export declare function isRawSampler(sampler: string): boolean;
-export type Sampler = keyof typeof SupportedSamplers;

package/dist/Projects/types/SamplerParams.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SupportedSamplers = void 0;
-exports.isSampler = isSampler;
-exports.isRawSampler = isRawSampler;
-exports.SupportedSamplers = {
-    dfs_sd3: 'Discrete Flow Scheduler (SD3)',
-    dpm_pp: 'DPM Solver Multistep (DPM-Solver++)',
-    dpm_pp_sde: 'DPM++ SDE',
-    dpm_pp_2m: 'DPM++ 2M',
-    //dpm_pp_2m_sde: 'DPM++ 2M SDE',
-    euler: 'Euler',
-    euler_a: 'Euler a',
-    //heun: 'Heun',
-    lcm: 'LCM (Latent Consistency Model)',
-    pndm_plms: 'PNDM (Pseudo-linear multi-step)'
-    //uni_pc: 'UniPC'
-};
-function isSampler(sampler) {
-    return sampler in exports.SupportedSamplers;
-}
-function isRawSampler(sampler) {
-    const samplers = Object.values(exports.SupportedSamplers);
-    return samplers.includes(sampler);
-}
-//# sourceMappingURL=SamplerParams.js.map

package/dist/Projects/types/SamplerParams.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SamplerParams.js","sourceRoot":"","sources":["../../../src/Projects/types/SamplerParams.ts"],"names":[],"mappings":";;;AAcA,8BAEC;AAED,oCAGC;AArBY,QAAA,iBAAiB,GAAG;IAC/B,OAAO,EAAE,+BAA+B;IACxC,MAAM,EAAE,qCAAqC;IAC7C,UAAU,EAAE,WAAW;IACvB,SAAS,EAAE,UAAU;IACrB,gCAAgC;IAChC,KAAK,EAAE,OAAO;IACd,OAAO,EAAE,SAAS;IAClB,eAAe;IACf,GAAG,EAAE,gCAAgC;IACrC,SAAS,EAAE,iCAAiC;IAC5C,iBAAiB;CAClB,CAAC;AAEF,SAAgB,SAAS,CAAC,OAAe;IACvC,OAAO,OAAO,IAAI,yBAAiB,CAAC;AACtC,CAAC;AAED,SAAgB,YAAY,CAAC,OAAe;IAC1C,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,yBAAiB,CAAC,CAAC;IAClD,OAAO,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;AACpC,CAAC"}

package/dist/Projects/types/SchedulerParams.d.ts

@@ -1,14 +0,0 @@
-export declare const SupportedSchedulers: {
-    beta: string;
-    ddim: string;
-    karras: string;
-    kl_optimal: string;
-    leading: string;
-    linear: string;
-    normal: string;
-    sgm_uniform: string;
-    simple: string;
-};
-export declare function isScheduler(scheduler: string): scheduler is Scheduler;
-export declare function isRawScheduler(scheduler: string): boolean;
-export type Scheduler = keyof typeof SupportedSchedulers;

package/dist/Projects/types/SchedulerParams.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SupportedSchedulers = void 0;
-exports.isScheduler = isScheduler;
-exports.isRawScheduler = isRawScheduler;
-exports.SupportedSchedulers = {
-    beta: 'Beta',
-    ddim: 'DDIM',
-    karras: 'Karras',
-    kl_optimal: 'KL Optimal',
-    leading: 'Leading',
-    linear: 'Linear',
-    normal: 'Normal',
-    sgm_uniform: 'SGM Uniform',
-    simple: 'Simple'
-};
-function isScheduler(scheduler) {
-    return scheduler in exports.SupportedSchedulers;
-}
-function isRawScheduler(scheduler) {
-    const schedulers = Object.values(exports.SupportedSchedulers);
-    return schedulers.includes(scheduler);
-}
-//# sourceMappingURL=SchedulerParams.js.map

package/dist/Projects/types/SchedulerParams.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SchedulerParams.js","sourceRoot":"","sources":["../../../src/Projects/types/SchedulerParams.ts"],"names":[],"mappings":";;;AAYA,kCAEC;AAED,wCAGC;AAnBY,QAAA,mBAAmB,GAAG;IACjC,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,QAAQ;IAChB,UAAU,EAAE,YAAY;IACxB,OAAO,EAAE,SAAS;IAClB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,WAAW,EAAE,aAAa;IAC1B,MAAM,EAAE,QAAQ;CACjB,CAAC;AAEF,SAAgB,WAAW,CAAC,SAAiB;IAC3C,OAAO,SAAS,IAAI,2BAAmB,CAAC;AAC1C,CAAC;AAED,SAAgB,cAAc,CAAC,SAAiB;IAC9C,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,2BAAmB,CAAC,CAAC;IACtD,OAAO,UAAU,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;AACxC,CAAC"}

package/src/Projects/types/SamplerParams.ts

@@ -1,24 +0,0 @@
-export const SupportedSamplers = {
-  dfs_sd3: 'Discrete Flow Scheduler (SD3)',
-  dpm_pp: 'DPM Solver Multistep (DPM-Solver++)',
-  dpm_pp_sde: 'DPM++ SDE',
-  dpm_pp_2m: 'DPM++ 2M',
-  //dpm_pp_2m_sde: 'DPM++ 2M SDE',
-  euler: 'Euler',
-  euler_a: 'Euler a',
-  //heun: 'Heun',
-  lcm: 'LCM (Latent Consistency Model)',
-  pndm_plms: 'PNDM (Pseudo-linear multi-step)'
-  //uni_pc: 'UniPC'
-};
-
-export function isSampler(sampler: string): sampler is Sampler {
-  return sampler in SupportedSamplers;
-}
-
-export function isRawSampler(sampler: string): boolean {
-  const samplers = Object.values(SupportedSamplers);
-  return samplers.includes(sampler);
-}
-
-export type Sampler = keyof typeof SupportedSamplers;