@zapier/zapier-sdk 0.9.0 → 0.11.0

package/dist/resolvers/authenticationId.js

@@ -2,15 +2,17 @@ export const authenticationIdResolver = {
     type: "dynamic",
     depends: ["appKey"],
     fetch: async (sdk, resolvedParams) => {
-        const myAuths = await sdk.listAuthentications({
-            appKey: resolvedParams.appKey,
+        const listOptions = {
             maxItems: 1000,
+        };
+        if (resolvedParams.appKey) {
+            listOptions.appKey = resolvedParams.appKey;
+        }
+        const myAuths = await sdk.listAuthentications({
+            ...listOptions,
             owner: "me",
         });
-        const allAuths = await sdk.listAuthentications({
-            appKey: resolvedParams.appKey,
-            maxItems: 1000,
-        });
+        const allAuths = await sdk.listAuthentications(listOptions);
         // Filter out myAuths from allAuths
         const otherAuths = allAuths.data.filter((auth) => !myAuths.data.some((myAuth) => myAuth.id === auth.id));
         return [...myAuths.data, ...otherAuths];
@@ -18,7 +20,9 @@ export const authenticationIdResolver = {
     prompt: (auths, params) => ({
         type: "list",
         name: "authenticationId",
-        message: `Select authentication for ${params.appKey}:`,
+        message: params.appKey
+            ? `Select authentication for ${params.appKey}:`
+            : "Select authentication:",
         choices: [
             ...auths.map((auth) => ({
                 name: `${auth.title || auth.label || "Authentication"} (ID: ${auth.id})`,
@@ -31,3 +35,8 @@ export const authenticationIdResolver = {
         ],
     }),
 };
+// Generic version without appKey dependency
+export const authenticationIdGenericResolver = {
+    ...authenticationIdResolver,
+    depends: [],
+};

package/dist/resolvers/index.d.ts

@@ -1,40 +1,8 @@
-export declare const resolverRegistry: {
-    readonly appKey: import("./appKey").AppKeyResolver;
-    readonly actionType: import("./actionType").ActionTypeResolver;
-    readonly actionKey: import("./actionKey").ActionKeyResolver;
-    readonly authenticationId: import("./authenticationId").AuthenticationIdResolver;
-    readonly inputs: import("./inputs").InputsResolver;
-};
-export type ResolverName = keyof typeof resolverRegistry;
-export type ResolverType = (typeof resolverRegistry)[ResolverName];
-/**
- * Get a resolver by name
- */
-export declare function getResolver(name: string): ResolverType | undefined;
-/**
- * Get all resolvers for a list of missing parameters
- */
-export declare function getResolversForMissingParams(missingParams: string[]): Record<string, ResolverType>;
-/**
- * Check if a parameter has a resolver
- */
-export declare function hasResolver(paramName: string): boolean;
-/**
- * Get all parameter names that have resolvers
- */
-export declare function getResolvableParams(): string[];
-/**
- * Resolve dependency chain for a parameter
- * Returns parameters in the order they need to be resolved
- */
-export declare function getResolutionOrder(paramName: string, resolved?: Set<string>): string[];
-/**
- * Get resolution order for multiple parameters
- */
-export declare function getResolutionOrderForParams(paramNames: string[]): string[];
 export { appKeyResolver } from "./appKey";
 export { actionTypeResolver } from "./actionType";
 export { actionKeyResolver } from "./actionKey";
-export { authenticationIdResolver } from "./authenticationId";
+export { authenticationIdResolver, authenticationIdGenericResolver, } from "./authenticationId";
 export { inputsResolver } from "./inputs";
+export { inputFieldKeyResolver } from "./inputFieldKey";
+export { inputsAllOptionalResolver } from "./inputs";
 //# sourceMappingURL=index.d.ts.map

package/dist/resolvers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resolvers/index.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,gBAAgB;;;;;;CAMnB,CAAC;AAGX,MAAM,MAAM,YAAY,GAAG,MAAM,OAAO,gBAAgB,CAAC;AACzD,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,YAAY,CAAC,CAAC;AAInE;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAElE;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAC1C,aAAa,EAAE,MAAM,EAAE,GACtB,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAW9B;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,EAAE,CAE9C;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,EACjB,QAAQ,GAAE,GAAG,CAAC,MAAM,CAAa,GAChC,MAAM,EAAE,CAuBV;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAc1E;AAGD,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resolvers/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EACL,wBAAwB,EACxB,+BAA+B,GAChC,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAC"}

package/dist/resolvers/index.js

@@ -1,91 +1,8 @@
-import { appKeyResolver } from "./appKey";
-import { actionTypeResolver } from "./actionType";
-import { actionKeyResolver } from "./actionKey";
-import { authenticationIdResolver } from "./authenticationId";
-import { inputsResolver } from "./inputs";
-// Centralized resolver registry
-export const resolverRegistry = {
-    appKey: appKeyResolver,
-    actionType: actionTypeResolver,
-    actionKey: actionKeyResolver,
-    authenticationId: authenticationIdResolver,
-    inputs: inputsResolver,
-};
-// Utility functions for working with resolvers
-/**
- * Get a resolver by name
- */
-export function getResolver(name) {
-    return resolverRegistry[name];
-}
-/**
- * Get all resolvers for a list of missing parameters
- */
-export function getResolversForMissingParams(missingParams) {
-    const resolvers = {};
-    for (const param of missingParams) {
-        const resolver = resolverRegistry[param];
-        if (resolver) {
-            resolvers[param] = resolver;
-        }
-    }
-    return resolvers;
-}
-/**
- * Check if a parameter has a resolver
- */
-export function hasResolver(paramName) {
-    return paramName in resolverRegistry;
-}
-/**
- * Get all parameter names that have resolvers
- */
-export function getResolvableParams() {
-    return Object.keys(resolverRegistry);
-}
-/**
- * Resolve dependency chain for a parameter
- * Returns parameters in the order they need to be resolved
- */
-export function getResolutionOrder(paramName, resolved = new Set()) {
-    const resolver = getResolver(paramName);
-    if (!resolver || resolver.type === "static") {
-        return [paramName];
-    }
-    const order = [];
-    if ("depends" in resolver && resolver.depends) {
-        for (const dependency of resolver.depends) {
-            if (!resolved.has(dependency)) {
-                order.push(...getResolutionOrder(dependency, resolved));
-                resolved.add(dependency);
-            }
-        }
-    }
-    if (!resolved.has(paramName)) {
-        order.push(paramName);
-        resolved.add(paramName);
-    }
-    return order;
-}
-/**
- * Get resolution order for multiple parameters
- */
-export function getResolutionOrderForParams(paramNames) {
-    const resolved = new Set();
-    const order = [];
-    for (const paramName of paramNames) {
-        const paramOrder = getResolutionOrder(paramName, resolved);
-        for (const param of paramOrder) {
-            if (!order.includes(param)) {
-                order.push(param);
-            }
-        }
-    }
-    return order;
-}
-// Re-export individual resolvers for direct access if needed
+// Re-export individual resolvers for plugin use
 export { appKeyResolver } from "./appKey";
 export { actionTypeResolver } from "./actionType";
 export { actionKeyResolver } from "./actionKey";
-export { authenticationIdResolver } from "./authenticationId";
+export { authenticationIdResolver, authenticationIdGenericResolver, } from "./authenticationId";
 export { inputsResolver } from "./inputs";
+export { inputFieldKeyResolver } from "./inputFieldKey";
+export { inputsAllOptionalResolver } from "./inputs";

package/dist/resolvers/inputFieldKey.d.ts

@@ -0,0 +1,11 @@
+import type { DynamicResolver } from "../utils/schema-utils";
+import type { InputFieldItem } from "../schemas/Field";
+import type { ActionTypeProperty } from "../types/properties";
+export declare const inputFieldKeyResolver: DynamicResolver<InputFieldItem, {
+    appKey: string;
+    actionKey: string;
+    actionType: ActionTypeProperty;
+    authenticationId: number;
+    inputs?: Record<string, unknown>;
+}>;
+//# sourceMappingURL=inputFieldKey.d.ts.map

package/dist/resolvers/inputFieldKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inputFieldKey.d.ts","sourceRoot":"","sources":["../../src/resolvers/inputFieldKey.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAiC9D,eAAO,MAAM,qBAAqB,EAAE,eAAe,CACjD,cAAc,EACd;IACE,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,kBAAkB,CAAC;IAC/B,gBAAgB,EAAE,MAAM,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC,CA0BF,CAAC"}

package/dist/resolvers/inputFieldKey.js

@@ -0,0 +1,47 @@
+/**
+ * Helper function to flatten fieldsets into a flat array of input fields.
+ * Used to extract all input fields from nested fieldset structure for field selection.
+ */
+function flattenRootFieldset(rootFieldset) {
+    const result = [];
+    function processItem(item) {
+        if (item.type === "input_field") {
+            result.push(item);
+        }
+        else if (item.type === "fieldset") {
+            // Recursively process fields in the fieldset
+            for (const field of item.fields) {
+                processItem(field);
+            }
+        }
+        // Skip info fields as they're not input fields
+    }
+    for (const item of rootFieldset) {
+        processItem(item);
+    }
+    return result;
+}
+export const inputFieldKeyResolver = {
+    type: "dynamic",
+    depends: ["appKey", "actionKey", "actionType", "authenticationId"],
+    fetch: async (sdk, resolvedParams) => {
+        const fieldsResponse = await sdk.listInputFields({
+            appKey: resolvedParams.appKey,
+            actionKey: resolvedParams.actionKey,
+            actionType: resolvedParams.actionType,
+            authenticationId: resolvedParams.authenticationId,
+            inputs: resolvedParams.inputs, // Pass along currently resolved inputs
+        });
+        // Flatten the fieldset structure for field selection
+        return flattenRootFieldset(fieldsResponse.data);
+    },
+    prompt: (fields) => ({
+        type: "list",
+        name: "inputFieldKey",
+        message: "Select input field:",
+        choices: fields.map((field) => ({
+            name: `${field.title || field.key} - ${field.value_type || "No type"} ${field.is_required ? "(required)" : "(optional)"}`,
+            value: field.key,
+        })),
+    }),
+};

package/dist/resolvers/inputs.d.ts

@@ -1,8 +1,17 @@
-import type { ZapierSdk } from "../types/sdk";
-export interface InputsResolver {
+import type { ActionTypeProperty } from "../types/properties";
+import type { RootFieldItem } from "../types/domain";
+type InputsResolver = {
     type: "fields";
     depends: readonly string[];
-    fetch: (sdk: ZapierSdk, resolvedParams: Record<string, any>) => Promise<any[]>;
-}
+    fetch: (sdk: any, resolvedParams: {
+        appKey: string;
+        actionKey: string;
+        actionType: ActionTypeProperty;
+        authenticationId: number;
+        inputs?: Record<string, unknown>;
+    }) => Promise<RootFieldItem[]>;
+};
 export declare const inputsResolver: InputsResolver;
+export declare const inputsAllOptionalResolver: InputsResolver;
+export {};
 //# sourceMappingURL=inputs.d.ts.map

package/dist/resolvers/inputs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inputs.d.ts","sourceRoot":"","sources":["../../src/resolvers/inputs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,KAAK,EAAE,CACL,GAAG,EAAE,SAAS,EACd,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAChC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;CACrB;AAED,eAAO,MAAM,cAAc,EAAE,cAa5B,CAAC"}
+{"version":3,"file":"inputs.d.ts","sourceRoot":"","sources":["../../src/resolvers/inputs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAuBrD,KAAK,cAAc,GAAG;IACpB,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,KAAK,EAAE,CACL,GAAG,EAAE,GAAG,EACR,cAAc,EAAE;QACd,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,EAAE,MAAM,CAAC;QAClB,UAAU,EAAE,kBAAkB,CAAC;QAC/B,gBAAgB,EAAE,MAAM,CAAC;QACzB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KAClC,KACE,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC;CAC/B,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,cAa5B,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,cAcvC,CAAC"}

package/dist/resolvers/inputs.js

@@ -1,3 +1,24 @@
+// Helper function to recursively make all input fields optional while preserving structure
+function makeFieldsOptional(fields) {
+    return fields.map((field) => {
+        if (field.type === "input_field") {
+            return {
+                ...field,
+                is_required: false,
+            };
+        }
+        else if (field.type === "fieldset") {
+            return {
+                ...field,
+                fields: makeFieldsOptional(field.fields),
+            };
+        }
+        else {
+            // Info fields remain unchanged
+            return field;
+        }
+    });
+}
 export const inputsResolver = {
     type: "fields",
     depends: ["appKey", "actionKey", "actionType", "authenticationId"],
@@ -12,3 +33,18 @@ export const inputsResolver = {
         return fieldsResponse.data;
     },
 };
+export const inputsAllOptionalResolver = {
+    type: "fields",
+    depends: ["appKey", "actionKey", "actionType", "authenticationId"],
+    fetch: async (sdk, resolvedParams) => {
+        const fieldsResponse = await sdk.listInputFields({
+            appKey: resolvedParams.appKey,
+            actionKey: resolvedParams.actionKey,
+            actionType: resolvedParams.actionType,
+            authenticationId: resolvedParams.authenticationId,
+            inputs: resolvedParams.inputs, // Pass along currently resolved inputs
+        });
+        // Return nested structure with all fields marked as optional.
+        return makeFieldsOptional(fieldsResponse.data);
+    },
+};

package/dist/schemas/Action.d.ts

@@ -53,7 +53,7 @@ export declare const ActionItemSchema: z.ZodObject<Omit<{
     }, "strip", z.ZodTypeAny, {
         key: string;
         default?: string | undefined;
-        type?: "string" | "boolean" | "text" | "password" | "code" | "filter" | "integer" | "datetime" | "file" | "decimal" | "copy" | "dict" | "json" | undefined;
+        type?: "string" | "boolean" | "filter" | "code" | "integer" | "text" | "datetime" | "file" | "decimal" | "copy" | "password" | "dict" | "json" | undefined;
         label?: string | undefined;
         alters_custom_fields?: boolean | null | undefined;
         capabilities?: string[] | undefined;
@@ -84,7 +84,7 @@ export declare const ActionItemSchema: z.ZodObject<Omit<{
     }, {
         key: string;
         default?: string | undefined;
-        type?: "string" | "boolean" | "text" | "password" | "code" | "filter" | "integer" | "datetime" | "file" | "decimal" | "copy" | "dict" | "json" | undefined;
+        type?: "string" | "boolean" | "filter" | "code" | "integer" | "text" | "datetime" | "file" | "decimal" | "copy" | "password" | "dict" | "json" | undefined;
         label?: string | undefined;
         alters_custom_fields?: boolean | null | undefined;
         capabilities?: string[] | undefined;
@@ -137,10 +137,10 @@ export declare const ActionItemSchema: z.ZodObject<Omit<{
 }, "strip", z.ZodTypeAny, {
     type: "action";
     key: string;
-    title: string;
     description: string;
+    title: string;
     app_key: string;
-    action_type: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+    action_type: "filter" | "read" | "read_bulk" | "write" | "run" | "search" | "search_or_write" | "search_and_write";
     id?: string | undefined;
     noun?: string | undefined;
     description_html?: string | undefined;
@@ -149,7 +149,7 @@ export declare const ActionItemSchema: z.ZodObject<Omit<{
     needs?: {
         key: string;
         default?: string | undefined;
-        type?: "string" | "boolean" | "text" | "password" | "code" | "filter" | "integer" | "datetime" | "file" | "decimal" | "copy" | "dict" | "json" | undefined;
+        type?: "string" | "boolean" | "filter" | "code" | "integer" | "text" | "datetime" | "file" | "decimal" | "copy" | "password" | "dict" | "json" | undefined;
         label?: string | undefined;
         alters_custom_fields?: boolean | null | undefined;
         capabilities?: string[] | undefined;
@@ -189,10 +189,10 @@ export declare const ActionItemSchema: z.ZodObject<Omit<{
 }, {
     type: "action";
     key: string;
-    title: string;
     description: string;
+    title: string;
     app_key: string;
-    action_type: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+    action_type: "filter" | "read" | "read_bulk" | "write" | "run" | "search" | "search_or_write" | "search_and_write";
     id?: string | undefined;
     noun?: string | undefined;
     description_html?: string | undefined;
@@ -201,7 +201,7 @@ export declare const ActionItemSchema: z.ZodObject<Omit<{
     needs?: {
         key: string;
         default?: string | undefined;
-        type?: "string" | "boolean" | "text" | "password" | "code" | "filter" | "integer" | "datetime" | "file" | "decimal" | "copy" | "dict" | "json" | undefined;
+        type?: "string" | "boolean" | "filter" | "code" | "integer" | "text" | "datetime" | "file" | "decimal" | "copy" | "password" | "dict" | "json" | undefined;
         label?: string | undefined;
         alters_custom_fields?: boolean | null | undefined;
         capabilities?: string[] | undefined;

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

@@ -1 +1 @@
-{"version":3,"file":"Action.d.ts","sourceRoot":"","sources":["../../src/schemas/Action.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+B5B,CAAC;AAMF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}
+{"version":3,"file":"Action.d.ts","sourceRoot":"","sources":["../../src/schemas/Action.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoC5B,CAAC;AAMF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/schemas/Action.js

@@ -23,11 +23,16 @@ export const ActionItemSchema = withFormatter(ActionSchema.omit({ type: true, na
             });
         }
         if (item.description) {
-            details.push({ text: item.description, style: "dim" });
+            details.push({
+                text: item.description,
+                style: "dim",
+            });
         }
         return {
-            title: item.title || item.name || item.key,
-            subtitle: `(${item.key})`,
+            title: item.title || item.key,
+            id: item.id,
+            key: item.key,
+            description: item.description,
             details,
         };
     },

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: [],
         };
     },