/**
 * Cloudflare STREAM API
 *
 * Generated from Cloudflare TypeScript SDK.
 * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service stream
 */
import * as Schema from "effect/Schema";
import type * as HttpClient from "effect/unstable/http/HttpClient";
import * as API from "../client/api.ts";
import type { Credentials } from "../credentials.ts";
import { type DefaultErrors } from "../errors.ts";
export interface GetAudioTrackRequest {
    identifier: string;
    /** The account identifier tag. */
    accountId: string;
}
export declare const GetAudioTrackRequest: Schema.Schema<GetAudioTrackRequest>;
export interface GetAudioTrackResponse {
    result: {
        default?: boolean | null;
        label?: string | null;
        status?: "queued" | "ready" | "error" | null;
        uid?: string | null;
    }[];
}
export declare const GetAudioTrackResponse: Schema.Schema<GetAudioTrackResponse>;
export type GetAudioTrackError = DefaultErrors;
export declare const getAudioTrack: API.PaginatedOperationMethod<GetAudioTrackRequest, GetAudioTrackResponse, GetAudioTrackError, Credentials | HttpClient.HttpClient>;
export interface PatchAudioTrackRequest {
    identifier: string;
    audioIdentifier: string;
    /** Path param: The account identifier tag. */
    accountId: string;
    /** Body param: Denotes whether the audio track will be played by default in a player. */
    default?: boolean;
    /** Body param: A string to uniquely identify the track amongst other audio track labels for the specified video. */
    label?: string;
}
export declare const PatchAudioTrackRequest: Schema.Schema<PatchAudioTrackRequest>;
export interface PatchAudioTrackResponse {
    /** Denotes whether the audio track will be played by default in a player. */
    default?: boolean | null;
    /** A string to uniquely identify the track amongst other audio track labels for the specified video. */
    label?: string | null;
    /** Specifies the processing status of the video. */
    status?: "queued" | "ready" | "error" | null;
    /** A Cloudflare-generated unique identifier for a media item. */
    uid?: string | null;
}
export declare const PatchAudioTrackResponse: Schema.Schema<PatchAudioTrackResponse>;
export type PatchAudioTrackError = DefaultErrors;
export declare const patchAudioTrack: API.OperationMethod<PatchAudioTrackRequest, PatchAudioTrackResponse, PatchAudioTrackError, Credentials | HttpClient.HttpClient>;
export interface DeleteAudioTrackRequest {
    identifier: string;
    audioIdentifier: string;
    /** The account identifier tag. */
    accountId: string;
}
export declare const DeleteAudioTrackRequest: Schema.Schema<DeleteAudioTrackRequest>;
export type DeleteAudioTrackResponse = string;
export declare const DeleteAudioTrackResponse: Schema.Schema<DeleteAudioTrackResponse>;
export type DeleteAudioTrackError = DefaultErrors;
export declare const deleteAudioTrack: API.OperationMethod<DeleteAudioTrackRequest, DeleteAudioTrackResponse, DeleteAudioTrackError, Credentials | HttpClient.HttpClient>;
export interface CopyAudioTrackRequest {
    identifier: string;
    /** Path param: The account identifier tag. */
    accountId: string;
    /** Body param: A string to uniquely identify the track amongst other audio track labels for the specified video. */
    label: string;
    /** Body param: An audio track URL. The server must be publicly routable and support `HTTP HEAD` requests and `HTTP GET` range requests. The server should respond to `HTTP HEAD` requests with a `content-r */
    url?: string;
}
export declare const CopyAudioTrackRequest: Schema.Schema<CopyAudioTrackRequest>;
export interface CopyAudioTrackResponse {
    /** Denotes whether the audio track will be played by default in a player. */
    default?: boolean | null;
    /** A string to uniquely identify the track amongst other audio track labels for the specified video. */
    label?: string | null;
    /** Specifies the processing status of the video. */
    status?: "queued" | "ready" | "error" | null;
    /** A Cloudflare-generated unique identifier for a media item. */
    uid?: string | null;
}
export declare const CopyAudioTrackResponse: Schema.Schema<CopyAudioTrackResponse>;
export type CopyAudioTrackError = DefaultErrors;
export declare const copyAudioTrack: API.OperationMethod<CopyAudioTrackRequest, CopyAudioTrackResponse, CopyAudioTrackError, Credentials | HttpClient.HttpClient>;
export interface GetCaptionRequest {
    identifier: string;
    /** Identifier. */
    accountId: string;
}
export declare const GetCaptionRequest: Schema.Schema<GetCaptionRequest>;
export interface GetCaptionResponse {
    result: {
        generated?: boolean | null;
        label?: string | null;
        language?: string | null;
        status?: "ready" | "inprogress" | "error" | null;
    }[];
}
export declare const GetCaptionResponse: Schema.Schema<GetCaptionResponse>;
export type GetCaptionError = DefaultErrors;
export declare const getCaption: API.PaginatedOperationMethod<GetCaptionRequest, GetCaptionResponse, GetCaptionError, Credentials | HttpClient.HttpClient>;
export interface GetCaptionLanguageRequest {
    identifier: string;
    language: string;
    /** Identifier. */
    accountId: string;
}
export declare const GetCaptionLanguageRequest: Schema.Schema<GetCaptionLanguageRequest>;
export interface GetCaptionLanguageResponse {
    /** Whether the caption was generated via AI. */
    generated?: boolean | null;
    /** The language label displayed in the native language to users. */
    label?: string | null;
    /** The language tag in BCP 47 format. */
    language?: string | null;
    /** The status of a generated caption. */
    status?: "ready" | "inprogress" | "error" | null;
}
export declare const GetCaptionLanguageResponse: Schema.Schema<GetCaptionLanguageResponse>;
export type GetCaptionLanguageError = DefaultErrors;
export declare const getCaptionLanguage: API.OperationMethod<GetCaptionLanguageRequest, GetCaptionLanguageResponse, GetCaptionLanguageError, Credentials | HttpClient.HttpClient>;
export interface CreateCaptionLanguageRequest {
    identifier: string;
    language: string;
    /** Identifier. */
    accountId: string;
}
export declare const CreateCaptionLanguageRequest: Schema.Schema<CreateCaptionLanguageRequest>;
export interface CreateCaptionLanguageResponse {
    /** Whether the caption was generated via AI. */
    generated?: boolean | null;
    /** The language label displayed in the native language to users. */
    label?: string | null;
    /** The language tag in BCP 47 format. */
    language?: string | null;
    /** The status of a generated caption. */
    status?: "ready" | "inprogress" | "error" | null;
}
export declare const CreateCaptionLanguageResponse: Schema.Schema<CreateCaptionLanguageResponse>;
export type CreateCaptionLanguageError = DefaultErrors;
export declare const createCaptionLanguage: API.OperationMethod<CreateCaptionLanguageRequest, CreateCaptionLanguageResponse, CreateCaptionLanguageError, Credentials | HttpClient.HttpClient>;
export interface UpdateCaptionLanguageRequest {
    identifier: string;
    language: string;
    /** Path param: Identifier. */
    accountId: string;
    /** Body param: The WebVTT file containing the caption or subtitle content. */
    file: string;
}
export declare const UpdateCaptionLanguageRequest: Schema.Schema<UpdateCaptionLanguageRequest>;
export interface UpdateCaptionLanguageResponse {
    /** Whether the caption was generated via AI. */
    generated?: boolean | null;
    /** The language label displayed in the native language to users. */
    label?: string | null;
    /** The language tag in BCP 47 format. */
    language?: string | null;
    /** The status of a generated caption. */
    status?: "ready" | "inprogress" | "error" | null;
}
export declare const UpdateCaptionLanguageResponse: Schema.Schema<UpdateCaptionLanguageResponse>;
export type UpdateCaptionLanguageError = DefaultErrors;
export declare const updateCaptionLanguage: API.OperationMethod<UpdateCaptionLanguageRequest, UpdateCaptionLanguageResponse, UpdateCaptionLanguageError, Credentials | HttpClient.HttpClient>;
export interface DeleteCaptionLanguageRequest {
    identifier: string;
    language: string;
    /** Identifier. */
    accountId: string;
}
export declare const DeleteCaptionLanguageRequest: Schema.Schema<DeleteCaptionLanguageRequest>;
export type DeleteCaptionLanguageResponse = string;
export declare const DeleteCaptionLanguageResponse: Schema.Schema<DeleteCaptionLanguageResponse>;
export type DeleteCaptionLanguageError = DefaultErrors;
export declare const deleteCaptionLanguage: API.OperationMethod<DeleteCaptionLanguageRequest, DeleteCaptionLanguageResponse, DeleteCaptionLanguageError, Credentials | HttpClient.HttpClient>;
export interface GetCaptionLanguageVttRequest {
    identifier: string;
    language: string;
    /** Identifier. */
    accountId: string;
}
export declare const GetCaptionLanguageVttRequest: Schema.Schema<GetCaptionLanguageVttRequest>;
export type GetCaptionLanguageVttResponse = string;
export declare const GetCaptionLanguageVttResponse: Schema.Schema<GetCaptionLanguageVttResponse>;
export type GetCaptionLanguageVttError = DefaultErrors;
export declare const getCaptionLanguageVtt: API.OperationMethod<GetCaptionLanguageVttRequest, GetCaptionLanguageVttResponse, GetCaptionLanguageVttError, Credentials | HttpClient.HttpClient>;
export interface CreateClipRequest {
    /** Path param: The account identifier tag. */
    accountId: string;
    /** Body param: The unique video identifier (UID). */
    clippedFromVideoUID: string;
    /** Body param: Specifies the end time for the video clip in seconds. */
    endTimeSeconds: number;
    /** Body param: Specifies the start time for the video clip in seconds. */
    startTimeSeconds: number;
    /** Body param: Lists the origins allowed to display the video. Enter allowed origin domains in an array and use ` ` for wildcard subdomains. Empty arrays allow the video to be viewed on any origin. */
    allowedOrigins?: string[];
    /** Body param: A user-defined identifier for the media creator. */
    creator?: string;
    /** Body param: The maximum duration in seconds for a video upload. Can be set for a video that is not yet uploaded to limit its duration. Uploads that exceed the specified duration will fail during proce */
    maxDurationSeconds?: number;
    /** Body param: Indicates whether the video can be a accessed using the UID. When set to `true`, a signed token must be generated with a signing key to view the video. */
    requireSignedURLs?: boolean;
    /** Body param: The timestamp for a thumbnail image calculated as a percentage value of the video's duration. To convert from a second-wise timestamp to a percentage, divide the desired timestamp by the t */
    thumbnailTimestampPct?: number;
    /** Body param: */
    watermark?: {
        uid?: string;
    };
}
export declare const CreateClipRequest: Schema.Schema<CreateClipRequest>;
export interface CreateClipResponse {
    /** Lists the origins allowed to display the video. Enter allowed origin domains in an array and use ` ` for wildcard subdomains. Empty arrays allow the video to be viewed on any origin. */
    allowedOrigins?: string[] | null;
    /** The unique video identifier (UID). */
    clippedFromVideoUID?: string | null;
    /** The date and time the clip was created. */
    created?: string | null;
    /** A user-defined identifier for the media creator. */
    creator?: string | null;
    /** Specifies the end time for the video clip in seconds. */
    endTimeSeconds?: number | null;
    /** The maximum duration in seconds for a video upload. Can be set for a video that is not yet uploaded to limit its duration. Uploads that exceed the specified duration will fail during processing. A val */
    maxDurationSeconds?: number | null;
    /** A user modifiable key-value store used to reference other systems of record for managing videos. */
    meta?: unknown | null;
    /** The date and time the live input was last modified. */
    modified?: string | null;
    playback?: {
        dash?: string | null;
        hls?: string | null;
    } | null;
    /** The video's preview page URI. This field is omitted until encoding is complete. */
    preview?: string | null;
    /** Indicates whether the video can be a accessed using the UID. When set to `true`, a signed token must be generated with a signing key to view the video. */
    requireSignedURLs?: boolean | null;
    /** Specifies the start time for the video clip in seconds. */
    startTimeSeconds?: number | null;
    /** Specifies the processing status for all quality levels for a video. */
    status?: "pendingupload" | "downloading" | "queued" | "inprogress" | "ready" | "error" | "live-inprogress" | null;
    /** The timestamp for a thumbnail image calculated as a percentage value of the video's duration. To convert from a second-wise timestamp to a percentage, divide the desired timestamp by the total duratio */
    thumbnailTimestampPct?: number | null;
    watermark?: {
        uid?: string | null;
    } | null;
}
export declare const CreateClipResponse: Schema.Schema<CreateClipResponse>;
export type CreateClipError = DefaultErrors;
export declare const createClip: API.OperationMethod<CreateClipRequest, CreateClipResponse, CreateClipError, Credentials | HttpClient.HttpClient>;
export interface CreateCopyRequest {
    /** Path param: The account identifier tag. */
    accountId: string;
    /** Header param: A user-defined identifier for the media creator. */
    uploadCreator?: string;
    /** Body param: A video's URL. The server must be publicly routable and support `HTTP HEAD` requests and `HTTP GET` range requests. The server should respond to `HTTP HEAD` requests with a `content-range` */
    url: string;
    /** Body param: Lists the origins allowed to display the video. Enter allowed origin domains in an array and use ` ` for wildcard subdomains. Empty arrays allow the video to be viewed on any origin. */
    allowedOrigins?: string[];
    /** Body param: A user-defined identifier for the media creator. */
    creator?: string;
    /** Body param: A user modifiable key-value store used to reference other systems of record for managing videos. */
    meta?: unknown;
    /** Body param: Indicates whether the video can be a accessed using the UID. When set to `true`, a signed token must be generated with a signing key to view the video. */
    requireSignedURLs?: boolean;
    /** Body param: Indicates the date and time at which the video will be deleted. Omit the field to indicate no change, or include with a `null` value to remove an existing scheduled deletion. If specified, */
    scheduledDeletion?: string;
    /** Body param: The timestamp for a thumbnail image calculated as a percentage value of the video's duration. To convert from a second-wise timestamp to a percentage, divide the desired timestamp by the t */
    thumbnailTimestampPct?: number;
    /** Body param: */
    watermark?: {
        uid?: string;
    };
}
export declare const CreateCopyRequest: Schema.Schema<CreateCopyRequest>;
export interface CreateCopyResponse {
    /** Lists the origins allowed to display the video. Enter allowed origin domains in an array and use ` ` for wildcard subdomains. Empty arrays allow the video to be viewed on any origin. */
    allowedOrigins?: string[] | null;
    /** The date and time the media item was created. */
    created?: string | null;
    /** A user-defined identifier for the media creator. */
    creator?: string | null;
    /** The duration of the video in seconds. A value of `-1` means the duration is unknown. The duration becomes available after the upload and before the video is ready. */
    duration?: number | null;
    input?: {
        height?: number | null;
        width?: number | null;
    } | null;
    /** The live input ID used to upload a video with Stream Live. */
    liveInput?: string | null;
    /** The maximum duration in seconds for a video upload. Can be set for a video that is not yet uploaded to limit its duration. Uploads that exceed the specified duration will fail during processing. A val */
    maxDurationSeconds?: number | null;
    /** A user modifiable key-value store used to reference other systems of record for managing videos. */
    meta?: unknown | null;
    /** The date and time the media item was last modified. */
    modified?: string | null;
    playback?: {
        dash?: string | null;
        hls?: string | null;
    } | null;
    /** The video's preview page URI. This field is omitted until encoding is complete. */
    preview?: string | null;
    /** Indicates whether the video is playable. The field is empty if the video is not ready for viewing or the live stream is still in progress. */
    readyToStream?: boolean | null;
    /** Indicates the time at which the video became playable. The field is empty if the video is not ready for viewing or the live stream is still in progress. */
    readyToStreamAt?: string | null;
    /** Indicates whether the video can be a accessed using the UID. When set to `true`, a signed token must be generated with a signing key to view the video. */
    requireSignedURLs?: boolean | null;
    /** Indicates the date and time at which the video will be deleted. Omit the field to indicate no change, or include with a `null` value to remove an existing scheduled deletion. If specified, must be at  */
    scheduledDeletion?: string | null;
    /** The size of the media item in bytes. */
    size?: number | null;
    /** Specifies a detailed status for a video. If the `state` is `inprogress` or `error`, the `step` field returns `encoding` or `manifest`. If the `state` is `inprogress`, `pctComplete` returns a number be */
    status?: {
        errorReasonCode?: string | null;
        errorReasonText?: string | null;
        pctComplete?: string | null;
        state?: "pendingupload" | "downloading" | "queued" | "inprogress" | "ready" | "error" | "live-inprogress" | null;
    } | null;
    /** The media item's thumbnail URI. This field is omitted until encoding is complete. */
    thumbnail?: string | null;
    /** The timestamp for a thumbnail image calculated as a percentage value of the video's duration. To convert from a second-wise timestamp to a percentage, divide the desired timestamp by the total duratio */
    thumbnailTimestampPct?: number | null;
    /** A Cloudflare-generated unique identifier for a media item. */
    uid?: string | null;
    /** The date and time the media item was uploaded. */
    uploaded?: string | null;
    /** The date and time when the video upload URL is no longer valid for direct user uploads. */
    uploadExpiry?: string | null;
    watermark?: {
        created?: string | null;
        downloadedFrom?: string | null;
        height?: number | null;
        name?: string | null;
        opacity?: number | null;
        padding?: number | null;
        position?: string | null;
        scale?: number | null;
        size?: number | null;
        uid?: string | null;
        width?: number | null;
    } | null;
}
export declare const CreateCopyResponse: Schema.Schema<CreateCopyResponse>;
export type CreateCopyError = DefaultErrors;
export declare const createCopy: API.OperationMethod<CreateCopyRequest, CreateCopyResponse, CreateCopyError, Credentials | HttpClient.HttpClient>;
export interface CreateDirectUploadRequest {
    /** Path param: The account identifier tag. */
    accountId: string;
    /** Header param: A user-defined identifier for the media creator. */
    uploadCreator?: string;
    /** Body param: The maximum duration in seconds for a video upload. Can be set for a video that is not yet uploaded to limit its duration. Uploads that exceed the specified duration will fail during proce */
    maxDurationSeconds: number;
    /** Body param: Lists the origins allowed to display the video. Enter allowed origin domains in an array and use ` ` for wildcard subdomains. Empty arrays allow the video to be viewed on any origin. */
    allowedOrigins?: string[];
    /** Body param: A user-defined identifier for the media creator. */
    creator?: string;
    /** Body param: The date and time after upload when videos will not be accepted. */
    expiry?: string;
    /** Body param: A user modifiable key-value store used to reference other systems of record for managing videos. */
    meta?: unknown;
    /** Body param: Indicates whether the video can be a accessed using the UID. When set to `true`, a signed token must be generated with a signing key to view the video. */
    requireSignedURLs?: boolean;
    /** Body param: Indicates the date and time at which the video will be deleted. Omit the field to indicate no change, or include with a `null` value to remove an existing scheduled deletion. If specified, */
    scheduledDeletion?: string;
    /** Body param: The timestamp for a thumbnail image calculated as a percentage value of the video's duration. To convert from a second-wise timestamp to a percentage, divide the desired timestamp by the t */
    thumbnailTimestampPct?: number;
    /** Body param: */
    watermark?: {
        uid?: string;
    };
}
export declare const CreateDirectUploadRequest: Schema.Schema<CreateDirectUploadRequest>;
export interface CreateDirectUploadResponse {
    /** Indicates the date and time at which the video will be deleted. Omit the field to indicate no change, or include with a `null` value to remove an existing scheduled deletion. If specified, must be at  */
    scheduledDeletion?: string | null;
    /** A Cloudflare-generated unique identifier for a media item. */
    uid?: string | null;
    /** The URL an unauthenticated upload can use for a single `HTTP POST multipart/form-data` request. */
    uploadURL?: string | null;
    watermark?: {
        created?: string | null;
        downloadedFrom?: string | null;
        height?: number | null;
        name?: string | null;
        opacity?: number | null;
        padding?: number | null;
        position?: string | null;
        scale?: number | null;
        size?: number | null;
        uid?: string | null;
        width?: number | null;
    } | null;
}
export declare const CreateDirectUploadResponse: Schema.Schema<CreateDirectUploadResponse>;
export type CreateDirectUploadError = DefaultErrors;
export declare const createDirectUpload: API.OperationMethod<CreateDirectUploadRequest, CreateDirectUploadResponse, CreateDirectUploadError, Credentials | HttpClient.HttpClient>;
export interface GetDownloadRequest {
    identifier: string;
    /** Identifier. */
    accountId: string;
}
export declare const GetDownloadRequest: Schema.Schema<GetDownloadRequest>;
export interface GetDownloadResponse {
    /** The audio-only download. Only present if this download type has been created. */
    audio?: {
        percentComplete?: number | null;
        status?: "ready" | "inprogress" | "error" | null;
        url?: string | null;
    } | null;
    /** The default video download. Only present if this download type has been created. */
    default?: {
        percentComplete?: number | null;
        status?: "ready" | "inprogress" | "error" | null;
        url?: string | null;
    } | null;
}
export declare const GetDownloadResponse: Schema.Schema<GetDownloadResponse>;
export type GetDownloadError = DefaultErrors;
export declare const getDownload: API.OperationMethod<GetDownloadRequest, GetDownloadResponse, GetDownloadError, Credentials | HttpClient.HttpClient>;
export interface CreateDownloadRequest {
    identifier: string;
    /** Path param: Identifier. */
    accountId: string;
    /** Body param: */
    body: unknown;
}
export declare const CreateDownloadRequest: Schema.Schema<CreateDownloadRequest>;
export interface CreateDownloadResponse {
    /** Indicates the progress as a percentage between 0 and 100. */
    percentComplete?: number | null;
    /** The status of a generated download. */
    status?: "ready" | "inprogress" | "error" | null;
    /** The URL to access the generated download. */
    url?: string | null;
}
export declare const CreateDownloadResponse: Schema.Schema<CreateDownloadResponse>;
export type CreateDownloadError = DefaultErrors;
export declare const createDownload: API.OperationMethod<CreateDownloadRequest, CreateDownloadResponse, CreateDownloadError, Credentials | HttpClient.HttpClient>;
export interface DeleteDownloadRequest {
    identifier: string;
    /** Identifier. */
    accountId: string;
}
export declare const DeleteDownloadRequest: Schema.Schema<DeleteDownloadRequest>;
export type DeleteDownloadResponse = string;
export declare const DeleteDownloadResponse: Schema.Schema<DeleteDownloadResponse>;
export type DeleteDownloadError = DefaultErrors;
export declare const deleteDownload: API.OperationMethod<DeleteDownloadRequest, DeleteDownloadResponse, DeleteDownloadError, Credentials | HttpClient.HttpClient>;
export interface GetEmbedRequest {
    identifier: string;
    /** The account identifier tag. */
    accountId: string;
}
export declare const GetEmbedRequest: Schema.Schema<GetEmbedRequest>;
export type GetEmbedResponse = string;
export declare const GetEmbedResponse: Schema.Schema<GetEmbedResponse>;
export type GetEmbedError = DefaultErrors;
export declare const getEmbed: API.OperationMethod<GetEmbedRequest, GetEmbedResponse, GetEmbedError, Credentials | HttpClient.HttpClient>;
export interface GetKeyRequest {
    /** Identifier. */
    accountId: string;
}
export declare const GetKeyRequest: Schema.Schema<GetKeyRequest>;
export interface GetKeyResponse {
    result: {
        id?: string | null;
        created?: string | null;
    }[];
}
export declare const GetKeyResponse: Schema.Schema<GetKeyResponse>;
export type GetKeyError = DefaultErrors;
export declare const getKey: API.PaginatedOperationMethod<GetKeyRequest, GetKeyResponse, GetKeyError, Credentials | HttpClient.HttpClient>;
export interface CreateKeyRequest {
    /** Path param: Identifier. */
    accountId: string;
    /** Body param: */
    body: unknown;
}
export declare const CreateKeyRequest: Schema.Schema<CreateKeyRequest>;
export interface CreateKeyResponse {
    /** Identifier. */
    id?: string | null;
    /** The date and time a signing key was created. */
    created?: string | null;
    /** The signing key in JWK format. */
    jwk?: string | null;
    /** The signing key in PEM format. */
    pem?: string | null;
}
export declare const CreateKeyResponse: Schema.Schema<CreateKeyResponse>;
export type CreateKeyError = DefaultErrors;
export declare const createKey: API.OperationMethod<CreateKeyRequest, CreateKeyResponse, CreateKeyError, Credentials | HttpClient.HttpClient>;
export interface DeleteKeyRequest {
    identifier: string;
    /** Identifier. */
    accountId: string;
}
export declare const DeleteKeyRequest: Schema.Schema<DeleteKeyRequest>;
export type DeleteKeyResponse = string;
export declare const DeleteKeyResponse: Schema.Schema<DeleteKeyResponse>;
export type DeleteKeyError = DefaultErrors;
export declare const deleteKey: API.OperationMethod<DeleteKeyRequest, DeleteKeyResponse, DeleteKeyError, Credentials | HttpClient.HttpClient>;
export interface GetLiveInputRequest {
    liveInputIdentifier: string;
    /** Identifier. */
    accountId: string;
}
export declare const GetLiveInputRequest: Schema.Schema<GetLiveInputRequest>;
export interface GetLiveInputResponse {
    /** The date and time the live input was created. */
    created?: string | null;
    /** Indicates the number of days after which the live inputs recordings will be deleted. When a stream completes and the recording is ready, the value is used to calculate a scheduled deletion date for th */
    deleteRecordingAfterDays?: number | null;
    /** A user modifiable key-value store used to reference other systems of record for managing live inputs. */
    meta?: unknown | null;
    /** The date and time the live input was last modified. */
    modified?: string | null;
    /** A unique identifier for a live input. */
    uid?: string | null;
}
export declare const GetLiveInputResponse: Schema.Schema<GetLiveInputResponse>;
export type GetLiveInputError = DefaultErrors;
export declare const getLiveInput: API.OperationMethod<GetLiveInputRequest, GetLiveInputResponse, GetLiveInputError, Credentials | HttpClient.HttpClient>;
export interface ListLiveInputsRequest {
    /** Path param: Identifier. */
    accountId: string;
    /** Query param: Includes the total number of videos associated with the submitted query parameters. */
    includeCounts?: boolean;
}
export declare const ListLiveInputsRequest: Schema.Schema<ListLiveInputsRequest>;
export interface ListLiveInputsResponse {
    liveInputs?: {
        created?: string | null;
        deleteRecordingAfterDays?: number | null;
        meta?: unknown | null;
        modified?: string | null;
        uid?: string | null;
    }[] | null;
    /** The total number of remaining live inputs based on cursor position. */
    range?: number | null;
    /** The total number of live inputs that match the provided filters. */
    total?: number | null;
}
export declare const ListLiveInputsResponse: Schema.Schema<ListLiveInputsResponse>;
export type ListLiveInputsError = DefaultErrors;
export declare const listLiveInputs: API.OperationMethod<ListLiveInputsRequest, ListLiveInputsResponse, ListLiveInputsError, Credentials | HttpClient.HttpClient>;
export interface CreateLiveInputRequest {
    /** Path param: Identifier. */
    accountId: string;
    /** Body param: Sets the creator ID asssociated with this live input. */
    defaultCreator?: string;
    /** Body param: Indicates the number of days after which the live inputs recordings will be deleted. When a stream completes and the recording is ready, the value is used to calculate a scheduled deletion */
    deleteRecordingAfterDays?: number;
    /** Body param: A user modifiable key-value store used to reference other systems of record for managing live inputs. */
    meta?: unknown;
    /** Body param: Records the input to a Cloudflare Stream video. Behavior depends on the mode. In most cases, the video will initially be viewable as a live video and transition to on-demand after a condit */
    recording?: {
        allowedOrigins?: string[];
        hideLiveViewerCount?: boolean;
        mode?: "off" | "automatic";
        requireSignedURLs?: boolean;
        timeoutSeconds?: number;
    };
}
export declare const CreateLiveInputRequest: Schema.Schema<CreateLiveInputRequest>;
export interface CreateLiveInputResponse {
    /** The date and time the live input was created. */
    created?: string | null;
    /** Indicates the number of days after which the live inputs recordings will be deleted. When a stream completes and the recording is ready, the value is used to calculate a scheduled deletion date for th */
    deleteRecordingAfterDays?: number | null;
    /** A user modifiable key-value store used to reference other systems of record for managing live inputs. */
    meta?: unknown | null;
    /** The date and time the live input was last modified. */
    modified?: string | null;
    /** A unique identifier for a live input. */
    uid?: string | null;
}
export declare const CreateLiveInputResponse: Schema.Schema<CreateLiveInputResponse>;
export type CreateLiveInputError = DefaultErrors;
export declare const createLiveInput: API.OperationMethod<CreateLiveInputRequest, CreateLiveInputResponse, CreateLiveInputError, Credentials | HttpClient.HttpClient>;
export interface UpdateLiveInputRequest {
    liveInputIdentifier: string;
    /** Path param: Identifier. */
    accountId: string;
    /** Body param: Sets the creator ID asssociated with this live input. */
    defaultCreator?: string;
    /** Body param: Indicates the number of days after which the live inputs recordings will be deleted. When a stream completes and the recording is ready, the value is used to calculate a scheduled deletion */
    deleteRecordingAfterDays?: number;
    /** Body param: A user modifiable key-value store used to reference other systems of record for managing live inputs. */
    meta?: unknown;
    /** Body param: Records the input to a Cloudflare Stream video. Behavior depends on the mode. In most cases, the video will initially be viewable as a live video and transition to on-demand after a condit */
    recording?: {
        allowedOrigins?: string[];
        hideLiveViewerCount?: boolean;
        mode?: "off" | "automatic";
        requireSignedURLs?: boolean;
        timeoutSeconds?: number;
    };
}
export declare const UpdateLiveInputRequest: Schema.Schema<UpdateLiveInputRequest>;
export interface UpdateLiveInputResponse {
    /** The date and time the live input was created. */
    created?: string | null;
    /** Indicates the number of days after which the live inputs recordings will be deleted. When a stream completes and the recording is ready, the value is used to calculate a scheduled deletion date for th */
    deleteRecordingAfterDays?: number | null;
    /** A user modifiable key-value store used to reference other systems of record for managing live inputs. */
    meta?: unknown | null;
    /** The date and time the live input was last modified. */
    modified?: string | null;
    /** A unique identifier for a live input. */
    uid?: string | null;
}
export declare const UpdateLiveInputResponse: Schema.Schema<UpdateLiveInputResponse>;
export type UpdateLiveInputError = DefaultErrors;
export declare const updateLiveInput: API.OperationMethod<UpdateLiveInputRequest, UpdateLiveInputResponse, UpdateLiveInputError, Credentials | HttpClient.HttpClient>;
export interface DeleteLiveInputRequest {
    liveInputIdentifier: string;
    /** Identifier. */
    accountId: string;
}
export declare const DeleteLiveInputRequest: Schema.Schema<DeleteLiveInputRequest>;
export type DeleteLiveInputResponse = unknown;
export declare const DeleteLiveInputResponse: Schema.Schema<DeleteLiveInputResponse>;
export type DeleteLiveInputError = DefaultErrors;
export declare const deleteLiveInput: API.OperationMethod<DeleteLiveInputRequest, DeleteLiveInputResponse, DeleteLiveInputError, Credentials | HttpClient.HttpClient>;
export interface ListLiveInputOutputsRequest {
    liveInputIdentifier: string;
    /** Identifier. */
    accountId: string;
}
export declare const ListLiveInputOutputsRequest: Schema.Schema<ListLiveInputOutputsRequest>;
export interface ListLiveInputOutputsResponse {
    result: {
        enabled?: boolean | null;
        streamKey?: string | null;
        uid?: string | null;
        url?: string | null;
    }[];
}
export declare const ListLiveInputOutputsResponse: Schema.Schema<ListLiveInputOutputsResponse>;
export type ListLiveInputOutputsError = DefaultErrors;
export declare const listLiveInputOutputs: API.PaginatedOperationMethod<ListLiveInputOutputsRequest, ListLiveInputOutputsResponse, ListLiveInputOutputsError, Credentials | HttpClient.HttpClient>;
export interface CreateLiveInputOutputRequest {
    liveInputIdentifier: string;
    /** Path param: Identifier. */
    accountId: string;
    /** Body param: The streamKey used to authenticate against an output's target. */
    streamKey: string;
    /** Body param: The URL an output uses to restream. */
    url: string;
    /** Body param: When enabled, live video streamed to the associated live input will be sent to the output URL. When disabled, live video will not be sent to the output URL, even when streaming to the asso */
    enabled?: boolean;
}
export declare const CreateLiveInputOutputRequest: Schema.Schema<CreateLiveInputOutputRequest>;
export interface CreateLiveInputOutputResponse {
    /** When enabled, live video streamed to the associated live input will be sent to the output URL. When disabled, live video will not be sent to the output URL, even when streaming to the associated live  */
    enabled?: boolean | null;
    /** The streamKey used to authenticate against an output's target. */
    streamKey?: string | null;
    /** A unique identifier for the output. */
    uid?: string | null;
    /** The URL an output uses to restream. */
    url?: string | null;
}
export declare const CreateLiveInputOutputResponse: Schema.Schema<CreateLiveInputOutputResponse>;
export type CreateLiveInputOutputError = DefaultErrors;
export declare const createLiveInputOutput: API.OperationMethod<CreateLiveInputOutputRequest, CreateLiveInputOutputResponse, CreateLiveInputOutputError, Credentials | HttpClient.HttpClient>;
export interface UpdateLiveInputOutputRequest {
    liveInputIdentifier: string;
    outputIdentifier: string;
    /** Path param: Identifier. */
    accountId: string;
    /** Body param: When enabled, live video streamed to the associated live input will be sent to the output URL. When disabled, live video will not be sent to the output URL, even when streaming to the asso */
    enabled: boolean;
}
export declare const UpdateLiveInputOutputRequest: Schema.Schema<UpdateLiveInputOutputRequest>;
export interface UpdateLiveInputOutputResponse {
    /** When enabled, live video streamed to the associated live input will be sent to the output URL. When disabled, live video will not be sent to the output URL, even when streaming to the associated live  */
    enabled?: boolean | null;
    /** The streamKey used to authenticate against an output's target. */
    streamKey?: string | null;
    /** A unique identifier for the output. */
    uid?: string | null;
    /** The URL an output uses to restream. */
    url?: string | null;
}
export declare const UpdateLiveInputOutputResponse: Schema.Schema<UpdateLiveInputOutputResponse>;
export type UpdateLiveInputOutputError = DefaultErrors;
export declare const updateLiveInputOutput: API.OperationMethod<UpdateLiveInputOutputRequest, UpdateLiveInputOutputResponse, UpdateLiveInputOutputError, Credentials | HttpClient.HttpClient>;
export interface DeleteLiveInputOutputRequest {
    liveInputIdentifier: string;
    outputIdentifier: string;
    /** Identifier. */
    accountId: string;
}
export declare const DeleteLiveInputOutputRequest: Schema.Schema<DeleteLiveInputOutputRequest>;
export type DeleteLiveInputOutputResponse = unknown;
export declare const DeleteLiveInputOutputResponse: Schema.Schema<DeleteLiveInputOutputResponse>;
export type DeleteLiveInputOutputError = DefaultErrors;
export declare const deleteLiveInputOutput: API.OperationMethod<DeleteLiveInputOutputRequest, DeleteLiveInputOutputResponse, DeleteLiveInputOutputError, Credentials | HttpClient.HttpClient>;
export interface GetStreamRequest {
    identifier: string;
    /** The account identifier tag. */
    accountId: string;
}
export declare const GetStreamRequest: Schema.Schema<GetStreamRequest>;
export interface GetStreamResponse {
    /** Lists the origins allowed to display the video. Enter allowed origin domains in an array and use ` ` for wildcard subdomains. Empty arrays allow the video to be viewed on any origin. */
    allowedOrigins?: string[] | null;
    /** The date and time the media item was created. */
    created?: string | null;
    /** A user-defined identifier for the media creator. */
    creator?: string | null;
    /** The duration of the video in seconds. A value of `-1` means the duration is unknown. The duration becomes available after the upload and before the video is ready. */
    duration?: number | null;
    input?: {
        height?: number | null;
        width?: number | null;
    } | null;
    /** The live input ID used to upload a video with Stream Live. */
    liveInput?: string | null;
    /** The maximum duration in seconds for a video upload. Can be set for a video that is not yet uploaded to limit its duration. Uploads that exceed the specified duration will fail during processing. A val */
    maxDurationSeconds?: number | null;
    /** A user modifiable key-value store used to reference other systems of record for managing videos. */
    meta?: unknown | null;
    /** The date and time the media item was last modified. */
    modified?: string | null;
    playback?: {
        dash?: string | null;
        hls?: string | null;
    } | null;
    /** The video's preview page URI. This field is omitted until encoding is complete. */
    preview?: string | null;
    /** Indicates whether the video is playable. The field is empty if the video is not ready for viewing or the live stream is still in progress. */
    readyToStream?: boolean | null;
    /** Indicates the time at which the video became playable. The field is empty if the video is not ready for viewing or the live stream is still in progress. */
    readyToStreamAt?: string | null;
    /** Indicates whether the video can be a accessed using the UID. When set to `true`, a signed token must be generated with a signing key to view the video. */
    requireSignedURLs?: boolean | null;
    /** Indicates the date and time at which the video will be deleted. Omit the field to indicate no change, or include with a `null` value to remove an existing scheduled deletion. If specified, must be at  */
    scheduledDeletion?: string | null;
    /** The size of the media item in bytes. */
    size?: number | null;
    /** Specifies a detailed status for a video. If the `state` is `inprogress` or `error`, the `step` field returns `encoding` or `manifest`. If the `state` is `inprogress`, `pctComplete` returns a number be */
    status?: {
        errorReasonCode?: string | null;
        errorReasonText?: string | null;
        pctComplete?: string | null;
        state?: "pendingupload" | "downloading" | "queued" | "inprogress" | "ready" | "error" | "live-inprogress" | null;
    } | null;
    /** The media item's thumbnail URI. This field is omitted until encoding is complete. */
    thumbnail?: string | null;
    /** The timestamp for a thumbnail image calculated as a percentage value of the video's duration. To convert from a second-wise timestamp to a percentage, divide the desired timestamp by the total duratio */
    thumbnailTimestampPct?: number | null;
    /** A Cloudflare-generated unique identifier for a media item. */
    uid?: string | null;
    /** The date and time the media item was uploaded. */
    uploaded?: string | null;
    /** The date and time when the video upload URL is no longer valid for direct user uploads. */
    uploadExpiry?: string | null;
    watermark?: {
        created?: string | null;
        downloadedFrom?: string | null;
        height?: number | null;
        name?: string | null;
        opacity?: number | null;
        padding?: number | null;
        position?: string | null;
        scale?: number | null;
        size?: number | null;
        uid?: string | null;
        width?: number | null;
    } | null;
}
export declare const GetStreamResponse: Schema.Schema<GetStreamResponse>;
export type GetStreamError = DefaultErrors;
export declare const getStream: API.OperationMethod<GetStreamRequest, GetStreamResponse, GetStreamError, Credentials | HttpClient.HttpClient>;
export interface ListStreamsRequest {
    /** Path param: The account identifier tag. */
    accountId: string;
    /** Query param: Lists videos in ascending order of creation. */
    asc?: boolean;
    /** Query param: A user-defined identifier for the media creator. */
    creator?: string;
    /** Query param: Lists videos created before the specified date. */
    end?: string;
    /** Query param: Includes the total number of videos associated with the submitted query parameters. */
    includeCounts?: boolean;
    /** Query param: Provides a partial word match of the `name` key in the `meta` field. Slow for medium to large video libraries. May be unavailable for very large libraries. */
    search?: string;
    /** Query param: Lists videos created after the specified date. */
    start?: string;
    /** Query param: Specifies the processing status for all quality levels for a video. */
    status?: "pendingupload" | "downloading" | "queued" | "inprogress" | "ready" | "error" | "live-inprogress";
    /** Query param: Specifies whether the video is `vod` or `live`. */
    type?: string;
    /** Query param: Provides a fast, exact string match on the `name` key in the `meta` field. */
    videoName?: string;
}
export declare const ListStreamsRequest: Schema.Schema<ListStreamsRequest>;
export interface ListStreamsResponse {
    result: {
        allowedOrigins?: string[] | null;
        created?: string | null;
        creator?: string | null;
        duration?: number | null;
        input?: {
            height?: number | null;
            width?: number | null;
        } | null;
        liveInput?: string | null;
        maxDurationSeconds?: number | null;
        meta?: unknown | null;
        modified?: string | null;
        playback?: {
            dash?: string | null;
            hls?: string | null;
        } | null;
        preview?: string | null;
        readyToStream?: boolean | null;
        readyToStreamAt?: string | null;
        requireSignedURLs?: boolean | null;
        scheduledDeletion?: string | null;
        size?: number | null;
        status?: {
            errorReasonCode?: string | null;
            errorReasonText?: string | null;
            pctComplete?: string | null;
            state?: "pendingupload" | "downloading" | "queued" | "inprogress" | "ready" | "error" | "live-inprogress" | null;
        } | null;
        thumbnail?: string | null;
        thumbnailTimestampPct?: number | null;
        uid?: string | null;
        uploaded?: string | null;
        uploadExpiry?: string | null;
        watermark?: {
            created?: string | null;
            downloadedFrom?: string | null;
            height?: number | null;
            name?: string | null;
            opacity?: number | null;
            padding?: number | null;
            position?: string | null;
            scale?: number | null;
            size?: number | null;
            uid?: string | null;
            width?: number | null;
        } | null;
    }[];
}
export declare const ListStreamsResponse: Schema.Schema<ListStreamsResponse>;
export type ListStreamsError = DefaultErrors;
export declare const listStreams: API.PaginatedOperationMethod<ListStreamsRequest, ListStreamsResponse, ListStreamsError, Credentials | HttpClient.HttpClient>;
export interface CreateStreamRequest {
    /** Path param: The account identifier tag. */
    accountId: string;
    /** Query param: Provisions a URL to let your end users upload videos directly to Cloudflare Stream without exposing your API token to clients. */
    directUser?: boolean;
    /** Header param: Specifies the TUS protocol version. This value must be included in every upload request. Notes: The only supported version of TUS protocol is 1.0.0. */
    tusResumable: "1.0.0";
    /** Header param: Indicates the size of the entire upload in bytes. The value must be a non-negative integer. */
    uploadLength: number;
    /** Header param: A user-defined identifier for the media creator. */
    uploadCreator?: string;
    /** Header param: Comma-separated key-value pairs following the TUS protocol specification. Values are Base-64 encoded. Supported keys: `name`, `requiresignedurls`, `allowedorigins`, `thumbnailtimestamppc */
    uploadMetadata?: string;
    /** Body param: */
    body: unknown;
}
export declare const CreateStreamRequest: Schema.Schema<CreateStreamRequest>;
export type CreateStreamResponse = unknown;
export declare const CreateStreamResponse: Schema.Schema<CreateStreamResponse>;
export type CreateStreamError = DefaultErrors;
export declare const createStream: API.OperationMethod<CreateStreamRequest, CreateStreamResponse, CreateStreamError, Credentials | HttpClient.HttpClient>;
export interface DeleteStreamRequest {
    identifier: string;
    /** The account identifier tag. */
    accountId: string;
}
export declare const DeleteStreamRequest: Schema.Schema<DeleteStreamRequest>;
export type DeleteStreamResponse = unknown;
export declare const DeleteStreamResponse: Schema.Schema<DeleteStreamResponse>;
export type DeleteStreamError = DefaultErrors;
export declare const deleteStream: API.OperationMethod<DeleteStreamRequest, DeleteStreamResponse, DeleteStreamError, Credentials | HttpClient.HttpClient>;
export interface EditStreamRequest {
    identifier: string;
    /** Path param: The account identifier tag. */
    accountId: string;
    /** Body param: Lists the origins allowed to display the video. Enter allowed origin domains in an array and use ` ` for wildcard subdomains. Empty arrays allow the video to be viewed on any origin. */
    allowedOrigins?: string[];
    /** Body param: A user-defined identifier for the media creator. */
    creator?: string;
    /** Body param: The maximum duration in seconds for a video upload. Can be set for a video that is not yet uploaded to limit its duration. Uploads that exceed the specified duration will fail during proce */
    maxDurationSeconds?: number;
    /** Body param: A user modifiable key-value store used to reference other systems of record for managing videos. */
    meta?: unknown;
    /** Body param: Indicates whether the video can be a accessed using the UID. When set to `true`, a signed token must be generated with a signing key to view the video. */
    requireSignedURLs?: boolean;
    /** Body param: Indicates the date and time at which the video will be deleted. Omit the field to indicate no change, or include with a `null` value to remove an existing scheduled deletion. If specified, */
    scheduledDeletion?: string;
    /** Body param: The timestamp for a thumbnail image calculated as a percentage value of the video's duration. To convert from a second-wise timestamp to a percentage, divide the desired timestamp by the t */
    thumbnailTimestampPct?: number;
    /** Body param: The date and time when the video upload URL is no longer valid for direct user uploads. */
    uploadExpiry?: string;
}
export declare const EditStreamRequest: Schema.Schema<EditStreamRequest>;
export interface EditStreamResponse {
    /** Lists the origins allowed to display the video. Enter allowed origin domains in an array and use ` ` for wildcard subdomains. Empty arrays allow the video to be viewed on any origin. */
    allowedOrigins?: string[] | null;
    /** The date and time the media item was created. */
    created?: string | null;
    /** A user-defined identifier for the media creator. */
    creator?: string | null;
    /** The duration of the video in seconds. A value of `-1` means the duration is unknown. The duration becomes available after the upload and before the video is ready. */
    duration?: number | null;
    input?: {
        height?: number | null;
        width?: number | null;
    } | null;
    /** The live input ID used to upload a video with Stream Live. */
    liveInput?: string | null;
    /** The maximum duration in seconds for a video upload. Can be set for a video that is not yet uploaded to limit its duration. Uploads that exceed the specified duration will fail during processing. A val */
    maxDurationSeconds?: number | null;
    /** A user modifiable key-value store used to reference other systems of record for managing videos. */
    meta?: unknown | null;
    /** The date and time the media item was last modified. */
    modified?: string | null;
    playback?: {
        dash?: string | null;
        hls?: string | null;
    } | null;
    /** The video's preview page URI. This field is omitted until encoding is complete. */
    preview?: string | null;
    /** Indicates whether the video is playable. The field is empty if the video is not ready for viewing or the live stream is still in progress. */
    readyToStream?: boolean | null;
    /** Indicates the time at which the video became playable. The field is empty if the video is not ready for viewing or the live stream is still in progress. */
    readyToStreamAt?: string | null;
    /** Indicates whether the video can be a accessed using the UID. When set to `true`, a signed token must be generated with a signing key to view the video. */
    requireSignedURLs?: boolean | null;
    /** Indicates the date and time at which the video will be deleted. Omit the field to indicate no change, or include with a `null` value to remove an existing scheduled deletion. If specified, must be at  */
    scheduledDeletion?: string | null;
    /** The size of the media item in bytes. */
    size?: number | null;
    /** Specifies a detailed status for a video. If the `state` is `inprogress` or `error`, the `step` field returns `encoding` or `manifest`. If the `state` is `inprogress`, `pctComplete` returns a number be */
    status?: {
        errorReasonCode?: string | null;
        errorReasonText?: string | null;
        pctComplete?: string | null;
        state?: "pendingupload" | "downloading" | "queued" | "inprogress" | "ready" | "error" | "live-inprogress" | null;
    } | null;
    /** The media item's thumbnail URI. This field is omitted until encoding is complete. */
    thumbnail?: string | null;
    /** The timestamp for a thumbnail image calculated as a percentage value of the video's duration. To convert from a second-wise timestamp to a percentage, divide the desired timestamp by the total duratio */
    thumbnailTimestampPct?: number | null;
    /** A Cloudflare-generated unique identifier for a media item. */
    uid?: string | null;
    /** The date and time the media item was uploaded. */
    uploaded?: string | null;
    /** The date and time when the video upload URL is no longer valid for direct user uploads. */
    uploadExpiry?: string | null;
    watermark?: {
        created?: string | null;
        downloadedFrom?: string | null;
        height?: number | null;
        name?: string | null;
        opacity?: number | null;
        padding?: number | null;
        position?: string | null;
        scale?: number | null;
        size?: number | null;
        uid?: string | null;
        width?: number | null;
    } | null;
}
export declare const EditStreamResponse: Schema.Schema<EditStreamResponse>;
export type EditStreamError = DefaultErrors;
export declare const editStream: API.OperationMethod<EditStreamRequest, EditStreamResponse, EditStreamError, Credentials | HttpClient.HttpClient>;
export interface CreateTokenRequest {
    identifier: string;
    /** Path param: The account identifier tag. */
    accountId: string;
    /** Body param: The optional ID of a Stream signing key. If present, the `pem` field is also required. */
    id?: string;
    /** Body param: The optional list of access rule constraints on the token. Access can be blocked or allowed based on an IP, IP range, or by country. Access rules are evaluated from first to last. If a rul */
    accessRules?: {
        action?: "allow" | "block";
        country?: string[];
        ip?: string[];
        type?: "any" | "ip.src" | "ip.geoip.country";
    }[];
    /** Body param: The optional boolean value that enables using signed tokens to access MP4 download links for a video. */
    downloadable?: boolean;
    /** Body param: The optional unix epoch timestamp that specficies the time after a token is not accepted. The maximum time specification is 24 hours from issuing time. If this field is not set, the defaul */
    exp?: number;
    /** Body param: The optional unix epoch timestamp that specifies the time before a the token is not accepted. If this field is not set, the default is one hour before issuing. */
    nbf?: number;
    /** Body param: The optional base64 encoded private key in PEM format associated with a Stream signing key. If present, the `id` field is also required. */
    pem?: string;
}
export declare const CreateTokenRequest: Schema.Schema<CreateTokenRequest>;
export interface CreateTokenResponse {
    /** The signed token used with the signed URLs feature. */
    token?: string | null;
}
export declare const CreateTokenResponse: Schema.Schema<CreateTokenResponse>;
export type CreateTokenError = DefaultErrors;
export declare const createToken: API.OperationMethod<CreateTokenRequest, CreateTokenResponse, CreateTokenError, Credentials | HttpClient.HttpClient>;
export interface StorageUsageVideoRequest {
    /** Path param: The account identifier tag. */
    accountId: string;
    /** Query param: A user-defined identifier for the media creator. */
    creator?: string;
}
export declare const StorageUsageVideoRequest: Schema.Schema<StorageUsageVideoRequest>;
export interface StorageUsageVideoResponse {
    /** A user-defined identifier for the media creator. */
    creator?: string | null;
    /** The total minutes of video content stored in the account. */
    totalStorageMinutes?: number | null;
    /** The storage capacity alloted for the account. */
    totalStorageMinutesLimit?: number | null;
    /** The total count of videos associated with the account. */
    videoCount?: number | null;
}
export declare const StorageUsageVideoResponse: Schema.Schema<StorageUsageVideoResponse>;
export type StorageUsageVideoError = DefaultErrors;
export declare const storageUsageVideo: API.OperationMethod<StorageUsageVideoRequest, StorageUsageVideoResponse, StorageUsageVideoError, Credentials | HttpClient.HttpClient>;
export interface GetWatermarkRequest {
    identifier: string;
    /** The account identifier tag. */
    accountId: string;
}
export declare const GetWatermarkRequest: Schema.Schema<GetWatermarkRequest>;
export interface GetWatermarkResponse {
    /** The date and a time a watermark profile was created. */
    created?: string | null;
    /** The source URL for a downloaded image. If the watermark profile was created via direct upload, this field is null. */
    downloadedFrom?: string | null;
    /** The height of the image in pixels. */
    height?: number | null;
    /** A short description of the watermark profile. */
    name?: string | null;
    /** The translucency of the image. A value of `0.0` makes the image completely transparent, and `1.0` makes the image completely opaque. Note that if the image is already semi-transparent, setting this to */
    opacity?: number | null;
    /** The whitespace between the adjacent edges (determined by position) of the video and the image. `0.0` indicates no padding, and `1.0` indicates a fully padded video width or length, as determined by th */
    padding?: number | null;
    /** The location of the image. Valid positions are: `upperRight`, `upperLeft`, `lowerLeft`, `lowerRight`, and `center`. Note that `center` ignores the `padding` parameter. */
    position?: string | null;
    /** The size of the image relative to the overall size of the video. This parameter will adapt to horizontal and vertical videos automatically. `0.0` indicates no scaling (use the size of the image as-is) */
    scale?: number | null;
    /** The size of the image in bytes. */
    size?: number | null;
    /** The unique identifier for a watermark profile. */
    uid?: string | null;
    /** The width of the image in pixels. */
    width?: number | null;
}
export declare const GetWatermarkResponse: Schema.Schema<GetWatermarkResponse>;
export type GetWatermarkError = DefaultErrors;
export declare const getWatermark: API.OperationMethod<GetWatermarkRequest, GetWatermarkResponse, GetWatermarkError, Credentials | HttpClient.HttpClient>;
export interface ListWatermarksRequest {
    /** The account identifier tag. */
    accountId: string;
}
export declare const ListWatermarksRequest: Schema.Schema<ListWatermarksRequest>;
export interface ListWatermarksResponse {
    result: {
        created?: string | null;
        downloadedFrom?: string | null;
        height?: number | null;
        name?: string | null;
        opacity?: number | null;
        padding?: number | null;
        position?: string | null;
        scale?: number | null;
        size?: number | null;
        uid?: string | null;
        width?: number | null;
    }[];
}
export declare const ListWatermarksResponse: Schema.Schema<ListWatermarksResponse>;
export type ListWatermarksError = DefaultErrors;
export declare const listWatermarks: API.PaginatedOperationMethod<ListWatermarksRequest, ListWatermarksResponse, ListWatermarksError, Credentials | HttpClient.HttpClient>;
export interface CreateWatermarkRequest {
    /** Path param: The account identifier tag. */
    accountId: string;
    /** Body param: The image file to upload. */
    file: string;
    /** Body param: A short description of the watermark profile. */
    name?: string;
    /** Body param: The translucency of the image. A value of `0.0` makes the image completely transparent, and `1.0` makes the image completely opaque. Note that if the image is already semi-transparent, set */
    opacity?: number;
    /** Body param: The whitespace between the adjacent edges (determined by position) of the video and the image. `0.0` indicates no padding, and `1.0` indicates a fully padded video width or length, as dete */
    padding?: number;
    /** Body param: The location of the image. Valid positions are: `upperRight`, `upperLeft`, `lowerLeft`, `lowerRight`, and `center`. Note that `center` ignores the `padding` parameter. */
    position?: string;
    /** Body param: The size of the image relative to the overall size of the video. This parameter will adapt to horizontal and vertical videos automatically. `0.0` indicates no scaling (use the size of the  */
    scale?: number;
}
export declare const CreateWatermarkRequest: Schema.Schema<CreateWatermarkRequest>;
export interface CreateWatermarkResponse {
    /** The date and a time a watermark profile was created. */
    created?: string | null;
    /** The source URL for a downloaded image. If the watermark profile was created via direct upload, this field is null. */
    downloadedFrom?: string | null;
    /** The height of the image in pixels. */
    height?: number | null;
    /** A short description of the watermark profile. */
    name?: string | null;
    /** The translucency of the image. A value of `0.0` makes the image completely transparent, and `1.0` makes the image completely opaque. Note that if the image is already semi-transparent, setting this to */
    opacity?: number | null;
    /** The whitespace between the adjacent edges (determined by position) of the video and the image. `0.0` indicates no padding, and `1.0` indicates a fully padded video width or length, as determined by th */
    padding?: number | null;
    /** The location of the image. Valid positions are: `upperRight`, `upperLeft`, `lowerLeft`, `lowerRight`, and `center`. Note that `center` ignores the `padding` parameter. */
    position?: string | null;
    /** The size of the image relative to the overall size of the video. This parameter will adapt to horizontal and vertical videos automatically. `0.0` indicates no scaling (use the size of the image as-is) */
    scale?: number | null;
    /** The size of the image in bytes. */
    size?: number | null;
    /** The unique identifier for a watermark profile. */
    uid?: string | null;
    /** The width of the image in pixels. */
    width?: number | null;
}
export declare const CreateWatermarkResponse: Schema.Schema<CreateWatermarkResponse>;
export type CreateWatermarkError = DefaultErrors;
export declare const createWatermark: API.OperationMethod<CreateWatermarkRequest, CreateWatermarkResponse, CreateWatermarkError, Credentials | HttpClient.HttpClient>;
export interface DeleteWatermarkRequest {
    identifier: string;
    /** The account identifier tag. */
    accountId: string;
}
export declare const DeleteWatermarkRequest: Schema.Schema<DeleteWatermarkRequest>;
export type DeleteWatermarkResponse = string;
export declare const DeleteWatermarkResponse: Schema.Schema<DeleteWatermarkResponse>;
export type DeleteWatermarkError = DefaultErrors;
export declare const deleteWatermark: API.OperationMethod<DeleteWatermarkRequest, DeleteWatermarkResponse, DeleteWatermarkError, Credentials | HttpClient.HttpClient>;
export interface GetWebhookRequest {
    /** The account identifier tag. */
    accountId: string;
}
export declare const GetWebhookRequest: Schema.Schema<GetWebhookRequest>;
export type GetWebhookResponse = unknown;
export declare const GetWebhookResponse: Schema.Schema<GetWebhookResponse>;
export type GetWebhookError = DefaultErrors;
export declare const getWebhook: API.OperationMethod<GetWebhookRequest, GetWebhookResponse, GetWebhookError, Credentials | HttpClient.HttpClient>;
export interface PutWebhookRequest {
    /** Path param: The account identifier tag. */
    accountId: string;
    /** Body param: The URL where webhooks will be sent. */
    notificationUrl: string;
}
export declare const PutWebhookRequest: Schema.Schema<PutWebhookRequest>;
export type PutWebhookResponse = unknown;
export declare const PutWebhookResponse: Schema.Schema<PutWebhookResponse>;
export type PutWebhookError = DefaultErrors;
export declare const putWebhook: API.OperationMethod<PutWebhookRequest, PutWebhookResponse, PutWebhookError, Credentials | HttpClient.HttpClient>;
export interface DeleteWebhookRequest {
    /** The account identifier tag. */
    accountId: string;
}
export declare const DeleteWebhookRequest: Schema.Schema<DeleteWebhookRequest>;
export type DeleteWebhookResponse = string;
export declare const DeleteWebhookResponse: Schema.Schema<DeleteWebhookResponse>;
export type DeleteWebhookError = DefaultErrors;
export declare const deleteWebhook: API.OperationMethod<DeleteWebhookRequest, DeleteWebhookResponse, DeleteWebhookError, Credentials | HttpClient.HttpClient>;
//# sourceMappingURL=stream.d.ts.map