import * as z from "zod";
import { ClosedEnum } from "../../types/enums.js";
import { Result as SafeParseResult } from "../../types/fp.js";
import { SDKValidationError } from "../errors/sdkvalidationerror.js";
export type GenerateArchiveGlobals = {
    /**
     * The cloud name of your product environment.
     */
    cloudName?: string | undefined;
};
/**
 * The type of resources to include in the archive. "image" for images, "video" for videos, "raw" for non-media files, or "all" for mixed types.
 */
export declare const GenerateArchiveResourceType: {
    readonly Image: "image";
    readonly Video: "video";
    readonly Raw: "raw";
    readonly All: "all";
};
/**
 * The type of resources to include in the archive. "image" for images, "video" for videos, "raw" for non-media files, or "all" for mixed types.
 */
export type GenerateArchiveResourceType = ClosedEnum<typeof GenerateArchiveResourceType>;
/**
 * The specific file type of assets to include in the archive. Not applicable when "resource_type" is "all".
 */
export declare const GenerateArchiveType: {
    readonly Upload: "upload";
    readonly Private: "private";
    readonly Authenticated: "authenticated";
    readonly Fetch: "fetch";
};
/**
 * The specific file type of assets to include in the archive. Not applicable when "resource_type" is "all".
 */
export type GenerateArchiveType = ClosedEnum<typeof GenerateArchiveType>;
/**
 * The method for generating and delivering the archive. Options:
 *
 * @remarks
 * download - Generates and delivers the archive file without storing it
 * create - Creates and stores the archive as a raw asset, returning URLs in the response
 * create_and_download - Creates, stores, and delivers the archive file
 */
export declare const Mode: {
    readonly Download: "download";
    readonly Create: "create";
    readonly CreateAndDownload: "create_and_download";
};
/**
 * The method for generating and delivering the archive. Options:
 *
 * @remarks
 * download - Generates and delivers the archive file without storing it
 * create - Creates and stores the archive as a raw asset, returning URLs in the response
 * create_and_download - Creates, stores, and delivers the archive file
 */
export type Mode = ClosedEnum<typeof Mode>;
/**
 * The format of the generated archive.
 */
export declare const TargetFormat: {
    readonly Zip: "zip";
    readonly Tgz: "tgz";
};
/**
 * The format of the generated archive.
 */
