import * as z from "zod";
import { Result as SafeParseResult } from "../../types/fp.js";
import { SDKValidationError } from "../errors/sdkvalidationerror.js";
import { Asset, Asset$Outbound } from "./asset.js";
import { EncryptionOutput, EncryptionOutput$Outbound } from "./encryptionoutput.js";
import { ExportTaskParams, ExportTaskParams$Outbound } from "./exporttaskparams.js";
import { InputCreatorId, InputCreatorId$Outbound } from "./inputcreatorid.js";
import { IpfsExportParams, IpfsExportParams$Outbound } from "./ipfsexportparams.js";
import { TranscodeProfile, TranscodeProfile$Outbound } from "./transcodeprofile.js";
/**
 * Type of the task
 */
export declare enum TaskType {
    Upload = "upload",
    Export = "export",
    ExportData = "export-data",
    TranscodeFile = "transcode-file",
    Clip = "clip"
}
/**
 * Parameters for the upload task
 */
export type Upload = {
    /**
     * URL of the asset to "upload"
     */
    url?: string | undefined;
    encryption?: EncryptionOutput | undefined;
    /**
     * Decides if the output video should include C2PA signature
     */
    c2pa?: boolean | undefined;
    profiles?: Array<TranscodeProfile> | undefined;
    /**
     * How many seconds the duration of each output segment should be
     */
    targetSegmentSizeSecs?: number | undefined;
};
/**
 * File content to store into IPFS
 */
export type Content = {};
/**
 * Parameters for the export-data task
 */
export type TaskExportData = {
    /**
     * File content to store into IPFS
     */
    content: Content;
    ipfs?: IpfsExportParams | undefined;
    /**
     * Optional type of content
     */
    type?: string | undefined;
    /**
     * Optional ID of the content
     */
    id?: string | undefined;
};
/**
 * Input video file to transcode
 */
export type TaskInput = {
    /**
     * URL of a video to transcode, accepts object-store format
     *
     * @remarks
     * "s3+https"
     */
    url?: string | undefined;
};
/**
 * Storage for the output files
 */
export type TaskStorage = {
    /**
     * URL of the output storage, accepts object-store format
     *
     * @remarks
     * "s3+https"
     */
    url?: string | undefined;
};
/**
 * HLS output format
 */
export type TaskHls = {
    /**
     * Path for the HLS output
     */
    path?: string | undefined;
};
/**
 * MP4 output format
 */
export type TaskMp4 = {
    /**
     * Path for the MP4 output
     */
    path?: string | undefined;
};
/**
 * Output formats
 */
export type TaskOutputs = {
    /**
     * HLS output format
     */
    hls?: TaskHls | undefined;
    /**
     * MP4 output format
     */
    mp4?: TaskMp4 | undefined;
};
/**
 * Parameters for the transcode-file task
 */
export type TranscodeFile = {
    /**
     * Input video file to transcode
     */
    input?: TaskInput | undefined;
    /**
     * Storage for the output files
     */
    storage?: TaskStorage | undefined;
    /**
     * Output formats
     */
    outputs?: TaskOutputs | undefined;
    profiles?: Array<TranscodeProfile> | undefined;
    /**
     * How many seconds the duration of each output segment should
     *
     * @remarks
     * be
     */
    targetSegmentSizeSecs?: number | undefined;
    creatorId?: InputCreatorId | undefined;
    /**
     * Decides if the output video should include C2PA signature
     */
    c2pa?: boolean | undefined;
};
/**
 * Strategy to use for clipping the asset. If not specified, the default strategy that Catalyst is configured for will be used. This field only available for admin users, and is only used for E2E testing.
 */
export type ClipStrategy = {
    /**
     * The start timestamp of the clip in Unix milliseconds. _See the ClipTrigger in the UI Kit for an example of how this is calculated (for HLS, it uses `Program Date-Time` tags, and for WebRTC, it uses the latency from server to client at stream startup)._
     */
    startTime?: number | undefined;
    /**
     * The end timestamp of the clip in Unix milliseconds. _See the ClipTrigger in the UI Kit for an example of how this is calculated (for HLS, it uses `Program Date-Time` tags, and for WebRTC, it uses the latency from server to client at stream startup)._
     */
    endTime?: number | undefined;
    /**
     * The playback ID of the stream or stream recording to clip. Asset playback IDs are not supported yet.
     */
    playbackId?: string | undefined;
};
/**
 * Force to use a specific strategy in the Catalyst pipeline. If not specified, the default strategy that Catalyst is configured for will be used. This field only available for admin users, and is only used for E2E testing.
 */
