@cloudinary/asset-management-mcp 0.8.1 → 0.9.0

package/src/models/getpersonop.ts

@@ -5,7 +5,7 @@
 
 import * as z from "zod";
 import { ApiError, ApiError$zodSchema } from "./apierror.js";
-import { PersonDetails, PersonDetails$zodSchema } from "./persondetails.js";
+import { PersonResponse, PersonResponse$zodSchema } from "./personresponse.js";
 
 export type GetPersonGlobals = { cloud_name?: string | undefined };
 
@@ -25,22 +25,10 @@ export const GetPersonRequest$zodSchema: z.ZodType<GetPersonRequest> = z.object(
   },
 );
 
-/**
- * Person retrieved successfully
- */
-export type GetPersonResponseBody = { person?: PersonDetails | undefined };
-
-export const GetPersonResponseBody$zodSchema: z.ZodType<GetPersonResponseBody> =
-  z.object({
-    person: PersonDetails$zodSchema.optional().describe(
-      "Detailed information about a recognized person.",
-    ),
-  }).describe("Person retrieved successfully");
-
-export type GetPersonResponse = ApiError | GetPersonResponseBody;
+export type GetPersonResponse = ApiError | PersonResponse;
 
 export const GetPersonResponse$zodSchema: z.ZodType<GetPersonResponse> = z
   .union([
     ApiError$zodSchema,
-    z.lazy(() => GetPersonResponseBody$zodSchema),
+    PersonResponse$zodSchema,
   ]);

package/src/models/getusageop.ts

@@ -17,7 +17,9 @@ export const GetUsageGlobals$zodSchema: z.ZodType<GetUsageGlobals> = z.object({
 export type GetUsageRequest = { date?: string | undefined };
 
 export const GetUsageRequest$zodSchema: z.ZodType<GetUsageRequest> = z.object({
-  date: z.string().date().optional(),
+  date: z.string().date().describe(
+    "The date for which to retrieve usage details (YYYY-MM-DD). If not specified, returns the current usage.",
+  ).optional(),
 });
 
 export type GetUsageResponse = ApiError | UsageResponse;

package/src/models/getvideoviewsop.ts

@@ -6,6 +6,10 @@
 import * as z from "zod";
 import { ClosedEnum } from "../types/enums.js";
 import { ApiError, ApiError$zodSchema } from "./apierror.js";
+import {
+  VideoViewsResponse,
+  VideoViewsResponse$zodSchema,
+} from "./videoviewsresponse.js";
 
 export type GetVideoViewsGlobals = { cloud_name?: string | undefined };
 
@@ -66,71 +70,10 @@ export const GetVideoViewsRequest$zodSchema: z.ZodType<GetVideoViewsRequest> = z
     ),
   });
 
-export type Data = {
-  video_public_id?: string | undefined;
-  video_duration?: number | null | undefined;
-  video_transformation?: string | null | undefined;
-  video_extension?: string | null | undefined;
-  viewer_application_name?: string | null | undefined;
-  viewer_location_country_code?: string | null | undefined;
-  viewer_os_identifier?: string | null | undefined;
-  view_watch_time?: number | null | undefined;
-  view_ended_at?: string | undefined;
-};
-
-export const Data$zodSchema: z.ZodType<Data> = z.object({
-  video_duration: z.number().nullable().optional().describe(
-    "The duration in seconds of the video",
-  ),
-  video_extension: z.string().nullable().optional().describe(
-    "The file extension of the video",
-  ),
-  video_public_id: z.string().optional().describe(
-    "The full public ID of the video",
-  ),
-  video_transformation: z.string().nullable().optional().describe(
-    "The transformation applied to the video",
-  ),
-  view_ended_at: z.iso.datetime({ offset: true }).optional().describe(
-    "The date when the video view ended",
-  ),
-  view_watch_time: z.number().nullable().optional().describe(
-    "The length of time the video was viewed",
-  ),
-  viewer_application_name: z.string().nullable().optional().describe(
-    "The application used to view the video",
-  ),
-  viewer_location_country_code: z.string().nullable().optional().describe(
-    "The 2-digit ISO country code of the viewer location",
-  ),
-  viewer_os_identifier: z.string().nullable().optional().describe(
-    "The full identifier for the viewer's operating system",
-  ),
-});
-
-/**
- * List of video views retrieved
- */
-export type GetVideoViewsResponseBody = {
-  request_id?: string | undefined;
-  next_cursor?: string | undefined;
-  data?: Array<Data> | undefined;
-};
-
-export const GetVideoViewsResponseBody$zodSchema: z.ZodType<
-  GetVideoViewsResponseBody
-> = z.object({
-  data: z.array(z.lazy(() => Data$zodSchema)).optional(),
-  next_cursor: z.string().optional().describe("Cursor value for pagination"),
-  request_id: z.string().optional().describe(
-    "Unique identifier for the request",
-  ),
-}).describe("List of video views retrieved");
-
-export type GetVideoViewsResponse = ApiError | GetVideoViewsResponseBody;
+export type GetVideoViewsResponse = ApiError | VideoViewsResponse;
 
 export const GetVideoViewsResponse$zodSchema: z.ZodType<GetVideoViewsResponse> =
   z.union([
     ApiError$zodSchema,
-    z.lazy(() => GetVideoViewsResponseBody$zodSchema),
+    VideoViewsResponse$zodSchema,
   ]);