export type TargetFormat = ClosedEnum<typeof TargetFormat>;
export type GenerateArchiveRequestBody = {
    /**
     * (Required for signed REST API calls) Used to authenticate the request and based on the parameters you use in the request. When using the Cloudinary SDKs for signed requests, the signature is automatically generated and added to the request. If you manually generate your own signed POST request, you need to manually generate the signature parameter and add it to the request together with the api_key and timestamp parameters.
     *
     * @remarks
     */
    signature?: string | undefined;
    /**
     * The timestamp to use for the request in unix time. This is automatically computed by the Cloudinary's SDKs.
     */
    timestamp?: number | undefined;
    /**
     * The API key to use for the request. This is automatically computed by the Cloudinary's SDKs.
     */
    apiKey?: string | undefined;
    /**
     * The list of public IDs to include in the archive. Up to 1000 public IDs are supported.
     */
    publicIds?: Array<string> | undefined;
    /**
     * A tag to use for selecting assets to include in the archive. Up to 20 tags are supported.
     */
    tags?: Array<string> | undefined;
    /**
     * Select all assets where the public ID starts with this prefix. Up to 20 prefixes are supported.
     */
    prefixes?: Array<string> | undefined;
    /**
     * The specific file type of assets to include in the archive. Not applicable when "resource_type" is "all".
     */
    type?: GenerateArchiveType | undefined;
    /**
     * The transformations to apply to the assets before including them in the archive (separated by "|").
     */
    transformations?: string | undefined;
    /**
     * The method for generating and delivering the archive. Options:
     *
     * @remarks
     * download - Generates and delivers the archive file without storing it
     * create - Creates and stores the archive as a raw asset, returning URLs in the response
     * create_and_download - Creates, stores, and delivers the archive file
     */
    mode?: Mode | undefined;
    /**
     * The format of the generated archive.
     */
    targetFormat?: TargetFormat | undefined;
    /**
     * The public ID to assign to the generated archive, or the filename of the downloaded archive file.
     */
    targetPublicId?: string | undefined;
    /**
     * The folder in your product environment where the generated archive should be stored.
     */
    targetAssetFolder?: string | undefined;
    /**
     * Whether to flatten all files to be in the root of the archive file.
     */
    flattenFolders?: boolean | undefined;
    /**
     * Whether to flatten the folder structure of the derived assets.
     */
    flattenTransformations?: boolean | undefined;
    /**
     * Whether to skip adding the transformation details to the file names in the archive.
     */
    skipTransformationName?: boolean | undefined;
    /**
     * Whether to allow missing assets in the archive. If false, the operation will fail if any asset is not found.
     */
    allowMissing?: boolean | undefined;
    /**
     * ("download" mode only) Unix timestamp indicating when the generated archive URL should expire.
     */
    expiresAt?: number | undefined;
    /**
     * Whether to use the original filenames of the assets in the archive instead of public IDs (when available).
     */
    useOriginalFilename?: boolean | undefined;
    /**
     * ("create" mode only), specifies whether to generate the archive asynchronously.
     */
    async?: boolean | undefined;
    /**
     * ("create" mode only), specifies the URL to notify when the archive generation is complete.
     */
    notificationUrl?: string | undefined;
    /**
     * A list of tag names to assign to the generated archive.
     */
    targetTags?: Array<string> | undefined;
    /**
     * Whether to keep the derived assets used for generating the archive.
     */
    keepDerived?: boolean | undefined;
};
export type GenerateArchiveRequest = {
    /**
     * The type of resources to include in the archive. "image" for images, "video" for videos, "raw" for non-media files, or "all" for mixed types.
     */
    resourceType: GenerateArchiveResourceType;
    requestBody: GenerateArchiveRequestBody;
};
/**
 * Archive successfully generated or downloaded
 */
