@zapier/zapier-sdk 0.8.3 → 0.10.0

package/dist/schemas/App.d.ts

@@ -1,26 +1,198 @@
 import { z } from "zod";
 export { FormattedItem, FormatMetadata } from "../utils/schema-utils";
-export declare const AppItemSchema: z.ZodObject<{
-    title: z.ZodString;
-    key: z.ZodString;
-    current_implementation_id: z.ZodString;
+export declare const AppItemSchema: z.ZodObject<Omit<{
+    id: z.ZodString;
+    name: z.ZodString;
+    slug: z.ZodString;
+    age_in_days: z.ZodOptional<z.ZodNumber>;
+    auth_type: z.ZodOptional<z.ZodString>;
+    banner: z.ZodOptional<z.ZodString>;
+    categories: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        slug: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: number;
+        name: string;
+        slug: string;
+    }, {
+        id: number;
+        name: string;
+        slug: string;
+    }>, "many">>;
+    images: z.ZodOptional<z.ZodObject<{
+        url_16x16: z.ZodOptional<z.ZodString>;
+        url_32x32: z.ZodOptional<z.ZodString>;
+        url_64x64: z.ZodOptional<z.ZodString>;
+        url_128x128: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url_16x16?: string | undefined;
+        url_32x32?: string | undefined;
+        url_64x64?: string | undefined;
+        url_128x128?: string | undefined;
+    }, {
+        url_16x16?: string | undefined;
+        url_32x32?: string | undefined;
+        url_64x64?: string | undefined;
+        url_128x128?: string | undefined;
+    }>>;
+    popularity: z.ZodOptional<z.ZodNumber>;
+    has_filters: z.ZodOptional<z.ZodBoolean>;
+    has_reads: z.ZodOptional<z.ZodBoolean>;
+    has_searches: z.ZodOptional<z.ZodBoolean>;
+    has_searches_or_writes: z.ZodOptional<z.ZodBoolean>;
+    has_upfront_fields: z.ZodOptional<z.ZodBoolean>;
+    has_writes: z.ZodOptional<z.ZodBoolean>;
+    is_beta: z.ZodOptional<z.ZodBoolean>;
+    is_built_in: z.ZodOptional<z.ZodBoolean>;
+    is_deprecated: z.ZodOptional<z.ZodBoolean>;
+    is_featured: z.ZodOptional<z.ZodBoolean>;
+    is_hidden: z.ZodOptional<z.ZodBoolean>;
+    is_invite: z.ZodOptional<z.ZodBoolean>;
+    is_premium: z.ZodOptional<z.ZodBoolean>;
+    is_public: z.ZodOptional<z.ZodBoolean>;
+    is_upcoming: z.ZodOptional<z.ZodBoolean>;
     version: z.ZodOptional<z.ZodString>;
+    visibility: z.ZodOptional<z.ZodString>;
+    actions: z.ZodOptional<z.ZodObject<{
+        read: z.ZodOptional<z.ZodNumber>;
+        read_bulk: z.ZodOptional<z.ZodNumber>;
+        write: z.ZodOptional<z.ZodNumber>;
+        search: z.ZodOptional<z.ZodNumber>;
+        search_or_write: z.ZodOptional<z.ZodNumber>;
+        search_and_write: z.ZodOptional<z.ZodNumber>;
+        filter: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        filter?: number | undefined;
+        read?: number | undefined;
+        read_bulk?: number | undefined;
+        write?: number | undefined;
+        search?: number | undefined;
+        search_or_write?: number | undefined;
+        search_and_write?: number | undefined;
+    }, {
+        filter?: number | undefined;
+        read?: number | undefined;
+        read_bulk?: number | undefined;
+        write?: number | undefined;
+        search?: number | undefined;
+        search_or_write?: number | undefined;
+        search_and_write?: number | undefined;
+    }>>;
     description: z.ZodOptional<z.ZodString>;
-    slug: z.ZodOptional<z.ZodString>;
+    primary_color: z.ZodOptional<z.ZodString>;
+    secondary_color: z.ZodOptional<z.ZodString>;
+    classification: z.ZodOptional<z.ZodString>;
+    api_docs_url: z.ZodOptional<z.ZodString>;
+    image: z.ZodOptional<z.ZodString>;
+}, "id" | "name"> & {
+    title: z.ZodString;
+    key: z.ZodString;
+    implementation_id: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     key: string;
     title: string;
-    current_implementation_id: string;
-    version?: string | undefined;
+    slug: string;
+    implementation_id: string;
     description?: string | undefined;
-    slug?: string | undefined;
+    is_hidden?: boolean | undefined;
+    age_in_days?: number | undefined;
+    api_docs_url?: string | undefined;
+    banner?: string | undefined;
+    categories?: {
+        id: number;
+        name: string;
+        slug: string;
+    }[] | undefined;
+    image?: string | undefined;
+    images?: {
+        url_16x16?: string | undefined;
+        url_32x32?: string | undefined;
+        url_64x64?: string | undefined;
+        url_128x128?: string | undefined;
+    } | undefined;
+    is_beta?: boolean | undefined;
+    is_built_in?: boolean | undefined;
+    is_featured?: boolean | undefined;
+    is_premium?: boolean | undefined;
+    is_public?: boolean | undefined;
+    is_upcoming?: boolean | undefined;
+    popularity?: number | undefined;
+    primary_color?: string | undefined;
+    auth_type?: string | undefined;
+    actions?: {
+        filter?: number | undefined;
+        read?: number | undefined;
+        read_bulk?: number | undefined;
+        write?: number | undefined;
+        search?: number | undefined;
+        search_or_write?: number | undefined;
+        search_and_write?: number | undefined;
+    } | undefined;
+    is_deprecated?: boolean | undefined;
+    secondary_color?: string | undefined;
+    has_filters?: boolean | undefined;
+    has_reads?: boolean | undefined;
+    has_searches?: boolean | undefined;
+    has_searches_or_writes?: boolean | undefined;
+    has_upfront_fields?: boolean | undefined;
+    has_writes?: boolean | undefined;
+    is_invite?: boolean | undefined;
+    version?: string | undefined;
+    visibility?: string | undefined;
+    classification?: string | undefined;
 }, {
     key: string;
     title: string;
-    current_implementation_id: string;
-    version?: string | undefined;
+    slug: string;
+    implementation_id: string;
     description?: string | undefined;
-    slug?: string | undefined;
+    is_hidden?: boolean | undefined;
+    age_in_days?: number | undefined;
+    api_docs_url?: string | undefined;
+    banner?: string | undefined;
+    categories?: {
+        id: number;
+        name: string;
+        slug: string;
+    }[] | undefined;
+    image?: string | undefined;
+    images?: {
+        url_16x16?: string | undefined;
+        url_32x32?: string | undefined;
+        url_64x64?: string | undefined;
+        url_128x128?: string | undefined;
+    } | undefined;
+    is_beta?: boolean | undefined;
+    is_built_in?: boolean | undefined;
+    is_featured?: boolean | undefined;
+    is_premium?: boolean | undefined;
+    is_public?: boolean | undefined;
+    is_upcoming?: boolean | undefined;
+    popularity?: number | undefined;
+    primary_color?: string | undefined;
+    auth_type?: string | undefined;
+    actions?: {
+        filter?: number | undefined;
+        read?: number | undefined;
+        read_bulk?: number | undefined;
+        write?: number | undefined;
+        search?: number | undefined;
+        search_or_write?: number | undefined;
+        search_and_write?: number | undefined;
+    } | undefined;
+    is_deprecated?: boolean | undefined;
+    secondary_color?: string | undefined;
+    has_filters?: boolean | undefined;
+    has_reads?: boolean | undefined;
+    has_searches?: boolean | undefined;
+    has_searches_or_writes?: boolean | undefined;
+    has_upfront_fields?: boolean | undefined;
+    has_writes?: boolean | undefined;
+    is_invite?: boolean | undefined;
+    version?: string | undefined;
+    visibility?: string | undefined;
+    classification?: string | undefined;
 }>;
 export type AppItem = z.infer<typeof AppItemSchema>;
 //# sourceMappingURL=App.d.ts.map