export declare enum CatalystPipelineStrategy {
    Catalyst = "catalyst",
    CatalystFfmpeg = "catalyst_ffmpeg",
    BackgroundExternal = "background_external",
    BackgroundMist = "background_mist",
    FallbackExternal = "fallback_external",
    External = "external"
}
export type Clip = {
    /**
     * URL of the asset to "clip"
     */
    url?: string | undefined;
    /**
     * Strategy to use for clipping the asset. If not specified, the default strategy that Catalyst is configured for will be used. This field only available for admin users, and is only used for E2E testing.
     */
    clipStrategy?: ClipStrategy | undefined;
    /**
     * Force to use a specific strategy in the Catalyst pipeline. If not specified, the default strategy that Catalyst is configured for will be used. This field only available for admin users, and is only used for E2E testing.
     */
    catalystPipelineStrategy?: CatalystPipelineStrategy | undefined;
    /**
     * ID of the session
     */
    sessionId?: string | undefined;
    /**
     * ID of the input asset or stream
     */
    inputId?: string | undefined;
};
/**
 * Parameters of the task
 */
export type Params = {
    /**
     * Parameters for the upload task
     */
    upload?: Upload | undefined;
    /**
     * Parameters for the export task
     */
    export?: ExportTaskParams | undefined;
    /**
     * Parameters for the export-data task
     */
    exportData?: TaskExportData | undefined;
    /**
     * Parameters for the transcode-file task
     */
    transcodeFile?: TranscodeFile | undefined;
    clip?: Clip | undefined;
};
/**
 * Phase of the task
 */
export declare enum TaskPhase {
    Pending = "pending",
    Waiting = "waiting",
    Running = "running",
    Failed = "failed",
    Completed = "completed",
    Cancelled = "cancelled"
}
/**
 * Status of the task
 */
export type TaskStatus = {
    /**
     * Phase of the task
     */
    phase: TaskPhase;
    /**
     * Timestamp (in milliseconds) at which task was updated
     */
    updatedAt: number;
    /**
     * Current progress of the task in a 0-1 ratio
     */
    progress?: number | undefined;
    /**
     * Error message if the task failed
     */
    errorMessage?: string | undefined;
    /**
     * Number of retries done on the task
     */
    retries?: number | undefined;
};
/**
 * Output of the upload task
 */
export type TaskUpload = {
    assetSpec?: Asset | undefined;
    additionalProperties: {
        [k: string]: any;
    };
};
export type TaskIpfs = {
    /**
     * IPFS CID of the exported video file
     */
    videoFileCid: string;
    /**
     * URL for the file with the IPFS protocol
     */
    videoFileUrl?: string | undefined;
    /**
     * URL to access file via HTTP through an IPFS gateway
     */
    videoFileGatewayUrl?: string | undefined;
    /**
     * IPFS CID of the default metadata exported for the video
     */
    nftMetadataCid?: string | undefined;
    /**
     * URL for the metadata file with the IPFS protocol
     */
    nftMetadataUrl?: string | undefined;
    /**
     * URL to access metadata file via HTTP through an IPFS
     *
     * @remarks
     * gateway
     */
    nftMetadataGatewayUrl?: string | undefined;
};
/**
 * Output of the export task
 */
export type Export = {
    ipfs?: TaskIpfs | undefined;
};
export type TaskSchemasIpfs = {
    /**
     * IPFS CID of the exported data
     */
    cid: string;
};
/**
 * Output of the export data task
 */
export type ExportData = {
    ipfs?: TaskSchemasIpfs | undefined;
};
/**
 * Output of the task
 */