export type GenerateArchiveResponseBody = {
    /**
     * The unique identifier of the generated archive in the Cloudinary system.
     */
    assetId?: string | undefined;
    /**
     * The public ID of the generated archive.
     */
    publicId?: string | undefined;
    /**
     * The version number of the generated archive.
     */
    version?: number | undefined;
    /**
     * The unique identifier of this version of the generated archive.
     */
    versionId?: string | undefined;
    /**
     * The type of resource. Always "raw" for generated archives.
     */
    resourceType?: string | undefined;
    /**
     * The timestamp when the archive was generated.
     */
    createdAt?: Date | undefined;
    /**
     * The tags assigned to the generated archive.
     */
    tags?: Array<string> | undefined;
    /**
     * The size of the generated archive in bytes.
     */
    bytes?: number | undefined;
    /**
     * The resource type of the generated archive.
     */
    type?: string | undefined;
    /**
     * The HTTP URL for downloading the generated archive.
     */
    url?: string | undefined;
    /**
     * The HTTPS URL for downloading the generated archive.
     */
    secureUrl?: string | undefined;
    /**
     * The folder where the archive is stored (only for product environments with Dynamic Folders disabled)
     *
     * @deprecated field: If Dynamic folders mode is enabled on your product environment, this parameter is deprecated, and it's recommended to use the asset_folder parameter.
    .
     */
    folder?: string | undefined;
    /**
     * The number of unique resources included in the archive.
     */
    resourceCount?: number | undefined;
    /**
     * The total number of files in the archive.
     */
    fileCount?: number | undefined;
    /**
     * The folder in your product environment where the archive is stored.
     */
    assetFolder?: string | undefined;
    /**
     * The display name of the generated archive.
     */
    displayName?: string | undefined;
    /**
     * The list of public IDs that were requested but not found.
     */
    missingPublicIds?: Array<string> | undefined;
    /**
     * The list of tags that were requested but returned no results.
     */
    emptyTags?: Array<string> | undefined;
    /**
     * The list of prefixes that were requested but returned no results.
     */
    emptyPrefixes?: Array<string> | undefined;
};
export type GenerateArchiveResponse = GenerateArchiveResponseBody | ReadableStream<Uint8Array>;
/** @internal */
export declare const GenerateArchiveGlobals$inboundSchema: z.ZodType<GenerateArchiveGlobals, z.ZodTypeDef, unknown>;
/** @internal */
export type GenerateArchiveGlobals$Outbound = {
    cloud_name?: string | undefined;
};
/** @internal */
export declare const GenerateArchiveGlobals$outboundSchema: z.ZodType<GenerateArchiveGlobals$Outbound, z.ZodTypeDef, GenerateArchiveGlobals>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace GenerateArchiveGlobals$ {
    /** @deprecated use `GenerateArchiveGlobals$inboundSchema` instead. */
    const inboundSchema: z.ZodType<GenerateArchiveGlobals, z.ZodTypeDef, unknown>;
    /** @deprecated use `GenerateArchiveGlobals$outboundSchema` instead. */
    const outboundSchema: z.ZodType<GenerateArchiveGlobals$Outbound, z.ZodTypeDef, GenerateArchiveGlobals>;
    /** @deprecated use `GenerateArchiveGlobals$Outbound` instead. */
    type Outbound = GenerateArchiveGlobals$Outbound;
}
export declare function generateArchiveGlobalsToJSON(generateArchiveGlobals: GenerateArchiveGlobals): string;
export declare function generateArchiveGlobalsFromJSON(jsonString: string): SafeParseResult<GenerateArchiveGlobals, SDKValidationError>;
/** @internal */
export declare const GenerateArchiveResourceType$inboundSchema: z.ZodNativeEnum<typeof GenerateArchiveResourceType>;
/** @internal */
export declare const GenerateArchiveResourceType$outboundSchema: z.ZodNativeEnum<typeof GenerateArchiveResourceType>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace GenerateArchiveResourceType$ {
    /** @deprecated use `GenerateArchiveResourceType$inboundSchema` instead. */
    const inboundSchema: z.ZodNativeEnum<{
        readonly Image: "image";
        readonly Video: "video";
        readonly Raw: "raw";
        readonly All: "all";
    }>;
    /** @deprecated use `GenerateArchiveResourceType$outboundSchema` instead. */
    const outboundSchema: z.ZodNativeEnum<{
        readonly Image: "image";
        readonly Video: "video";
        readonly Raw: "raw";
        readonly All: "all";
    }>;
}
/** @internal */
export declare const GenerateArchiveType$inboundSchema: z.ZodNativeEnum<typeof GenerateArchiveType>;
/** @internal */
export declare const GenerateArchiveType$outboundSchema: z.ZodNativeEnum<typeof GenerateArchiveType>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace GenerateArchiveType$ {
    /** @deprecated use `GenerateArchiveType$inboundSchema` instead. */
    const inboundSchema: z.ZodNativeEnum<{
        readonly Upload: "upload";
        readonly Private: "private";
        readonly Authenticated: "authenticated";
        readonly Fetch: "fetch";
    }>;
    /** @deprecated use `GenerateArchiveType$outboundSchema` instead. */
    const outboundSchema: z.ZodNativeEnum<{
        readonly Upload: "upload";
        readonly Private: "private";
        readonly Authenticated: "authenticated";
        readonly Fetch: "fetch";
    }>;
}
/** @internal */
export declare const Mode$inboundSchema: z.ZodNativeEnum<typeof Mode>;
/** @internal */
export declare const Mode$outboundSchema: z.ZodNativeEnum<typeof Mode>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace Mode$ {
    /** @deprecated use `Mode$inboundSchema` instead. */
    const inboundSchema: z.ZodNativeEnum<{
        readonly Download: "download";
        readonly Create: "create";
        readonly CreateAndDownload: "create_and_download";
    }>;
    /** @deprecated use `Mode$outboundSchema` instead. */
    const outboundSchema: z.ZodNativeEnum<{
        readonly Download: "download";
        readonly Create: "create";
        readonly CreateAndDownload: "create_and_download";
    }>;
}
/** @internal */
export declare const TargetFormat$inboundSchema: z.ZodNativeEnum<typeof TargetFormat>;
/** @internal */
export declare const TargetFormat$outboundSchema: z.ZodNativeEnum<typeof TargetFormat>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace TargetFormat$ {
    /** @deprecated use `TargetFormat$inboundSchema` instead. */
    const inboundSchema: z.ZodNativeEnum<{
        readonly Zip: "zip";
        readonly Tgz: "tgz";
    }>;
    /** @deprecated use `TargetFormat$outboundSchema` instead. */
    const outboundSchema: z.ZodNativeEnum<{
        readonly Zip: "zip";
        readonly Tgz: "tgz";
    }>;
}
/** @internal */
export declare const GenerateArchiveRequestBody$inboundSchema: z.ZodType<GenerateArchiveRequestBody, z.ZodTypeDef, unknown>;
/** @internal */
export type GenerateArchiveRequestBody$Outbound = {
    signature?: string | undefined;
    timestamp?: number | undefined;
    api_key?: string | undefined;
    public_ids?: Array<string> | undefined;
    tags?: Array<string> | undefined;
    prefixes?: Array<string> | undefined;
    type?: string | undefined;
    transformations?: string | undefined;
    mode: string;
    target_format: string;
    target_public_id?: string | undefined;
    target_asset_folder?: string | undefined;
    flatten_folders: boolean;
    flatten_transformations: boolean;
    skip_transformation_name: boolean;
    allow_missing: boolean;
    expires_at?: number | undefined;
    use_original_filename: boolean;
    async: boolean;
    notification_url?: string | undefined;
    target_tags?: Array<string> | undefined;
    keep_derived: boolean;
};
/** @internal */
export declare const GenerateArchiveRequestBody$outboundSchema: z.ZodType<GenerateArchiveRequestBody$Outbound, z.ZodTypeDef, GenerateArchiveRequestBody>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace GenerateArchiveRequestBody$ {
    /** @deprecated use `GenerateArchiveRequestBody$inboundSchema` instead. */
    const inboundSchema: z.ZodType<GenerateArchiveRequestBody, z.ZodTypeDef, unknown>;
    /** @deprecated use `GenerateArchiveRequestBody$outboundSchema` instead. */
    const outboundSchema: z.ZodType<GenerateArchiveRequestBody$Outbound, z.ZodTypeDef, GenerateArchiveRequestBody>;
    /** @deprecated use `GenerateArchiveRequestBody$Outbound` instead. */
    type Outbound = GenerateArchiveRequestBody$Outbound;
}
export declare function generateArchiveRequestBodyToJSON(generateArchiveRequestBody: GenerateArchiveRequestBody): string;
export declare function generateArchiveRequestBodyFromJSON(jsonString: string): SafeParseResult<GenerateArchiveRequestBody, SDKValidationError>;
/** @internal */
export declare const GenerateArchiveRequest$inboundSchema: z.ZodType<GenerateArchiveRequest, z.ZodTypeDef, unknown>;
/** @internal */
export type GenerateArchiveRequest$Outbound = {
    resource_type: string;
    RequestBody: GenerateArchiveRequestBody$Outbound;
};
/** @internal */
export declare const GenerateArchiveRequest$outboundSchema: z.ZodType<GenerateArchiveRequest$Outbound, z.ZodTypeDef, GenerateArchiveRequest>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace GenerateArchiveRequest$ {
    /** @deprecated use `GenerateArchiveRequest$inboundSchema` instead. */
    const inboundSchema: z.ZodType<GenerateArchiveRequest, z.ZodTypeDef, unknown>;
    /** @deprecated use `GenerateArchiveRequest$outboundSchema` instead. */
    const outboundSchema: z.ZodType<GenerateArchiveRequest$Outbound, z.ZodTypeDef, GenerateArchiveRequest>;
    /** @deprecated use `GenerateArchiveRequest$Outbound` instead. */
    type Outbound = GenerateArchiveRequest$Outbound;
}
export declare function generateArchiveRequestToJSON(generateArchiveRequest: GenerateArchiveRequest): string;
export declare function generateArchiveRequestFromJSON(jsonString: string): SafeParseResult<GenerateArchiveRequest, SDKValidationError>;
/** @internal */
export declare const GenerateArchiveResponseBody$inboundSchema: z.ZodType<GenerateArchiveResponseBody, z.ZodTypeDef, unknown>;
/** @internal */
export type GenerateArchiveResponseBody$Outbound = {
    asset_id?: string | undefined;
    public_id?: string | undefined;
    version?: number | undefined;
    version_id?: string | undefined;
    resource_type?: string | undefined;
    created_at?: string | undefined;
    tags?: Array<string> | undefined;
    bytes?: number | undefined;
    type?: string | undefined;
    url?: string | undefined;
    secure_url?: string | undefined;
    folder?: string | undefined;
    resource_count?: number | undefined;
    file_count?: number | undefined;
    asset_folder?: string | undefined;
    display_name?: string | undefined;
    missing_public_ids?: Array<string> | undefined;
    empty_tags?: Array<string> | undefined;
    empty_prefixes?: Array<string> | undefined;
};
/** @internal */
export declare const GenerateArchiveResponseBody$outboundSchema: z.ZodType<GenerateArchiveResponseBody$Outbound, z.ZodTypeDef, GenerateArchiveResponseBody>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace GenerateArchiveResponseBody$ {
    /** @deprecated use `GenerateArchiveResponseBody$inboundSchema` instead. */
    const inboundSchema: z.ZodType<GenerateArchiveResponseBody, z.ZodTypeDef, unknown>;
    /** @deprecated use `GenerateArchiveResponseBody$outboundSchema` instead. */
    const outboundSchema: z.ZodType<GenerateArchiveResponseBody$Outbound, z.ZodTypeDef, GenerateArchiveResponseBody>;
    /** @deprecated use `GenerateArchiveResponseBody$Outbound` instead. */
    type Outbound = GenerateArchiveResponseBody$Outbound;
}
export declare function generateArchiveResponseBodyToJSON(generateArchiveResponseBody: GenerateArchiveResponseBody): string;
export declare function generateArchiveResponseBodyFromJSON(jsonString: string): SafeParseResult<GenerateArchiveResponseBody, SDKValidationError>;
/** @internal */
export declare const GenerateArchiveResponse$inboundSchema: z.ZodType<GenerateArchiveResponse, z.ZodTypeDef, unknown>;
/** @internal */
export type GenerateArchiveResponse$Outbound = GenerateArchiveResponseBody$Outbound | ReadableStream<Uint8Array>;
/** @internal */
export declare const GenerateArchiveResponse$outboundSchema: z.ZodType<GenerateArchiveResponse$Outbound, z.ZodTypeDef, GenerateArchiveResponse>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace GenerateArchiveResponse$ {
    /** @deprecated use `GenerateArchiveResponse$inboundSchema` instead. */
    const inboundSchema: z.ZodType<GenerateArchiveResponse, z.ZodTypeDef, unknown>;
    /** @deprecated use `GenerateArchiveResponse$outboundSchema` instead. */
    const outboundSchema: z.ZodType<GenerateArchiveResponse$Outbound, z.ZodTypeDef, GenerateArchiveResponse>;
    /** @deprecated use `GenerateArchiveResponse$Outbound` instead. */
    type Outbound = GenerateArchiveResponse$Outbound;
}
export declare function generateArchiveResponseToJSON(generateArchiveResponse: GenerateArchiveResponse): string;
export declare function generateArchiveResponseFromJSON(jsonString: string): SafeParseResult<GenerateArchiveResponse, SDKValidationError>;
//# sourceMappingURL=generatearchive.d.ts.map