@zapier/zapier-sdk 0.9.0 → 0.10.0

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;AAE9D,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,CAyBF,CAAC"}

package/dist/resolvers/inputFieldKey.js

@@ -0,0 +1,23 @@
+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
+        });
+        return 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,13 @@
-import type { ZapierSdk } from "../types/sdk";
-export interface InputsResolver {
-    type: "fields";
-    depends: readonly string[];
-    fetch: (sdk: ZapierSdk, resolvedParams: Record<string, any>) => Promise<any[]>;
-}
+import type { FieldsResolver } from "../utils/schema-utils";
+import type { ActionTypeProperty } from "../types/properties";
+type InputsResolver = FieldsResolver<{
+    appKey: string;
+    actionKey: string;
+    actionType: ActionTypeProperty;
+    authenticationId: number;
+    inputs?: Record<string, unknown>;
+}>;
 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,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAE9D,KAAK,cAAc,GAAG,cAAc,CAAC;IACnC,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,CAAC,CAAC;AAEH,eAAO,MAAM,cAAc,EAAE,cAa5B,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,cAgBvC,CAAC"}

package/dist/resolvers/inputs.js

@@ -12,3 +12,20 @@ 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 fieldsResponse.data.map((field) => ({
+            ...field,
+            is_required: false,
+        }));
+    },
+};

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

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,
         };
     },