package/dist/schemas/App.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"App.d.ts","sourceRoot":"","sources":["../../src/schemas/App.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAMtE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;EAmBzB,CAAC;AAMF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}
+{"version":3,"file":"App.d.ts","sourceRoot":"","sources":["../../src/schemas/App.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAMtE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBzB,CAAC;AAMF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/schemas/App.js

@@ -1,21 +1,19 @@
 import { z } from "zod";
 import { withFormatter } from "../utils/schema-utils";
+import { ImplementationMetaSchema } from "../api/schemas";
 // ============================================================================
-// App Item Schema (extends API schema with computed fields and formatting)
+// App Item Schema (extends ImplementationMetaSchema with transformed fields)
 // ============================================================================
-export const AppItemSchema = withFormatter(z.object({
-    // Essential properties only
+export const AppItemSchema = withFormatter(ImplementationMetaSchema.omit({ name: true, id: true }).extend({
     title: z.string(), // Mapped from name
-    key: z.string(), // Mapped from selected_api
-    current_implementation_id: z.string(), // From id, keeps the full version
-    version: z.string().optional(), // Extracted from implementation ID
-    description: z.string().optional(),
-    slug: z.string().optional(),
+    key: z.string(), // Extracted from id (base part without version)
+    implementation_id: z.string(), // Mapped from id (full versioned ID)
 }), {
     format: (item) => {
         return {
             title: item.title,
-            subtitle: `(${item.key})`,
+            key: item.key,
+            description: item.description,
             details: [],
         };
     },

package/dist/schemas/Auth.d.ts

@@ -28,15 +28,13 @@ export declare const AuthenticationItemSchema: z.ZodObject<Omit<{
     version: z.ZodOptional<z.ZodString>;
     user_id: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    date: string;
     id: number;
+    date: string;
     account_id: number;
     is_invite_only: boolean;
     is_private: boolean;
     shared_with_all: boolean;
     url?: string | undefined;
-    title?: string | null | undefined;
-    version?: string | undefined;
     label?: string | null | undefined;
     permissions?: Record<string, boolean> | undefined;
     lastchanged?: string | undefined;
@@ -45,23 +43,23 @@ export declare const AuthenticationItemSchema: z.ZodObject<Omit<{
     is_shared?: string | undefined;
     marked_stale_at?: string | null | undefined;
     identifier?: string | null | undefined;
+    title?: string | null | undefined;
     groups?: string | undefined;
     members?: string | undefined;
     user_id?: number | undefined;
+    version?: string | undefined;
     implementation_id?: string | undefined;
     is_expired?: string | undefined;
     expired_at?: string | null | undefined;
     app_key?: string | undefined;
 }, {
-    date: string;
     id: number;
+    date: string;
     account_id: number;
     is_invite_only: boolean;
     is_private: boolean;
     shared_with_all: boolean;
     url?: string | undefined;
-    title?: string | null | undefined;
-    version?: string | undefined;
     label?: string | null | undefined;
     permissions?: Record<string, boolean> | undefined;
     lastchanged?: string | undefined;
@@ -70,9 +68,11 @@ export declare const AuthenticationItemSchema: z.ZodObject<Omit<{
     is_shared?: string | undefined;
     marked_stale_at?: string | null | undefined;
     identifier?: string | null | undefined;
+    title?: string | null | undefined;
     groups?: string | undefined;
     members?: string | undefined;
     user_id?: number | undefined;
+    version?: string | undefined;
     implementation_id?: string | undefined;
     is_expired?: string | undefined;
     expired_at?: string | null | undefined;
@@ -107,15 +107,13 @@ export declare const AuthItemSchema: z.ZodObject<Omit<{
     version: z.ZodOptional<z.ZodString>;
     user_id: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    date: string;
     id: number;
+    date: string;
     account_id: number;
     is_invite_only: boolean;
     is_private: boolean;
     shared_with_all: boolean;
     url?: string | undefined;
-    title?: string | null | undefined;
-    version?: string | undefined;
     label?: string | null | undefined;
     permissions?: Record<string, boolean> | undefined;
     lastchanged?: string | undefined;
@@ -124,23 +122,23 @@ export declare const AuthItemSchema: z.ZodObject<Omit<{
     is_shared?: string | undefined;
     marked_stale_at?: string | null | undefined;
     identifier?: string | null | undefined;
+    title?: string | null | undefined;
     groups?: string | undefined;
     members?: string | undefined;
     user_id?: number | undefined;
+    version?: string | undefined;
     implementation_id?: string | undefined;
     is_expired?: string | undefined;
     expired_at?: string | null | undefined;
     app_key?: string | undefined;
 }, {
-    date: string;
     id: number;
+    date: string;
     account_id: number;
     is_invite_only: boolean;
     is_private: boolean;
     shared_with_all: boolean;
     url?: string | undefined;
-    title?: string | null | undefined;
-    version?: string | undefined;
     label?: string | null | undefined;
     permissions?: Record<string, boolean> | undefined;
     lastchanged?: string | undefined;
@@ -149,9 +147,11 @@ export declare const AuthItemSchema: z.ZodObject<Omit<{
     is_shared?: string | undefined;
     marked_stale_at?: string | null | undefined;
     identifier?: string | null | undefined;
+    title?: string | null | undefined;
     groups?: string | undefined;
     members?: string | undefined;
     user_id?: number | undefined;
+    version?: string | undefined;
     implementation_id?: string | undefined;
     is_expired?: string | undefined;
     expired_at?: string | null | undefined;

package/dist/schemas/Auth.js

@@ -32,7 +32,7 @@ export const AuthenticationItemSchema = withFormatter(AuthenticationSchema.omit(
         }
         return {
             title: item.title || `Authentication ${item.id}`,
-            subtitle: `(ID: ${item.id})`,
+            id: item.id?.toString(),
             details,
         };
     },

package/dist/schemas/Field.d.ts

@@ -1,47 +1,6 @@
 import { z } from "zod";
-export declare const InputFieldItemSchema: z.ZodObject<Omit<{
+export declare const InputFieldItemSchema: z.ZodObject<{
     key: z.ZodString;
-    alters_custom_fields: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
-    capabilities: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    choices: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        key: z.ZodOptional<z.ZodString>;
-        label: z.ZodOptional<z.ZodString>;
-        sample: z.ZodOptional<z.ZodString>;
-        value: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        value?: string | undefined;
-        key?: string | undefined;
-        label?: string | undefined;
-        sample?: string | undefined;
-    }, {
-        value?: string | undefined;
-        key?: string | undefined;
-        label?: string | undefined;
-        sample?: string | undefined;
-    }>, "many">>;
-    computed: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
-    custom_field: z.ZodOptional<z.ZodBoolean>;
-    default: z.ZodOptional<z.ZodString>;
-    depends_on: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    format: z.ZodOptional<z.ZodLiteral<"SELECT">>;
-    from_search: z.ZodOptional<z.ZodBoolean>;
-    from_write: z.ZodOptional<z.ZodBoolean>;
-    help_text: z.ZodOptional<z.ZodString>;
-    help_text_html: z.ZodOptional<z.ZodString>;
-    input_format: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    label: z.ZodOptional<z.ZodString>;
-    language: z.ZodOptional<z.ZodString>;
-    parent_key: z.ZodOptional<z.ZodString>;
-    placeholder: z.ZodOptional<z.ZodString>;
-    prefill: z.ZodOptional<z.ZodString>;
-    required: z.ZodOptional<z.ZodBoolean>;
-    searchfill: z.ZodOptional<z.ZodString>;
-    send_in_json: z.ZodOptional<z.ZodBoolean>;
-    regex: z.ZodOptional<z.ZodString>;
-    type: z.ZodOptional<z.ZodEnum<["integer", "string", "text", "datetime", "boolean", "file", "decimal", "copy", "password", "dict", "code", "filter", "json"]>>;
-    list: z.ZodOptional<z.ZodBoolean>;
-}, "depends_on" | "format" | "placeholder" | "required"> & {
-    id: z.ZodString;
     default_value: z.ZodString;
     depends_on: z.ZodArray<z.ZodString, "many">;
     description: z.ZodString;
@@ -60,81 +19,29 @@ export declare const InputFieldItemSchema: z.ZodObject<Omit<{
     }>>;
 }, "strip", z.ZodTypeAny, {
     key: string;
-    title: string;
-    description: string;
     depends_on: string[];
     placeholder: string;
-    id: string;
+    description: string;
+    title: string;
     default_value: string;
     invalidates_input_fields: boolean;
     is_required: boolean;
     value_type: string;
-    default?: string | undefined;
-    type?: "string" | "boolean" | "text" | "password" | "code" | "filter" | "integer" | "datetime" | "file" | "decimal" | "copy" | "dict" | "json" | undefined;
-    label?: string | undefined;
-    alters_custom_fields?: boolean | null | undefined;
-    capabilities?: string[] | undefined;
-    choices?: {
-        value?: string | undefined;
-        key?: string | undefined;
-        label?: string | undefined;
-        sample?: string | undefined;
-    }[] | undefined;
-    computed?: boolean | null | undefined;
-    custom_field?: boolean | undefined;
     format?: string | undefined;
-    from_search?: boolean | undefined;
-    from_write?: boolean | undefined;
-    help_text?: string | undefined;
-    help_text_html?: string | undefined;
-    input_format?: string[] | undefined;
-    language?: string | undefined;
-    parent_key?: string | undefined;
-    prefill?: string | undefined;
-    searchfill?: string | undefined;
-    send_in_json?: boolean | undefined;
-    regex?: string | undefined;
-    list?: boolean | undefined;
     items?: {
         type: string;
     } | undefined;
 }, {
     key: string;
-    title: string;
-    description: string;
     depends_on: string[];
     placeholder: string;
-    id: string;
+    description: string;
+    title: string;
     default_value: string;
     invalidates_input_fields: boolean;
     is_required: boolean;
     value_type: string;
-    default?: string | undefined;
-    type?: "string" | "boolean" | "text" | "password" | "code" | "filter" | "integer" | "datetime" | "file" | "decimal" | "copy" | "dict" | "json" | undefined;
-    label?: string | undefined;
-    alters_custom_fields?: boolean | null | undefined;
-    capabilities?: string[] | undefined;
-    choices?: {
-        value?: string | undefined;
-        key?: string | undefined;
-        label?: string | undefined;
-        sample?: string | undefined;
-    }[] | undefined;
-    computed?: boolean | null | undefined;
-    custom_field?: boolean | undefined;
     format?: string | undefined;
-    from_search?: boolean | undefined;
-    from_write?: boolean | undefined;
-    help_text?: string | undefined;
-    help_text_html?: string | undefined;
-    input_format?: string[] | undefined;
-    language?: string | undefined;
-    parent_key?: string | undefined;
-    prefill?: string | undefined;
-    searchfill?: string | undefined;
-    send_in_json?: boolean | undefined;
-    regex?: string | undefined;
-    list?: boolean | undefined;
     items?: {
         type: string;
     } | undefined;

package/dist/schemas/Field.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Field.d.ts","sourceRoot":"","sources":["../../src/schemas/Field.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkHhC,CAAC;AAMF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAGlE,MAAM,MAAM,SAAS,GAAG,cAAc,CAAC"}
+{"version":3,"file":"Field.d.ts","sourceRoot":"","sources":["../../src/schemas/Field.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkFhC,CAAC;AAMF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAGlE,MAAM,MAAM,SAAS,GAAG,cAAc,CAAC"}

package/dist/schemas/Field.js

@@ -1,47 +1,44 @@
 import { z } from "zod";
 import { withFormatter } from "../utils/schema-utils";
-import { NeedSchema } from "../api/schemas";
 // ============================================================================
 // Input Field Item Schema (extends API Need schema with computed fields and formatting)
 // ============================================================================
-export const InputFieldItemSchema = withFormatter(NeedSchema.omit({
-    depends_on: true,
-    placeholder: true,
-    required: true,
-    format: true,
-}).extend({
-    id: z.string(), // Mapped from 'key'
+export const InputFieldItemSchema = withFormatter(z.object({
+    key: z.string(), // From need.key
     default_value: z.string(), // Mapped from 'default' with fallback to ""
-    depends_on: z.array(z.string()), // Override: mapped from 'depends_on' with fallback to []
+    depends_on: z.array(z.string()), // Mapped from 'depends_on' with fallback to []
     description: z.string(), // Mapped from 'help_text' with fallback to ""
     invalidates_input_fields: z.boolean(), // Mapped from 'alters_custom_fields' with fallback to false
-    is_required: z.boolean(), // Override: mapped from 'required' with fallback to false
-    placeholder: z.string(), // Override: mapped from 'placeholder' with fallback to ""
+    is_required: z.boolean(), // Mapped from 'required' with fallback to false
+    placeholder: z.string(), // Mapped from 'placeholder' with fallback to ""
     title: z.string(), // Mapped from 'label' with fallback to ""
     value_type: z.string(), // Computed from InputFieldType enum
-    format: z.string().optional(), // Override: computed from InputFieldFormat enum (optional)
+    format: z.string().optional(), // Computed from InputFieldFormat enum (optional)
     items: z.object({ type: z.string() }).optional(), // Computed from ItemsType enum (optional, only for arrays)
 }), {
     format: (item) => {
         const details = [];
         // Type and required status
         const typeInfo = [
-            item.type && `Type: ${item.type}`,
-            `Required: ${item.required ? "Yes" : "No"}`,
+            item.value_type && `Type: ${item.value_type}`,
+            `Required: ${item.is_required ? "Yes" : "No"}`,
         ]
             .filter(Boolean)
             .join(" | ");
         if (typeInfo) {
             details.push({ text: typeInfo, style: "dim" });
         }
-        // Help text
-        if (item.helpText) {
-            details.push({ text: item.helpText, style: "normal" });
+        // Description
+        if (item.description) {
+            details.push({
+                text: item.description,
+                style: "normal",
+            });
         }
         // Default value
-        if (item.default !== undefined) {
+        if (item.default_value) {
             details.push({
-                text: `Default: ${item.default}`,
+                text: `Default: ${item.default_value}`,
                 style: "accent",
             });
         }
@@ -52,20 +49,10 @@ export const InputFieldItemSchema = withFormatter(NeedSchema.omit({
                 style: "dim",
             });
         }
-        // Choices
-        if (item.choices && item.choices.length > 0) {
-            const choiceText = item.choices.length <= 3
-                ? `Choices: ${item.choices.map((c) => c.label || c.value).join(", ")}`
-                : `Choices: ${item.choices
-                    .slice(0, 3)
-                    .map((c) => c.label || c.value)
-                    .join(", ")} (+${item.choices.length - 3} more)`;
-            details.push({ text: choiceText, style: "accent" });
-        }
         // Dependencies
-        if (item.dependsOn && item.dependsOn.length > 0) {
+        if (item.depends_on && item.depends_on.length > 0) {
             details.push({
-                text: `Depends on: ${item.dependsOn.join(", ")}`,
+                text: `Depends on: ${item.depends_on.join(", ")}`,
                 style: "warning",
             });
         }
@@ -73,32 +60,17 @@ export const InputFieldItemSchema = withFormatter(NeedSchema.omit({
         if (item.format) {
             details.push({ text: `Format: ${item.format}`, style: "dim" });
         }
-        // Input format
-        if (item.inputFormat && item.inputFormat.length > 0) {
+        // Items type for arrays
+        if (item.items) {
             details.push({
-                text: `Input formats: ${item.inputFormat.join(", ")}`,
+                text: `Items type: ${item.items.type}`,
                 style: "dim",
             });
         }
-        // Special field flags
-        const flags = [];
-        if (item.computed)
-            flags.push("computed");
-        if (item.customField)
-            flags.push("custom");
-        if (flags.length > 0) {
-            details.push({
-                text: `Flags: ${flags.join(", ")}`,
-                style: "success",
-            });
-        }
-        // Backwards compatibility: show description if no helpText
-        if (item.description && !item.helpText) {
-            details.push({ text: item.description, style: "normal" });
-        }
         return {
-            title: item.label || item.name || item.key,
-            subtitle: `(${item.key})`,
+            title: item.title || item.key,
+            key: item.key,
+            description: item.description,
             details,
         };
     },

package/dist/schemas/Run.d.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+export declare const ActionResultItemSchema: z.ZodUnknown;
+//# sourceMappingURL=Run.d.ts.map

package/dist/schemas/Run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Run.d.ts","sourceRoot":"","sources":["../../src/schemas/Run.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAoCxB,eAAO,MAAM,sBAAsB,cAGlC,CAAC"}

package/dist/schemas/Run.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { withFormatter } from "../utils/schema-utils";
+// Type guard to safely access object properties
+function getStringProperty(obj, key) {
+    if (typeof obj === "object" && obj !== null && key in obj) {
+        const value = obj[key];
+        return typeof value === "string" ? value : undefined;
+    }
+    return undefined;
+}
+// Formatter for action results - handles any data structure
+function formatActionResult(item) {
+    // Try to extract common fields for structured display
+    const obj = typeof item === "object" && item !== null ? item : {};
+    // Try common title fields
+    const title = getStringProperty(obj, "title") ||
+        getStringProperty(obj, "name") ||
+        getStringProperty(obj, "label") ||
+        getStringProperty(obj, "subject") ||
+        "Action Result";
+    return {
+        title,
+        id: getStringProperty(obj, "id"),
+        key: getStringProperty(obj, "key"),
+        description: getStringProperty(obj, "description"),
+        data: item, // Let formatJsonOutput handle the JSON rendering
+        details: [], // Not used when data is provided
+    };
+}
+// Flexible schema for action results - can be any object
+export const ActionResultItemSchema = withFormatter(z.unknown().describe("Action execution result"), { format: formatActionResult });