package/src/models/info.ts

@@ -8,50 +8,99 @@ import {
   AccessControlItem,
   AccessControlItem$zodSchema,
 } from "./accesscontrolitem.js";
+import {
+  ContextFullResponse,
+  ContextFullResponse$zodSchema,
+} from "./contextfullresponse.js";
+import {
+  CoordinatesResponse,
+  CoordinatesResponse$zodSchema,
+} from "./coordinatesresponse.js";
+import {
+  DeliveryTypeAll,
+  DeliveryTypeAll$zodSchema,
+} from "./deliverytypeall.js";
 
-export type InfoContext2 = {
-  key?: string | undefined;
-  value?: string | undefined;
+export type InfoModeration = {
+  kind?: string | undefined;
+  status?: string | undefined;
+  updated_at?: string | undefined;
 };
 
-export const InfoContext2$zodSchema: z.ZodType<InfoContext2> = z.object({
-  key: z.string().optional(),
-  value: z.string().optional(),
+export const InfoModeration$zodSchema: z.ZodType<InfoModeration> = z.object({
+  kind: z.string().optional(),
+  status: z.string().optional(),
+  updated_at: z.iso.datetime({ offset: true }).optional(),
 });
 
-export type InfoContext1 = { custom?: { [k: string]: any } | undefined };
+export type RelatedAsset = {};
+
+export const RelatedAsset$zodSchema: z.ZodType<RelatedAsset> = z.object({});
 
-export const InfoContext1$zodSchema: z.ZodType<InfoContext1> = z.object({
-  custom: z.record(z.string(), z.any()).optional(),
+export type LastUpdated = {
+  access_control_updated_at?: string | undefined;
+  context_updated_at?: string | undefined;
+  metadata_updated_at?: string | undefined;
+  public_id_updated_at?: string | undefined;
+  tags_updated_at?: string | undefined;
+  updated_at?: string | undefined;
+};
+
+export const LastUpdated$zodSchema: z.ZodType<LastUpdated> = z.object({
+  access_control_updated_at: z.iso.datetime({ offset: true }).optional(),
+  context_updated_at: z.iso.datetime({ offset: true }).optional(),
+  metadata_updated_at: z.iso.datetime({ offset: true }).optional(),
+  public_id_updated_at: z.iso.datetime({ offset: true }).optional(),
+  tags_updated_at: z.iso.datetime({ offset: true }).optional(),
+  updated_at: z.iso.datetime({ offset: true }).optional(),
 });
 
-/**
- * Included if 'context=true' parameter is used. Can be object with custom properties or array of key-value pairs.
- */
-export type Context = InfoContext1 | Array<InfoContext2>;
+export type Derived = {
+  transformation?: string | undefined;
+  format?: string | undefined;
+  bytes?: number | undefined;
+  id?: string | undefined;
+  url?: string | undefined;
+  secure_url?: string | undefined;
+};
 
-export const Context$zodSchema: z.ZodType<Context> = z.union([
-  z.lazy(() => InfoContext1$zodSchema),
-  z.array(z.lazy(() => InfoContext2$zodSchema)),
-]).describe(
-  "Included if 'context=true' parameter is used. Can be object with custom properties or array of key-value pairs.",
-);
+export const Derived$zodSchema: z.ZodType<Derived> = z.object({
+  bytes: z.int().optional(),
+  format: z.string().optional(),
+  id: z.string().optional(),
+  secure_url: z.string().optional(),
+  transformation: z.string().optional(),
+  url: z.string().optional(),
+});
 
-export type Moderation = {
-  kind?: string | undefined;
-  status?: string | undefined;
-  updated_at?: string | undefined;
+export type Version = {
+  version_id?: string | undefined;
+  version?: string | undefined;
+  format?: string | null | undefined;
+  size?: number | undefined;
+  time?: string | undefined;
+  restorable?: boolean | undefined;
 };
 
-export const Moderation$zodSchema: z.ZodType<Moderation> = z.object({
-  kind: z.string().optional(),
-  status: z.string().optional(),
-  updated_at: z.iso.datetime({ offset: true }).optional(),
+export const Version$zodSchema: z.ZodType<Version> = z.object({
+  format: z.string().nullable().optional(),
+  restorable: z.boolean().optional(),
+  size: z.int().optional(),
+  time: z.iso.datetime({ offset: true }).optional(),
+  version: z.string().optional(),
+  version_id: z.string().optional().describe(
+    "Hexadecimal version ID; length is a positive multiple of 32 (typically 32 or 64).",
+  ),
 });
 
-export type RelatedAsset = {};
+/**
+ * Additional asset information (visual search, recognized people, etc.)
+ */
+export type InfoInfo = {};
 
-export const RelatedAsset$zodSchema: z.ZodType<RelatedAsset> = z.object({});
+export const InfoInfo$zodSchema: z.ZodType<InfoInfo> = z.object({}).describe(
+  "Additional asset information (visual search, recognized people, etc.)",
+);
 
 export type Derivative = {
   id?: string | undefined;
@@ -62,16 +111,16 @@ export type Derivative = {
 
 export const Derivative$zodSchema: z.ZodType<Derivative> = z.object({
   id: z.string().optional().describe(
-    "The unique identifier of the derived resource",
+    "The unique identifier of the derived resource.",
   ),
   secure_url: z.string().optional().describe(
-    "The secure URL for accessing the derived resource",
+    "The secure URL for accessing the derived resource.",
   ),
   transformation: z.string().optional().describe(
-    "The transformation string that was applied",
+    "The transformation string that was applied.",
   ),
   transformation_signature: z.string().optional().describe(
-    "The unique signature of the transformation",
+    "The unique signature of the transformation.",
   ),
 });
 
@@ -85,7 +134,7 @@ export type Info = {
   format?: string | undefined;
   version?: number | undefined;
   resource_type?: string | undefined;
-  type?: string | undefined;
+  type?: DeliveryTypeAll | undefined;
   created_at?: string | undefined;
   uploaded_at?: string | undefined;
   bytes?: number | undefined;
@@ -95,11 +144,11 @@ export type Info = {
   aspect_ratio?: number | null | undefined;
   pixels?: number | null | undefined;
   tags?: Array<string> | null | undefined;
-  context?: InfoContext1 | Array<InfoContext2> | null | undefined;
+  context?: ContextFullResponse | null | undefined;
   metadata?: { [k: string]: any } | undefined;
   moderation_kind?: string | undefined;
   moderation_status?: string | undefined;
-  moderation?: Array<Moderation> | undefined;
+  moderation?: Array<InfoModeration> | undefined;
   backup?: boolean | undefined;
   url?: string | undefined;
   secure_url?: string | undefined;
@@ -111,6 +160,18 @@ export type Info = {
   resource_subtype?: string | null | undefined;
   substatus?: string | null | undefined;
   related_assets?: Array<RelatedAsset> | null | undefined;
+  last_updated?: LastUpdated | null | undefined;
+  next_cursor?: string | undefined;
+  derived?: Array<Derived> | undefined;
+  faces?: Array<Array<number>> | null | undefined;
+  coordinates?: CoordinatesResponse | null | undefined;
+  illustration_score?: number | undefined;
+  semi_transparent?: boolean | undefined;
+  grayscale?: boolean | undefined;
+  colors?: Array<Array<any>> | undefined;
+  predominant?: { [k: string]: Array<Array<any>> } | undefined;
+  versions?: Array<Version> | undefined;
+  info?: InfoInfo | undefined;
   derivatives?: Array<Derivative> | null | undefined;
 };
 
@@ -121,41 +182,57 @@ export const Info$zodSchema: z.ZodType<Info> = z.object({
   ),
   aspect_ratio: z.number().nullable().optional(),
   asset_folder: z.string().optional(),
-  asset_id: z.string().optional(),
+  asset_id: z.string().optional().describe(
+    "A 32-character hexadecimal asset ID.",
+  ),
   backup: z.boolean().optional(),
   backup_bytes: z.int().optional(),
   bytes: z.int().optional(),
-  context: z.union([
-    z.lazy(() => InfoContext1$zodSchema),
-    z.array(z.lazy(() => InfoContext2$zodSchema)),
-  ]).nullable().optional().describe(
-    "Included if 'context=true' parameter is used. Can be object with custom properties or array of key-value pairs.",
+  colors: z.array(z.array(z.any())).optional(),
+  context: ContextFullResponse$zodSchema.nullable().optional().describe(
+    "Included if 'context=true' parameter is used.",
+  ),
+  coordinates: CoordinatesResponse$zodSchema.nullable().optional().describe(
+    "Face and custom coordinate data. Included if 'coordinates=true' parameter is used.",
   ),
   created_at: z.iso.datetime({ offset: true }).optional(),
   derivatives: z.array(z.lazy(() => Derivative$zodSchema)).nullable().optional()
     .describe(
       "Included if 'derived=true' parameter is used. Null when no derivatives exist.",
     ),
+  derived: z.array(z.lazy(() => Derived$zodSchema)).optional(),
   display_name: z.string().optional(),
   duration: z.number().nullable().optional().describe(
     "Duration in seconds for video/audio assets. Null for images.",
   ),
   etag: z.string().optional(),
+  faces: z.array(z.array(z.int())).nullable().optional().describe(
+    "Detected face rectangles. Included if 'faces=true' parameter is used.",
+  ),
   filename: z.string().optional(),
   folder: z.string().optional(),
   format: z.string().optional(),
+  grayscale: z.boolean().optional(),
   height: z.int().nullable().optional(),
-  metadata: z.record(z.string(), z.any()).optional(),
-  moderation: z.array(z.lazy(() => Moderation$zodSchema)).optional().describe(
-    "Included if 'moderations=true' parameter is used.",
+  illustration_score: z.number().optional(),
+  info: z.lazy(() => InfoInfo$zodSchema).optional().describe(
+    "Additional asset information (visual search, recognized people, etc.)",
   ),
+  last_updated: z.lazy(() => LastUpdated$zodSchema).nullable().optional(),
+  metadata: z.record(z.string(), z.any()).optional(),
+  moderation: z.array(z.lazy(() => InfoModeration$zodSchema)).optional()
+    .describe("Included if 'moderations=true' parameter is used."),
   moderation_kind: z.string().optional().describe(
     "The type of moderation applied to the asset.",
   ),
   moderation_status: z.string().optional().describe(
     "The current status of the moderation process for the asset.",
   ),
+  next_cursor: z.string().optional().describe(
+    "Cursor for paginating derived assets.",
+  ),
   pixels: z.int().nullable().optional(),
+  predominant: z.record(z.string(), z.array(z.array(z.any()))).optional(),
   public_id: z.string().optional(),
   related_assets: z.array(z.lazy(() => RelatedAsset$zodSchema)).nullable()
     .optional().describe(
@@ -166,6 +243,7 @@ export const Info$zodSchema: z.ZodType<Info> = z.object({
   ),
   resource_type: z.string().optional(),
   secure_url: z.string().optional(),
+  semi_transparent: z.boolean().optional(),
   status: z.string().optional(),
   substatus: z.string().nullable().optional().describe(
     "The substatus of the resource. Null when not set.",
@@ -173,9 +251,12 @@ export const Info$zodSchema: z.ZodType<Info> = z.object({
   tags: z.array(z.string()).nullable().optional().describe(
     "Included if 'tags=true' parameter is used.",
   ),
-  type: z.string().optional(),
+  type: DeliveryTypeAll$zodSchema.optional().describe(
+    "All supported delivery types.",
+  ),
   uploaded_at: z.iso.datetime({ offset: true }).optional(),
   url: z.string().optional(),
   version: z.int().optional(),
+  versions: z.array(z.lazy(() => Version$zodSchema)).optional(),
   width: z.int().nullable().optional(),
 });

package/src/models/listimagesop.ts

@@ -5,13 +5,13 @@
 
 import * as z from "zod";
 import { ApiError, ApiError$zodSchema } from "./apierror.js";
-import { Direction, Direction$zodSchema } from "./direction.js";
-import { FieldsSpec, FieldsSpec$zodSchema } from "./fieldsspec.js";
-import { ListResponse, ListResponse$zodSchema } from "./listresponse.js";
 import {
-  ListStorageType,
-  ListStorageType$zodSchema,
-} from "./liststoragetype.js";
+  DeliveryTypeAll,
+  DeliveryTypeAll$zodSchema,
+} from "./deliverytypeall.js";
+import { DirectionEnum, DirectionEnum$zodSchema } from "./directionenum.js";
+import { Fields, Fields$zodSchema } from "./fields.js";
+import { ListResponse, ListResponse$zodSchema } from "./listresponse.js";
 
 export type ListImagesGlobals = { cloud_name?: string | undefined };
 
@@ -23,39 +23,43 @@ export const ListImagesGlobals$zodSchema: z.ZodType<ListImagesGlobals> = z
   });
 
 export type ListImagesRequest = {
-  type?: ListStorageType | undefined;
+  type?: DeliveryTypeAll | undefined;
   prefix?: string | undefined;
   public_ids?: Array<string> | undefined;
   tags?: boolean | undefined;
   next_cursor?: string | undefined;
   max_results?: number | undefined;
-  direction?: Direction | undefined;
+  direction?: DirectionEnum | undefined;
   start_at?: string | undefined;
-  fields?: Array<FieldsSpec> | undefined;
+  fields?: Fields | undefined;
 };
 
 export const ListImagesRequest$zodSchema: z.ZodType<ListImagesRequest> = z
   .object({
-    direction: Direction$zodSchema.optional().describe("Sort direction."),
-    fields: z.array(FieldsSpec$zodSchema).optional(),
+    direction: DirectionEnum$zodSchema.optional().describe(
+      "The sort direction for the results. Default is \"desc\".",
+    ),
+    fields: Fields$zodSchema.optional().describe(
+      "Additional fields to include in the response. The fields public_id and asset_id are always included.",
+    ),
     max_results: z.int().describe(
       "Maximum number of results to return (1-500).",
     ).optional(),
     next_cursor: z.string().describe("Cursor for pagination.").optional(),
     prefix: z.string().describe(
-      "Find resources with a public ID prefix. Requires the `type` parameter.",
+      "A public_id prefix. When specified, all assets with that prefix are returned.",
     ).optional(),
     public_ids: z.array(z.string()).describe(
       "An array of public IDs to return.",
     ).optional(),
     start_at: z.iso.datetime({ offset: true }).describe(
-      "Retrieve resources uploaded after this timestamp.",
-    ).optional(),
-    tags: z.boolean().describe(
-      "Whether to include the list of tag names assigned to each asset. Default: false",
+      "An ISO-8601 formatted timestamp. When specified, returns resources created since that timestamp. Supported only if neither `prefix` nor `public_ids` were passed.",
     ).optional(),
-    type: ListStorageType$zodSchema.optional().describe(
-      "The storage type of the assets. Necessary for prefix filtering.",
+    tags: z.boolean().default(false).describe(
+      "Whether to include the list of tag names assigned to each asset. Default is false.",
+    ),
+    type: DeliveryTypeAll$zodSchema.optional().describe(
+      "The delivery type to filter by. When omitted, returns assets of all delivery types.",
     ),
   });
 

package/src/models/listpeopleop.ts

@@ -6,11 +6,11 @@
 import * as z from "zod";
 import { ClosedEnum } from "../types/enums.js";
 import { ApiError, ApiError$zodSchema } from "./apierror.js";
+import { DirectionEnum, DirectionEnum$zodSchema } from "./directionenum.js";
 import {
-  ParametersDirection,
-  ParametersDirection$zodSchema,
-} from "./parametersdirection.js";
-import { PersonDetails, PersonDetails$zodSchema } from "./persondetails.js";
+  PeopleListResponse,
+  PeopleListResponse$zodSchema,
+} from "./peoplelistresponse.js";
 import { PersonStatus, PersonStatus$zodSchema } from "./personstatus.js";
 
 export type ListPeopleGlobals = { cloud_name?: string | undefined };
@@ -71,12 +71,12 @@ export type ListPeopleRequest = {
   name_prefix?: string | undefined;
   status?: PersonStatus | undefined;
   sort_by?: ListPeopleSortBy | undefined;
-  direction?: ParametersDirection | undefined;
+  direction?: DirectionEnum | undefined;
 };
 
 export const ListPeopleRequest$zodSchema: z.ZodType<ListPeopleRequest> = z
   .object({
-    direction: ParametersDirection$zodSchema.optional().describe(
+    direction: DirectionEnum$zodSchema.optional().describe(
       "The sort direction for the results. Default is \"desc\".",
     ),
     max_results: z.int().default(50).describe(
@@ -99,29 +99,10 @@ export const ListPeopleRequest$zodSchema: z.ZodType<ListPeopleRequest> = z
     ),
   });
 
-/**
- * People retrieved successfully
- */
-export type ListPeopleResponseBody = {
-  people?: Array<PersonDetails> | undefined;
-  next_cursor?: string | undefined;
-};
-
-export const ListPeopleResponseBody$zodSchema: z.ZodType<
-  ListPeopleResponseBody
-> = z.object({
-  next_cursor: z.string().optional().describe(
-    "The cursor to use for the next page of results.",
-  ),
-  people: z.array(PersonDetails$zodSchema).optional().describe(
-    "A list of recognized person objects.",
-  ),
-}).describe("People retrieved successfully");
-
-export type ListPeopleResponse = ApiError | ListPeopleResponseBody;
+export type ListPeopleResponse = ApiError | PeopleListResponse;
 
 export const ListPeopleResponse$zodSchema: z.ZodType<ListPeopleResponse> = z
   .union([
     ApiError$zodSchema,
-    z.lazy(() => ListPeopleResponseBody$zodSchema),
+    PeopleListResponse$zodSchema,
   ]);

package/src/models/listrawfilesop.ts

@@ -5,13 +5,13 @@
 
 import * as z from "zod";
 import { ApiError, ApiError$zodSchema } from "./apierror.js";
-import { Direction, Direction$zodSchema } from "./direction.js";
-import { FieldsSpec, FieldsSpec$zodSchema } from "./fieldsspec.js";
-import { ListResponse, ListResponse$zodSchema } from "./listresponse.js";
 import {
-  ListStorageType,
-  ListStorageType$zodSchema,
-} from "./liststoragetype.js";
+  DeliveryTypeAll,
+  DeliveryTypeAll$zodSchema,
+} from "./deliverytypeall.js";
+import { DirectionEnum, DirectionEnum$zodSchema } from "./directionenum.js";
+import { Fields, Fields$zodSchema } from "./fields.js";
+import { ListResponse, ListResponse$zodSchema } from "./listresponse.js";
 
 export type ListRawFilesGlobals = { cloud_name?: string | undefined };
 
@@ -23,39 +23,43 @@ export const ListRawFilesGlobals$zodSchema: z.ZodType<ListRawFilesGlobals> = z
   });
 
 export type ListRawFilesRequest = {
-  type?: ListStorageType | undefined;
+  type?: DeliveryTypeAll | undefined;
   prefix?: string | undefined;
   public_ids?: Array<string> | undefined;
   tags?: boolean | undefined;
   next_cursor?: string | undefined;
   max_results?: number | undefined;
-  direction?: Direction | undefined;
+  direction?: DirectionEnum | undefined;
   start_at?: string | undefined;
-  fields?: Array<FieldsSpec> | undefined;
+  fields?: Fields | undefined;
 };
 
 export const ListRawFilesRequest$zodSchema: z.ZodType<ListRawFilesRequest> = z
   .object({
-    direction: Direction$zodSchema.optional().describe("Sort direction."),
-    fields: z.array(FieldsSpec$zodSchema).optional(),
+    direction: DirectionEnum$zodSchema.optional().describe(
+      "The sort direction for the results. Default is \"desc\".",
+    ),
+    fields: Fields$zodSchema.optional().describe(
+      "Additional fields to include in the response. The fields public_id and asset_id are always included.",
+    ),
     max_results: z.int().describe(
       "Maximum number of results to return (1-500).",
     ).optional(),
     next_cursor: z.string().describe("Cursor for pagination.").optional(),
     prefix: z.string().describe(
-      "A public_id prefix. When specified, all assets with that prefix are returned. When using this, the `type` parameter must also be specified.",
+      "A public_id prefix. When specified, all assets with that prefix are returned.",
     ).optional(),
     public_ids: z.array(z.string()).describe(
       "An array of public IDs to return.",
     ).optional(),
     start_at: z.iso.datetime({ offset: true }).describe(
-      "An ISO-8601 formatted timestamp. When specified, assets created since that timestamp are returned.  Supported only if neither `prefix` nor `public_ids` were passed.",
-    ).optional(),
-    tags: z.boolean().describe(
-      "Whether to include the list of tag names assigned to each asset. Default: false",
+      "An ISO-8601 formatted timestamp. When specified, returns resources created since that timestamp. Supported only if neither `prefix` nor `public_ids` were passed.",
     ).optional(),
-    type: ListStorageType$zodSchema.optional().describe(
-      "The delivery type. Necessary for prefix filtering.",
+    tags: z.boolean().default(false).describe(
+      "Whether to include the list of tag names assigned to each asset. Default is false.",
+    ),
+    type: DeliveryTypeAll$zodSchema.optional().describe(
+      "The delivery type to filter by. When omitted, returns assets of all delivery types.",
     ),
   });
 

package/src/models/listresourcesbyassetfolderop.ts

@@ -5,8 +5,8 @@
 
 import * as z from "zod";
 import { ApiError, ApiError$zodSchema } from "./apierror.js";
-import { Direction, Direction$zodSchema } from "./direction.js";
-import { FieldsSpec, FieldsSpec$zodSchema } from "./fieldsspec.js";
+import { DirectionEnum, DirectionEnum$zodSchema } from "./directionenum.js";
+import { Fields, Fields$zodSchema } from "./fields.js";
 import { ListResponse, ListResponse$zodSchema } from "./listresponse.js";
 import { ResourceType, ResourceType$zodSchema } from "./resourcetype.js";
 
@@ -26,21 +26,25 @@ export type ListResourcesByAssetFolderRequest = {
   resource_type?: ResourceType | undefined;
   next_cursor?: string | undefined;
   max_results?: number | undefined;
-  direction?: Direction | undefined;
-  fields?: Array<FieldsSpec> | undefined;
+  direction?: DirectionEnum | undefined;
+  fields?: Fields | undefined;
 };
 
 export const ListResourcesByAssetFolderRequest$zodSchema: z.ZodType<
   ListResourcesByAssetFolderRequest
 > = z.object({
   asset_folder: z.string().describe("The full path of the asset folder."),
-  direction: Direction$zodSchema.optional().describe("Sort direction."),
-  fields: z.array(FieldsSpec$zodSchema).optional(),
+  direction: DirectionEnum$zodSchema.optional().describe(
+    "The sort direction for the results. Default is \"desc\".",
+  ),
+  fields: Fields$zodSchema.optional().describe(
+    "Additional fields to include in the response. The fields public_id and asset_id are always included.",
+  ),
   max_results: z.int().describe("Maximum number of results to return (1-500).")
     .optional(),
   next_cursor: z.string().describe("Cursor for pagination.").optional(),
   resource_type: ResourceType$zodSchema.optional().describe(
-    "Filter by resource type within the folder.",
+    "Resource type filter.",
   ),
 });