export type Output = {
    /**
     * Output of the upload task
     */
    upload?: TaskUpload | undefined;
    /**
     * Output of the export task
     */
    export?: Export | undefined;
    /**
     * Output of the export data task
     */
    exportData?: ExportData | undefined;
};
export type Task = {
    /**
     * Task ID
     */
    id?: string | undefined;
    /**
     * Type of the task
     */
    type?: TaskType | undefined;
    /**
     * Timestamp (in milliseconds) at which task was created
     */
    createdAt?: number | undefined;
    /**
     * Timestamp (in milliseconds) at which the task was scheduled for
     *
     * @remarks
     * execution (e.g. after file upload finished).
     */
    scheduledAt?: number | undefined;
    /**
     * ID of the input asset
     */
    inputAssetId?: string | undefined;
    /**
     * ID of the output asset
     */
    outputAssetId?: string | undefined;
    /**
     * ID of the project
     */
    projectId?: string | undefined;
    /**
     * ID of the requester hash(IP + SALT + PlaybackId)
     */
    requesterId?: string | undefined;
    /**
     * Parameters of the task
     */
    params?: Params | undefined;
    /**
     * Status of the task
     */
    status?: TaskStatus | undefined;
    /**
     * Output of the task
     */
    output?: Output | undefined;
};
/** @internal */
export declare const TaskType$inboundSchema: z.ZodNativeEnum<typeof TaskType>;
/** @internal */
export declare const TaskType$outboundSchema: z.ZodNativeEnum<typeof TaskType>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace TaskType$ {
    /** @deprecated use `TaskType$inboundSchema` instead. */
    const inboundSchema: z.ZodNativeEnum<typeof TaskType>;
    /** @deprecated use `TaskType$outboundSchema` instead. */
    const outboundSchema: z.ZodNativeEnum<typeof TaskType>;
}
/** @internal */
export declare const Upload$inboundSchema: z.ZodType<Upload, z.ZodTypeDef, unknown>;
/** @internal */
export type Upload$Outbound = {
    url?: string | undefined;
    encryption?: EncryptionOutput$Outbound | undefined;
    c2pa?: boolean | undefined;
    profiles?: Array<TranscodeProfile$Outbound> | undefined;
    targetSegmentSizeSecs?: number | undefined;
};
/** @internal */
export declare const Upload$outboundSchema: z.ZodType<Upload$Outbound, z.ZodTypeDef, Upload>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace Upload$ {
    /** @deprecated use `Upload$inboundSchema` instead. */
    const inboundSchema: z.ZodType<Upload, z.ZodTypeDef, unknown>;
    /** @deprecated use `Upload$outboundSchema` instead. */
    const outboundSchema: z.ZodType<Upload$Outbound, z.ZodTypeDef, Upload>;
    /** @deprecated use `Upload$Outbound` instead. */
    type Outbound = Upload$Outbound;
}
export declare function uploadToJSON(upload: Upload): string;
export declare function uploadFromJSON(jsonString: string): SafeParseResult<Upload, SDKValidationError>;
/** @internal */
export declare const Content$inboundSchema: z.ZodType<Content, z.ZodTypeDef, unknown>;
/** @internal */
export type Content$Outbound = {};
/** @internal */
export declare const Content$outboundSchema: z.ZodType<Content$Outbound, z.ZodTypeDef, Content>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace Content$ {
    /** @deprecated use `Content$inboundSchema` instead. */
    const inboundSchema: z.ZodType<Content, z.ZodTypeDef, unknown>;
    /** @deprecated use `Content$outboundSchema` instead. */
    const outboundSchema: z.ZodType<Content$Outbound, z.ZodTypeDef, Content>;
    /** @deprecated use `Content$Outbound` instead. */
    type Outbound = Content$Outbound;
}
export declare function contentToJSON(content: Content): string;
export declare function contentFromJSON(jsonString: string): SafeParseResult<Content, SDKValidationError>;
/** @internal */
export declare const TaskExportData$inboundSchema: z.ZodType<TaskExportData, z.ZodTypeDef, unknown>;
/** @internal */
export type TaskExportData$Outbound = {
    content: Content$Outbound;
    ipfs?: IpfsExportParams$Outbound | undefined;
    type?: string | undefined;
    id?: string | undefined;
};
/** @internal */
export declare const TaskExportData$outboundSchema: z.ZodType<TaskExportData$Outbound, z.ZodTypeDef, TaskExportData>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace TaskExportData$ {
    /** @deprecated use `TaskExportData$inboundSchema` instead. */
    const inboundSchema: z.ZodType<TaskExportData, z.ZodTypeDef, unknown>;
    /** @deprecated use `TaskExportData$outboundSchema` instead. */
    const outboundSchema: z.ZodType<TaskExportData$Outbound, z.ZodTypeDef, TaskExportData>;
    /** @deprecated use `TaskExportData$Outbound` instead. */
    type Outbound = TaskExportData$Outbound;
}
export declare function taskExportDataToJSON(taskExportData: TaskExportData): string;
export declare function taskExportDataFromJSON(jsonString: string): SafeParseResult<TaskExportData, SDKValidationError>;
/** @internal */
export declare const TaskInput$inboundSchema: z.ZodType<TaskInput, z.ZodTypeDef, unknown>;
/** @internal */
export type TaskInput$Outbound = {
    url?: string | undefined;
};
/** @internal */
export declare const TaskInput$outboundSchema: z.ZodType<TaskInput$Outbound, z.ZodTypeDef, TaskInput>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace TaskInput$ {
    /** @deprecated use `TaskInput$inboundSchema` instead. */
    const inboundSchema: z.ZodType<TaskInput, z.ZodTypeDef, unknown>;
    /** @deprecated use `TaskInput$outboundSchema` instead. */
    const outboundSchema: z.ZodType<TaskInput$Outbound, z.ZodTypeDef, TaskInput>;
    /** @deprecated use `TaskInput$Outbound` instead. */
    type Outbound = TaskInput$Outbound;
}
export declare function taskInputToJSON(taskInput: TaskInput): string;
export declare function taskInputFromJSON(jsonString: string): SafeParseResult<TaskInput, SDKValidationError>;
/** @internal */
export declare const TaskStorage$inboundSchema: z.ZodType<TaskStorage, z.ZodTypeDef, unknown>;
/** @internal */
export type TaskStorage$Outbound = {
    url?: string | undefined;
};
/** @internal */
export declare const TaskStorage$outboundSchema: z.ZodType<TaskStorage$Outbound, z.ZodTypeDef, TaskStorage>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace TaskStorage$ {
    /** @deprecated use `TaskStorage$inboundSchema` instead. */
    const inboundSchema: z.ZodType<TaskStorage, z.ZodTypeDef, unknown>;
    /** @deprecated use `TaskStorage$outboundSchema` instead. */
    const outboundSchema: z.ZodType<TaskStorage$Outbound, z.ZodTypeDef, TaskStorage>;
    /** @deprecated use `TaskStorage$Outbound` instead. */
    type Outbound = TaskStorage$Outbound;
}
export declare function taskStorageToJSON(taskStorage: TaskStorage): string;
export declare function taskStorageFromJSON(jsonString: string): SafeParseResult<TaskStorage, SDKValidationError>;
/** @internal */
export declare const TaskHls$inboundSchema: z.ZodType<TaskHls, z.ZodTypeDef, unknown>;
/** @internal */
export type TaskHls$Outbound = {
    path?: string | undefined;
};
/** @internal */
export declare const TaskHls$outboundSchema: z.ZodType<TaskHls$Outbound, z.ZodTypeDef, TaskHls>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace TaskHls$ {
    /** @deprecated use `TaskHls$inboundSchema` instead. */
    const inboundSchema: z.ZodType<TaskHls, z.ZodTypeDef, unknown>;
    /** @deprecated use `TaskHls$outboundSchema` instead. */
    const outboundSchema: z.ZodType<TaskHls$Outbound, z.ZodTypeDef, TaskHls>;
    /** @deprecated use `TaskHls$Outbound` instead. */
    type Outbound = TaskHls$Outbound;
}
export declare function taskHlsToJSON(taskHls: TaskHls): string;
export declare function taskHlsFromJSON(jsonString: string): SafeParseResult<TaskHls, SDKValidationError>;
/** @internal */
export declare const TaskMp4$inboundSchema: z.ZodType<TaskMp4, z.ZodTypeDef, unknown>;
/** @internal */
export type TaskMp4$Outbound = {
    path?: string | undefined;
};
/** @internal */
export declare const TaskMp4$outboundSchema: z.ZodType<TaskMp4$Outbound, z.ZodTypeDef, TaskMp4>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace TaskMp4$ {
    /** @deprecated use `TaskMp4$inboundSchema` instead. */
    const inboundSchema: z.ZodType<TaskMp4, z.ZodTypeDef, unknown>;
    /** @deprecated use `TaskMp4$outboundSchema` instead. */
    const outboundSchema: z.ZodType<TaskMp4$Outbound, z.ZodTypeDef, TaskMp4>;
    /** @deprecated use `TaskMp4$Outbound` instead. */
    type Outbound = TaskMp4$Outbound;
}
export declare function taskMp4ToJSON(taskMp4: TaskMp4): string;
export declare function taskMp4FromJSON(jsonString: string): SafeParseResult<TaskMp4, SDKValidationError>;
/** @internal */
export declare const TaskOutputs$inboundSchema: z.ZodType<TaskOutputs, z.ZodTypeDef, unknown>;
/** @internal */
export type TaskOutputs$Outbound = {
    hls?: TaskHls$Outbound | undefined;
    mp4?: TaskMp4$Outbound | undefined;
};
/** @internal */
export declare const TaskOutputs$outboundSchema: z.ZodType<TaskOutputs$Outbound, z.ZodTypeDef, TaskOutputs>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace TaskOutputs$ {
    /** @deprecated use `TaskOutputs$inboundSchema` instead. */
    const inboundSchema: z.ZodType<TaskOutputs, z.ZodTypeDef, unknown>;
    /** @deprecated use `TaskOutputs$outboundSchema` instead. */
    const outboundSchema: z.ZodType<TaskOutputs$Outbound, z.ZodTypeDef, TaskOutputs>;
    /** @deprecated use `TaskOutputs$Outbound` instead. */
    type Outbound = TaskOutputs$Outbound;
}
export declare function taskOutputsToJSON(taskOutputs: TaskOutputs): string;
export declare function taskOutputsFromJSON(jsonString: string): SafeParseResult<TaskOutputs, SDKValidationError>;
/** @internal */
export declare const TranscodeFile$inboundSchema: z.ZodType<TranscodeFile, z.ZodTypeDef, unknown>;
/** @internal */
export type TranscodeFile$Outbound = {
    input?: TaskInput$Outbound | undefined;
    storage?: TaskStorage$Outbound | undefined;
    outputs?: TaskOutputs$Outbound | undefined;
    profiles?: Array<TranscodeProfile$Outbound> | undefined;
    targetSegmentSizeSecs?: number | undefined;
    creatorId?: InputCreatorId$Outbound | undefined;
    c2pa?: boolean | undefined;
};
/** @internal */
export declare const TranscodeFile$outboundSchema: z.ZodType<TranscodeFile$Outbound, z.ZodTypeDef, TranscodeFile>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace TranscodeFile$ {
    /** @deprecated use `TranscodeFile$inboundSchema` instead. */
    const inboundSchema: z.ZodType<TranscodeFile, z.ZodTypeDef, unknown>;
    /** @deprecated use `TranscodeFile$outboundSchema` instead. */
    const outboundSchema: z.ZodType<TranscodeFile$Outbound, z.ZodTypeDef, TranscodeFile>;
    /** @deprecated use `TranscodeFile$Outbound` instead. */
    type Outbound = TranscodeFile$Outbound;
}
export declare function transcodeFileToJSON(transcodeFile: TranscodeFile): string;
export declare function transcodeFileFromJSON(jsonString: string): SafeParseResult<TranscodeFile, SDKValidationError>;
/** @internal */
export declare const ClipStrategy$inboundSchema: z.ZodType<ClipStrategy, z.ZodTypeDef, unknown>;
/** @internal */
export type ClipStrategy$Outbound = {
    startTime?: number | undefined;
    endTime?: number | undefined;
    playbackId?: string | undefined;
};
/** @internal */
export declare const ClipStrategy$outboundSchema: z.ZodType<ClipStrategy$Outbound, z.ZodTypeDef, ClipStrategy>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace ClipStrategy$ {
    /** @deprecated use `ClipStrategy$inboundSchema` instead. */
    const inboundSchema: z.ZodType<ClipStrategy, z.ZodTypeDef, unknown>;
    /** @deprecated use `ClipStrategy$outboundSchema` instead. */
    const outboundSchema: z.ZodType<ClipStrategy$Outbound, z.ZodTypeDef, ClipStrategy>;
    /** @deprecated use `ClipStrategy$Outbound` instead. */
    type Outbound = ClipStrategy$Outbound;
}
export declare function clipStrategyToJSON(clipStrategy: ClipStrategy): string;
export declare function clipStrategyFromJSON(jsonString: string): SafeParseResult<ClipStrategy, SDKValidationError>;
/** @internal */
export declare const CatalystPipelineStrategy$inboundSchema: z.ZodNativeEnum<typeof CatalystPipelineStrategy>;
/** @internal */
export declare const CatalystPipelineStrategy$outboundSchema: z.ZodNativeEnum<typeof CatalystPipelineStrategy>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace CatalystPipelineStrategy$ {
    /** @deprecated use `CatalystPipelineStrategy$inboundSchema` instead. */
    const inboundSchema: z.ZodNativeEnum<typeof CatalystPipelineStrategy>;
    /** @deprecated use `CatalystPipelineStrategy$outboundSchema` instead. */
    const outboundSchema: z.ZodNativeEnum<typeof CatalystPipelineStrategy>;
}
/** @internal */
export declare const Clip$inboundSchema: z.ZodType<Clip, z.ZodTypeDef, unknown>;
/** @internal */
export type Clip$Outbound = {
    url?: string | undefined;
    clipStrategy?: ClipStrategy$Outbound | undefined;
    catalystPipelineStrategy?: string | undefined;
    sessionId?: string | undefined;
    inputId?: string | undefined;
};
/** @internal */
export declare const Clip$outboundSchema: z.ZodType<Clip$Outbound, z.ZodTypeDef, Clip>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace Clip$ {
    /** @deprecated use `Clip$inboundSchema` instead. */
    const inboundSchema: z.ZodType<Clip, z.ZodTypeDef, unknown>;
    /** @deprecated use `Clip$outboundSchema` instead. */
    const outboundSchema: z.ZodType<Clip$Outbound, z.ZodTypeDef, Clip>;
    /** @deprecated use `Clip$Outbound` instead. */
    type Outbound = Clip$Outbound;
}
export declare function clipToJSON(clip: Clip): string;
export declare function clipFromJSON(jsonString: string): SafeParseResult<Clip, SDKValidationError>;
/** @internal */
export declare const Params$inboundSchema: z.ZodType<Params, z.ZodTypeDef, unknown>;
/** @internal */
export type Params$Outbound = {
    upload?: Upload$Outbound | undefined;
    export?: ExportTaskParams$Outbound | undefined;
    exportData?: TaskExportData$Outbound | undefined;
    "transcode-file"?: TranscodeFile$Outbound | undefined;
    clip?: Clip$Outbound | undefined;
};
/** @internal */
export declare const Params$outboundSchema: z.ZodType<Params$Outbound, z.ZodTypeDef, Params>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace Params$ {
    /** @deprecated use `Params$inboundSchema` instead. */
    const inboundSchema: z.ZodType<Params, z.ZodTypeDef, unknown>;
    /** @deprecated use `Params$outboundSchema` instead. */
    const outboundSchema: z.ZodType<Params$Outbound, z.ZodTypeDef, Params>;
    /** @deprecated use `Params$Outbound` instead. */
    type Outbound = Params$Outbound;
}
export declare function paramsToJSON(params: Params): string;
export declare function paramsFromJSON(jsonString: string): SafeParseResult<Params, SDKValidationError>;
/** @internal */
export declare const TaskPhase$inboundSchema: z.ZodNativeEnum<typeof TaskPhase>;
/** @internal */
export declare const TaskPhase$outboundSchema: z.ZodNativeEnum<typeof TaskPhase>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace TaskPhase$ {
    /** @deprecated use `TaskPhase$inboundSchema` instead. */
    const inboundSchema: z.ZodNativeEnum<typeof TaskPhase>;
    /** @deprecated use `TaskPhase$outboundSchema` instead. */
    const outboundSchema: z.ZodNativeEnum<typeof TaskPhase>;
}
/** @internal */
export declare const TaskStatus$inboundSchema: z.ZodType<TaskStatus, z.ZodTypeDef, unknown>;
/** @internal */
export type TaskStatus$Outbound = {
    phase: string;
    updatedAt: number;
    progress?: number | undefined;
    errorMessage?: string | undefined;
    retries?: number | undefined;
};
/** @internal */
export declare const TaskStatus$outboundSchema: z.ZodType<TaskStatus$Outbound, z.ZodTypeDef, TaskStatus>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace TaskStatus$ {
    /** @deprecated use `TaskStatus$inboundSchema` instead. */
    const inboundSchema: z.ZodType<TaskStatus, z.ZodTypeDef, unknown>;
    /** @deprecated use `TaskStatus$outboundSchema` instead. */
    const outboundSchema: z.ZodType<TaskStatus$Outbound, z.ZodTypeDef, TaskStatus>;
    /** @deprecated use `TaskStatus$Outbound` instead. */
    type Outbound = TaskStatus$Outbound;
}
export declare function taskStatusToJSON(taskStatus: TaskStatus): string;
export declare function taskStatusFromJSON(jsonString: string): SafeParseResult<TaskStatus, SDKValidationError>;
/** @internal */
export declare const TaskUpload$inboundSchema: z.ZodType<TaskUpload, z.ZodTypeDef, unknown>;
/** @internal */
export type TaskUpload$Outbound = {
    assetSpec?: Asset$Outbound | undefined;
    [additionalProperties: string]: unknown;
};
/** @internal */
export declare const TaskUpload$outboundSchema: z.ZodType<TaskUpload$Outbound, z.ZodTypeDef, TaskUpload>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace TaskUpload$ {
    /** @deprecated use `TaskUpload$inboundSchema` instead. */
    const inboundSchema: z.ZodType<TaskUpload, z.ZodTypeDef, unknown>;
    /** @deprecated use `TaskUpload$outboundSchema` instead. */
    const outboundSchema: z.ZodType<TaskUpload$Outbound, z.ZodTypeDef, TaskUpload>;
    /** @deprecated use `TaskUpload$Outbound` instead. */
    type Outbound = TaskUpload$Outbound;
}
export declare function taskUploadToJSON(taskUpload: TaskUpload): string;
export declare function taskUploadFromJSON(jsonString: string): SafeParseResult<TaskUpload, SDKValidationError>;
/** @internal */
export declare const TaskIpfs$inboundSchema: z.ZodType<TaskIpfs, z.ZodTypeDef, unknown>;
/** @internal */
export type TaskIpfs$Outbound = {
    videoFileCid: string;
    videoFileUrl?: string | undefined;
    videoFileGatewayUrl?: string | undefined;
    nftMetadataCid?: string | undefined;
    nftMetadataUrl?: string | undefined;
    nftMetadataGatewayUrl?: string | undefined;
};
/** @internal */
export declare const TaskIpfs$outboundSchema: z.ZodType<TaskIpfs$Outbound, z.ZodTypeDef, TaskIpfs>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace TaskIpfs$ {
    /** @deprecated use `TaskIpfs$inboundSchema` instead. */
    const inboundSchema: z.ZodType<TaskIpfs, z.ZodTypeDef, unknown>;
    /** @deprecated use `TaskIpfs$outboundSchema` instead. */
    const outboundSchema: z.ZodType<TaskIpfs$Outbound, z.ZodTypeDef, TaskIpfs>;
    /** @deprecated use `TaskIpfs$Outbound` instead. */
    type Outbound = TaskIpfs$Outbound;
}
export declare function taskIpfsToJSON(taskIpfs: TaskIpfs): string;
export declare function taskIpfsFromJSON(jsonString: string): SafeParseResult<TaskIpfs, SDKValidationError>;
/** @internal */
export declare const Export$inboundSchema: z.ZodType<Export, z.ZodTypeDef, unknown>;
/** @internal */
export type Export$Outbound = {
    ipfs?: TaskIpfs$Outbound | undefined;
};
/** @internal */
export declare const Export$outboundSchema: z.ZodType<Export$Outbound, z.ZodTypeDef, Export>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace Export$ {
    /** @deprecated use `Export$inboundSchema` instead. */
    const inboundSchema: z.ZodType<Export, z.ZodTypeDef, unknown>;
    /** @deprecated use `Export$outboundSchema` instead. */
    const outboundSchema: z.ZodType<Export$Outbound, z.ZodTypeDef, Export>;
    /** @deprecated use `Export$Outbound` instead. */
    type Outbound = Export$Outbound;
}
export declare function exportToJSON(value: Export): string;
export declare function exportFromJSON(jsonString: string): SafeParseResult<Export, SDKValidationError>;
/** @internal */
export declare const TaskSchemasIpfs$inboundSchema: z.ZodType<TaskSchemasIpfs, z.ZodTypeDef, unknown>;
/** @internal */
export type TaskSchemasIpfs$Outbound = {
    cid: string;
};
/** @internal */
export declare const TaskSchemasIpfs$outboundSchema: z.ZodType<TaskSchemasIpfs$Outbound, z.ZodTypeDef, TaskSchemasIpfs>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace TaskSchemasIpfs$ {
    /** @deprecated use `TaskSchemasIpfs$inboundSchema` instead. */
    const inboundSchema: z.ZodType<TaskSchemasIpfs, z.ZodTypeDef, unknown>;
    /** @deprecated use `TaskSchemasIpfs$outboundSchema` instead. */
    const outboundSchema: z.ZodType<TaskSchemasIpfs$Outbound, z.ZodTypeDef, TaskSchemasIpfs>;
    /** @deprecated use `TaskSchemasIpfs$Outbound` instead. */
    type Outbound = TaskSchemasIpfs$Outbound;
}
export declare function taskSchemasIpfsToJSON(taskSchemasIpfs: TaskSchemasIpfs): string;
export declare function taskSchemasIpfsFromJSON(jsonString: string): SafeParseResult<TaskSchemasIpfs, SDKValidationError>;
/** @internal */
export declare const ExportData$inboundSchema: z.ZodType<ExportData, z.ZodTypeDef, unknown>;
/** @internal */
export type ExportData$Outbound = {
    ipfs?: TaskSchemasIpfs$Outbound | undefined;
};
/** @internal */
export declare const ExportData$outboundSchema: z.ZodType<ExportData$Outbound, z.ZodTypeDef, ExportData>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace ExportData$ {
    /** @deprecated use `ExportData$inboundSchema` instead. */
    const inboundSchema: z.ZodType<ExportData, z.ZodTypeDef, unknown>;
    /** @deprecated use `ExportData$outboundSchema` instead. */
    const outboundSchema: z.ZodType<ExportData$Outbound, z.ZodTypeDef, ExportData>;
    /** @deprecated use `ExportData$Outbound` instead. */
    type Outbound = ExportData$Outbound;
}
export declare function exportDataToJSON(exportData: ExportData): string;
export declare function exportDataFromJSON(jsonString: string): SafeParseResult<ExportData, SDKValidationError>;
/** @internal */
export declare const Output$inboundSchema: z.ZodType<Output, z.ZodTypeDef, unknown>;
/** @internal */
export type Output$Outbound = {
    upload?: TaskUpload$Outbound | undefined;
    export?: Export$Outbound | undefined;
    exportData?: ExportData$Outbound | undefined;
};
/** @internal */
export declare const Output$outboundSchema: z.ZodType<Output$Outbound, z.ZodTypeDef, Output>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace Output$ {
    /** @deprecated use `Output$inboundSchema` instead. */
    const inboundSchema: z.ZodType<Output, z.ZodTypeDef, unknown>;
    /** @deprecated use `Output$outboundSchema` instead. */
    const outboundSchema: z.ZodType<Output$Outbound, z.ZodTypeDef, Output>;
    /** @deprecated use `Output$Outbound` instead. */
    type Outbound = Output$Outbound;
}
export declare function outputToJSON(output: Output): string;
export declare function outputFromJSON(jsonString: string): SafeParseResult<Output, SDKValidationError>;
/** @internal */
export declare const Task$inboundSchema: z.ZodType<Task, z.ZodTypeDef, unknown>;
/** @internal */
export type Task$Outbound = {
    id?: string | undefined;
    type?: string | undefined;
    createdAt?: number | undefined;
    scheduledAt?: number | undefined;
    inputAssetId?: string | undefined;
    outputAssetId?: string | undefined;
    projectId?: string | undefined;
    requesterId?: string | undefined;
    params?: Params$Outbound | undefined;
    status?: TaskStatus$Outbound | undefined;
    output?: Output$Outbound | undefined;
};
/** @internal */
export declare const Task$outboundSchema: z.ZodType<Task$Outbound, z.ZodTypeDef, Task>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace Task$ {
    /** @deprecated use `Task$inboundSchema` instead. */
    const inboundSchema: z.ZodType<Task, z.ZodTypeDef, unknown>;
    /** @deprecated use `Task$outboundSchema` instead. */
    const outboundSchema: z.ZodType<Task$Outbound, z.ZodTypeDef, Task>;
    /** @deprecated use `Task$Outbound` instead. */
    type Outbound = Task$Outbound;
}
export declare function taskToJSON(task: Task): string;
export declare function taskFromJSON(jsonString: string): SafeParseResult<Task, SDKValidationError>;
//# sourceMappingURL=task.d.ts.map