@zapier/zapier-sdk 0.1.0 → 0.1.1

package/dist/schemas/Auth.js

@@ -9,7 +9,6 @@ const schema_utils_1 = require("../schema-utils");
 exports.AuthItemSchema = (0, schema_utils_1.withFormatter)(zod_1.z.object({
     id: zod_1.z.number(),
     title: zod_1.z.string().optional(),
-    label: zod_1.z.string().optional(),
     identifier: zod_1.z.string().optional(),
     account_id: zod_1.z.string().optional(),
     is_private: zod_1.z.boolean().optional(),
@@ -24,12 +23,6 @@ exports.AuthItemSchema = (0, schema_utils_1.withFormatter)(zod_1.z.object({
                 style: "accent",
             });
         }
-        if (item.label && item.title && item.label !== item.title) {
-            details.push({
-                text: `Label: ${item.label}`,
-                style: "normal",
-            });
-        }
         details.push({
             text: `Account: ${item.account_id || "unknown"} | Private: ${item.is_private || false} | Shared: ${item.shared_with_all || false}`,
             style: "dim",
@@ -41,7 +34,7 @@ exports.AuthItemSchema = (0, schema_utils_1.withFormatter)(zod_1.z.object({
             });
         }
         return {
-            title: item.title || item.label || `Authentication ${item.id}`,
+            title: item.title || `Authentication ${item.id}`,
             subtitle: `(ID: ${item.id})`,
             details,
         };

package/dist/sdk.js

@@ -8,7 +8,9 @@ const getApp_1 = require("./functions/getApp");
 const listActions_1 = require("./functions/listActions");
 const getAction_1 = require("./functions/getAction");
 const runAction_1 = require("./functions/runAction");
-const listAuths_1 = require("./functions/listAuths");
+const listAuthentications_1 = require("./functions/listAuthentications");
+const findFirstAuthentication_1 = require("./functions/findFirstAuthentication");
+const findUniqueAuthentication_1 = require("./functions/findUniqueAuthentication");
 const listFields_1 = require("./functions/listFields");
 const generateTypes_1 = require("./functions/generateTypes");
 const bundleCode_1 = require("./functions/bundleCode");
@@ -18,10 +20,12 @@ const info_2 = require("./functions/getApp/info");
 const info_3 = require("./functions/listActions/info");
 const info_4 = require("./functions/getAction/info");
 const info_5 = require("./functions/runAction/info");
-const info_6 = require("./functions/listAuths/info");
-const info_7 = require("./functions/listFields/info");
-const info_8 = require("./functions/generateTypes/info");
-const info_9 = require("./functions/bundleCode/info");
+const info_6 = require("./functions/listAuthentications/info");
+const info_7 = require("./functions/findFirstAuthentication/info");
+const info_8 = require("./functions/findUniqueAuthentication/info");
+const info_9 = require("./functions/listFields/info");
+const info_10 = require("./functions/generateTypes/info");
+const info_11 = require("./functions/bundleCode/info");
 // Function registry as array - uses names from function info objects
 const functionRegistry = [
     info_1.listAppsInfo,
@@ -29,10 +33,12 @@ const functionRegistry = [
     info_3.listActionsInfo,
     info_4.getActionInfo,
     info_5.runActionInfo,
-    info_6.listAuthsInfo,
-    info_7.listFieldsInfo,
-    info_8.generateTypesInfo,
-    info_9.bundleCodeInfo,
+    info_6.listAuthenticationsInfo,
+    info_7.findFirstAuthenticationInfo,
+    info_8.findUniqueAuthenticationInfo,
+    info_9.listFieldsInfo,
+    info_10.generateTypesInfo,
+    info_11.bundleCodeInfo,
 ];
 // Import plugin functions
 const index_1 = require("./plugins/apps/index");
@@ -68,7 +74,9 @@ function createBaseZapierSdk(options = {}) {
         listActions: (options = {}) => (0, listActions_1.listActions)({ ...options, api, token: finalToken }),
         getAction: (options) => (0, getAction_1.getAction)({ ...options, api, token: finalToken }),
         runAction: (options) => (0, runAction_1.runAction)({ ...options, api, token: finalToken }),
-        listAuths: (options = {}) => (0, listAuths_1.listAuths)({ ...options, api, token: finalToken }),
+        listAuthentications: (options = {}) => (0, listAuthentications_1.listAuthentications)({ ...options, api, token: finalToken }),
+        findFirstAuthentication: (options = {}) => (0, findFirstAuthentication_1.findFirstAuthentication)({ ...options, api, token: finalToken }),
+        findUniqueAuthentication: (options = {}) => (0, findUniqueAuthentication_1.findUniqueAuthentication)({ ...options, api, token: finalToken }),
         listFields: (options) => (0, listFields_1.listFields)({ ...options, api, token: finalToken }),
         generateTypes: (options) => (0, generateTypes_1.generateTypes)({ ...options, api, token: finalToken }),
         bundleCode: (options) => (0, bundleCode_1.bundleCode)(options), // No API config needed

package/dist/types/properties.js

@@ -2,12 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParamsPropertySchema = exports.DebugPropertySchema = exports.OutputPropertySchema = exports.OffsetPropertySchema = exports.LimitPropertySchema = exports.InputsPropertySchema = exports.AuthenticationIdPropertySchema = exports.ActionKeyPropertySchema = exports.ActionTypePropertySchema = exports.AppKeyPropertySchema = void 0;
 const zod_1 = require("zod");
+const schema_utils_1 = require("../schema-utils");
 // Shared property definitions for common parameters across functions
 // These can be reused in function schemas without duplication
-exports.AppKeyPropertySchema = zod_1.z
-    .string()
-    .min(1)
-    .describe("App slug (e.g., 'slack', 'github')");
+exports.AppKeyPropertySchema = (0, schema_utils_1.withPositional)(zod_1.z.string().min(1).describe("App slug (e.g., 'slack', 'github')"));
 exports.ActionTypePropertySchema = zod_1.z
     .enum(["read", "write", "search", "create", "update", "delete"])
     .describe("Action type that matches the action's defined type");

package/dist/types/sdk.d.ts

@@ -3,12 +3,14 @@ import type { GetActionSdkFunction } from "../functions/getAction/schemas";
 import type { GetAppSdkFunction } from "../functions/getApp/schemas";
 import type { RunActionSdkFunction } from "../functions/runAction/schemas";
 import type { ListFieldsSdkFunction } from "../functions/listFields/schemas";
-import type { ListAuthsSdkFunction } from "../functions/listAuths/schemas";
+import type { ListAuthenticationsSdkFunction } from "../functions/listAuthentications/schemas";
+import type { FindFirstAuthenticationSdkFunction } from "../functions/findFirstAuthentication/schemas";
+import type { FindUniqueAuthenticationSdkFunction } from "../functions/findUniqueAuthentication/schemas";
 import type { GenerateTypesSdkFunction } from "../functions/generateTypes/schemas";
 import type { ListAppsSdkFunction } from "../functions/listApps/schemas";
 import type { BundleCodeSdkFunction } from "../functions/bundleCode/schemas";
 import type { AppsPluginSdkExtension } from "../plugins/apps/types";
-export interface ZapierSdkFunctions extends ListActionsSdkFunction, GetActionSdkFunction, GetAppSdkFunction, RunActionSdkFunction, ListFieldsSdkFunction, ListAuthsSdkFunction, GenerateTypesSdkFunction, ListAppsSdkFunction, BundleCodeSdkFunction {
+export interface ZapierSdkFunctions extends ListActionsSdkFunction, GetActionSdkFunction, GetAppSdkFunction, RunActionSdkFunction, ListFieldsSdkFunction, ListAuthenticationsSdkFunction, FindFirstAuthenticationSdkFunction, FindUniqueAuthenticationSdkFunction, GenerateTypesSdkFunction, ListAppsSdkFunction, BundleCodeSdkFunction {
 }
 export interface ZapierSdkPlugins extends AppsPluginSdkExtension {
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zapier/zapier-sdk",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Complete Zapier SDK - combines all Zapier SDK packages",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/functions/findFirstAuthentication/index.ts

@@ -0,0 +1,24 @@
+import type { Authentication } from "../../types/domain";
+import { listAuthentications } from "../listAuthentications";
+import type { FindFirstAuthenticationOptions } from "./schemas";
+
+/**
+ * Find the first authentication matching the given criteria
+ *
+ * This function can be used standalone without instantiating a full SDK,
+ * which enables better tree-shaking in applications that only need this functionality.
+ *
+ * @param options - Filtering and API configuration options
+ * @returns Promise<Authentication | null> - First matching authentication or null if not found
+ */
+export async function findFirstAuthentication(
+  options: Partial<FindFirstAuthenticationOptions> = {},
+): Promise<Authentication | null> {
+  // Use listAuthentications with limit 1 to get the first result
+  const auths = await listAuthentications({
+    ...options,
+    limit: 1,
+  });
+
+  return auths.length > 0 ? auths[0] : null;
+}

package/src/functions/findFirstAuthentication/info.ts

@@ -0,0 +1,9 @@
+import { findFirstAuthentication } from "./index";
+import { FindFirstAuthenticationSchema } from "./schemas";
+
+// Function registry info - imports both function and schema
+export const findFirstAuthenticationInfo = {
+  name: findFirstAuthentication.name,
+  inputSchema: FindFirstAuthenticationSchema,
+  implementation: findFirstAuthentication,
+};

package/src/functions/findFirstAuthentication/schemas.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import {
+  AppKeyPropertySchema,
+  LimitPropertySchema,
+  OffsetPropertySchema,
+} from "../../types/properties";
+import { withOutputSchema } from "../../schema-utils";
+import { AuthItemSchema } from "../../schemas/Auth";
+import type { Authentication } from "../../types/domain";
+
+// Pure Zod schema - no resolver metadata!
+export const FindFirstAuthenticationSchema = withOutputSchema(
+  z
+    .object({
+      appKey: AppKeyPropertySchema.optional().describe(
+        "App slug to get authentications for (e.g., 'slack', 'github')",
+      ),
+      search: z
+        .string()
+        .optional()
+        .describe("Search term to filter authentications by title"),
+      title: z
+        .string()
+        .optional()
+        .describe("Filter authentications by exact title match"),
+      account_id: z.string().optional().describe("Filter by account ID"),
+      owner: z.string().optional().describe("Filter by owner"),
+      limit: LimitPropertySchema.optional().describe(
+        "Maximum number of items to return (1-200)",
+      ),
+      offset: OffsetPropertySchema.optional().describe(
+        "Number of items to skip for pagination",
+      ),
+    })
+    .describe("Find the first authentication matching the criteria"),
+  AuthItemSchema,
+);
+
+// Type inferred from schema + function config
+export type FindFirstAuthenticationOptions = z.infer<
+  typeof FindFirstAuthenticationSchema
+> & {
+  /** Base URL for Zapier API */
+  baseUrl?: string;
+  /** Authentication token */
+  token?: string;
+  /** Optional pre-instantiated API client */
+  api?: any;
+  /** Enable debug logging */
+  debug?: boolean;
+  /** Custom fetch implementation */
+  fetch?: typeof globalThis.fetch;
+};
+
+// SDK function interface - ready to be mixed into main SDK interface
+export interface FindFirstAuthenticationSdkFunction {
+  findFirstAuthentication: (
+    options?: Partial<FindFirstAuthenticationOptions>,
+  ) => Promise<Authentication | null>;
+}

package/src/functions/findUniqueAuthentication/index.ts

@@ -0,0 +1,35 @@
+import type { Authentication } from "../../types/domain";
+import { listAuthentications } from "../listAuthentications";
+import type { FindUniqueAuthenticationOptions } from "./schemas";
+
+/**
+ * Find a unique authentication matching the given criteria
+ *
+ * This function can be used standalone without instantiating a full SDK,
+ * which enables better tree-shaking in applications that only need this functionality.
+ *
+ * @param options - Filtering and API configuration options
+ * @returns Promise<Authentication> - The unique matching authentication
+ * @throws Error if no authentication found or multiple authentications found
+ */
+export async function findUniqueAuthentication(
+  options: Partial<FindUniqueAuthenticationOptions> = {},
+): Promise<Authentication> {
+  // Use listAuthentications with a reasonable limit to check for uniqueness
+  const auths = await listAuthentications({
+    ...options,
+    limit: 2, // Get up to 2 to check for uniqueness
+  });
+
+  if (auths.length === 0) {
+    throw new Error("No authentication found matching the specified criteria");
+  }
+
+  if (auths.length > 1) {
+    throw new Error(
+      "Multiple authentications found matching the specified criteria. Expected exactly one.",
+    );
+  }
+
+  return auths[0];
+}

package/src/functions/findUniqueAuthentication/info.ts

@@ -0,0 +1,9 @@
+import { findUniqueAuthentication } from "./index";
+import { FindUniqueAuthenticationSchema } from "./schemas";
+
+// Function registry info - imports both function and schema
+export const findUniqueAuthenticationInfo = {
+  name: findUniqueAuthentication.name,
+  inputSchema: FindUniqueAuthenticationSchema,
+  implementation: findUniqueAuthentication,
+};

package/src/functions/findUniqueAuthentication/schemas.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import {
+  AppKeyPropertySchema,
+  LimitPropertySchema,
+  OffsetPropertySchema,
+} from "../../types/properties";
+import { withOutputSchema } from "../../schema-utils";
+import { AuthItemSchema } from "../../schemas/Auth";
+import type { Authentication } from "../../types/domain";
+
+// Pure Zod schema - no resolver metadata!
+export const FindUniqueAuthenticationSchema = withOutputSchema(
+  z
+    .object({
+      appKey: AppKeyPropertySchema.optional().describe(
+        "App slug to get authentications for (e.g., 'slack', 'github')",
+      ),
+      search: z
+        .string()
+        .optional()
+        .describe("Search term to filter authentications by title"),
+      title: z
+        .string()
+        .optional()
+        .describe("Filter authentications by exact title match"),
+      account_id: z.string().optional().describe("Filter by account ID"),
+      owner: z.string().optional().describe("Filter by owner"),
+      limit: LimitPropertySchema.optional().describe(
+        "Maximum number of items to return (1-200)",
+      ),
+      offset: OffsetPropertySchema.optional().describe(
+        "Number of items to skip for pagination",
+      ),
+    })
+    .describe("Find a unique authentication matching the criteria"),
+  AuthItemSchema,
+);
+
+// Type inferred from schema + function config
+export type FindUniqueAuthenticationOptions = z.infer<
+  typeof FindUniqueAuthenticationSchema
+> & {
+  /** Base URL for Zapier API */
+  baseUrl?: string;
+  /** Authentication token */
+  token?: string;
+  /** Optional pre-instantiated API client */
+  api?: any;
+  /** Enable debug logging */
+  debug?: boolean;
+  /** Custom fetch implementation */
+  fetch?: typeof globalThis.fetch;
+};
+
+// SDK function interface - ready to be mixed into main SDK interface
+export interface FindUniqueAuthenticationSdkFunction {
+  findUniqueAuthentication: (
+    options?: Partial<FindUniqueAuthenticationOptions>,
+  ) => Promise<Authentication>;
+}

package/src/functions/{listAuths → listAuthentications}/index.ts

@@ -4,7 +4,7 @@ import type {
   AuthenticationsResponse,
 } from "../../types/domain";
 import { getApp } from "../getApp";
-import type { ListAuthsOptions } from "./schemas";
+import type { ListAuthenticationsOptions } from "./schemas";
 
 /**
  * List available authentications with optional filtering
@@ -15,8 +15,8 @@ import type { ListAuthsOptions } from "./schemas";
  * @param options - Filtering, pagination, and API configuration options
  * @returns Promise<Authentication[]> with pagination metadata
  */
-export async function listAuths(
-  options: Partial<ListAuthsOptions> = {},
+export async function listAuthentications(
+  options: Partial<ListAuthenticationsOptions> = {},
 ): Promise<Authentication[]> {
   const { token } = options;
 
@@ -29,8 +29,8 @@ export async function listAuths(
   const api = getOrCreateApiClient(options);
 
   // Local function to handle the actual API fetching
-  const listAuthsInternal = async (
-    options: ListAuthsOptions = {},
+  const listAuthenticationsInternal = async (
+    options: ListAuthenticationsOptions = {},
   ): Promise<Authentication[]> => {
     // Build search parameters
     const searchParams: Record<string, string> = {};
@@ -68,6 +68,12 @@ export async function listAuths(
     }
 
     // Add other query parameters if provided
+    // Use title as search if no explicit search provided
+    if (options.search) {
+      searchParams.search = options.search;
+    } else if (options.title) {
+      searchParams.search = options.title;
+    }
     if (options.account_id) {
       searchParams.account_id = options.account_id;
     }
@@ -102,7 +108,18 @@ export async function listAuths(
     );
 
     // Transform API response
-    const auths = data.results || [];
+    let auths = data.results || [];
+
+    // Coerce title from label if title is missing (API cleanup)
+    auths = auths.map((auth) => ({
+      ...auth,
+      title: auth.title || (auth as any).label || undefined,
+    }));
+
+    // Filter by exact title match if specified
+    if (options.title) {
+      auths = auths.filter((auth) => auth.title === options.title);
+    }
 
     // Add pagination metadata to the response
     if (auths.length > 0) {
@@ -121,7 +138,7 @@ export async function listAuths(
   // If a limit is provided and no specific owner filter, prioritize owned auths
   if (options.limit && options.owner === undefined) {
     // First get owned auths
-    const ownedAuths = await listAuthsInternal({
+    const ownedAuths = await listAuthenticationsInternal({
       ...options,
       owner: "me",
     });
@@ -132,7 +149,7 @@ export async function listAuths(
     }
 
     // Get all auths up to the original limit to fill remaining slots
-    const allAuths = await listAuthsInternal({
+    const allAuths = await listAuthenticationsInternal({
       ...options,
       owner: undefined,
     });
@@ -149,5 +166,5 @@ export async function listAuths(
   }
 
   // Standard implementation for non-prioritized requests
-  return listAuthsInternal(options);
+  return listAuthenticationsInternal(options);
 }

package/src/functions/listAuthentications/info.ts

@@ -0,0 +1,9 @@
+import { listAuthentications } from "./index";
+import { ListAuthenticationsSchema } from "./schemas";
+
+// Function registry info - imports both function and schema
+export const listAuthenticationsInfo = {
+  name: listAuthentications.name,
+  inputSchema: ListAuthenticationsSchema,
+  implementation: listAuthentications,
+};

package/src/functions/{listAuths → listAuthentications}/schemas.ts

@@ -9,12 +9,20 @@ import { AuthItemSchema } from "../../schemas/Auth";
 import type { Authentication } from "../../types/domain";
 
 // Pure Zod schema - no resolver metadata!
-export const ListAuthsSchema = withOutputSchema(
+export const ListAuthenticationsSchema = withOutputSchema(
   z
     .object({
       appKey: AppKeyPropertySchema.optional().describe(
         "App slug to get authentications for (e.g., 'slack', 'github')",
       ),
+      search: z
+        .string()
+        .optional()
+        .describe("Search term to filter authentications by title"),
+      title: z
+        .string()
+        .optional()
+        .describe("Filter authentications by exact title match"),
       account_id: z.string().optional().describe("Filter by account ID"),
       owner: z.string().optional().describe("Filter by owner"),
       limit: LimitPropertySchema.optional().describe(
@@ -29,7 +37,9 @@ export const ListAuthsSchema = withOutputSchema(
 );
 
 // Type inferred from schema + function config
-export type ListAuthsOptions = z.infer<typeof ListAuthsSchema> & {
+export type ListAuthenticationsOptions = z.infer<
+  typeof ListAuthenticationsSchema
+> & {
   /** Base URL for Zapier API */
   baseUrl?: string;
   /** Authentication token */
@@ -43,6 +53,8 @@ export type ListAuthsOptions = z.infer<typeof ListAuthsSchema> & {
 };
 
 // SDK function interface - ready to be mixed into main SDK interface
-export interface ListAuthsSdkFunction {
-  listAuths: (options?: Partial<ListAuthsOptions>) => Promise<Authentication[]>;
+export interface ListAuthenticationsSdkFunction {
+  listAuthentications: (
+    options?: Partial<ListAuthenticationsOptions>,
+  ) => Promise<Authentication[]>;
 }

package/src/index.ts

@@ -3,13 +3,18 @@ export * from "./types/domain";
 export * from "./types/properties";
 export * from "./plugins/apps";
 
+// Export schema utilities for CLI
+export { isPositional } from "./schema-utils";
+
 // Export resolvers for CLI use
 export * from "./resolvers";
 
 // Note: SdkSchemas is now available via SDK.__registry
 
 // Export individual functions for tree-shaking
-export { listAuths } from "./functions/listAuths";
+export { listAuthentications } from "./functions/listAuthentications";
+export { findFirstAuthentication } from "./functions/findFirstAuthentication";
+export { findUniqueAuthentication } from "./functions/findUniqueAuthentication";
 export { listApps } from "./functions/listApps";
 export { getApp } from "./functions/getApp";
 export { listActions } from "./functions/listActions";

package/src/resolvers/authenticationId.ts

@@ -15,7 +15,7 @@ export const authenticationIdResolver: AuthenticationIdResolver = {
   depends: ["appKey"] as const,
   fetch: async (sdk: ZapierSdk, resolvedParams: Record<string, any>) => {
     // Get auths for the specific app (owned auths will be prioritized automatically)
-    return await sdk.listAuths({
+    return await sdk.listAuthentications({
       appKey: resolvedParams.appKey,
       limit: 1000,
     });

package/src/schema-utils.ts

@@ -117,3 +117,38 @@ export function getFieldDescriptions(
 
   return descriptions;
 }
+
+// ============================================================================
+// Positional Parameter Metadata
+// ============================================================================
+
+export interface PositionalMetadata {
+  positional: true;
+}
+
+// Helper function to mark a parameter as positional for CLI
+export function withPositional<T extends z.ZodType>(schema: T): T {
+  // Store positional metadata on the schema definition
+  (schema._def as any).positionalMeta = { positional: true };
+  return schema;
+}
+
+// Helper function to check if a parameter should be positional
+export function isPositional(schema: z.ZodType): boolean {
+  // Check the current schema first
+  if ((schema._def as any).positionalMeta?.positional) {
+    return true;
+  }
+
+  // If this is a ZodOptional, check the inner type
+  if (schema instanceof z.ZodOptional) {
+    return isPositional(schema._def.innerType);
+  }
+
+  // If this is a ZodDefault, check the inner type
+  if (schema instanceof z.ZodDefault) {
+    return isPositional(schema._def.innerType);
+  }
+
+  return false;
+}

package/src/schemas/Auth.ts

@@ -9,7 +9,6 @@ export const AuthItemSchema = withFormatter(
   z.object({
     id: z.number(),
     title: z.string().optional(),
-    label: z.string().optional(),
     identifier: z.string().optional(),
     account_id: z.string().optional(),
     is_private: z.boolean().optional(),
@@ -27,13 +26,6 @@ export const AuthItemSchema = withFormatter(
         });
       }
 
-      if (item.label && item.title && item.label !== item.title) {
-        details.push({
-          text: `Label: ${item.label}`,
-          style: "normal" as const,
-        });
-      }
-
       details.push({
         text: `Account: ${item.account_id || "unknown"} | Private: ${item.is_private || false} | Shared: ${item.shared_with_all || false}`,
         style: "dim" as const,
@@ -47,7 +39,7 @@ export const AuthItemSchema = withFormatter(
       }
 
       return {
-        title: item.title || item.label || `Authentication ${item.id}`,
+        title: item.title || `Authentication ${item.id}`,
         subtitle: `(ID: ${item.id})`,
         details,
       };

package/src/sdk.ts

@@ -6,7 +6,9 @@ import { getApp } from "./functions/getApp";
 import { listActions } from "./functions/listActions";
 import { getAction } from "./functions/getAction";
 import { runAction } from "./functions/runAction";
-import { listAuths } from "./functions/listAuths";
+import { listAuthentications } from "./functions/listAuthentications";
+import { findFirstAuthentication } from "./functions/findFirstAuthentication";
+import { findUniqueAuthentication } from "./functions/findUniqueAuthentication";
 import { listFields } from "./functions/listFields";
 import { generateTypes } from "./functions/generateTypes";
 import { bundleCode } from "./functions/bundleCode";
@@ -17,7 +19,9 @@ import { getAppInfo } from "./functions/getApp/info";
 import { listActionsInfo } from "./functions/listActions/info";
 import { getActionInfo } from "./functions/getAction/info";
 import { runActionInfo } from "./functions/runAction/info";
-import { listAuthsInfo } from "./functions/listAuths/info";
+import { listAuthenticationsInfo } from "./functions/listAuthentications/info";
+import { findFirstAuthenticationInfo } from "./functions/findFirstAuthentication/info";
+import { findUniqueAuthenticationInfo } from "./functions/findUniqueAuthentication/info";
 import { listFieldsInfo } from "./functions/listFields/info";
 import { generateTypesInfo } from "./functions/generateTypes/info";
 import { bundleCodeInfo } from "./functions/bundleCode/info";
@@ -29,7 +33,9 @@ const functionRegistry = [
   listActionsInfo,
   getActionInfo,
   runActionInfo,
-  listAuthsInfo,
+  listAuthenticationsInfo,
+  findFirstAuthenticationInfo,
+  findUniqueAuthenticationInfo,
   listFieldsInfo,
   generateTypesInfo,
   bundleCodeInfo,
@@ -55,7 +61,9 @@ interface BaseZapierSdkWithFunctions {
   listActions: ZapierSdk["listActions"];
   getAction: ZapierSdk["getAction"];
   runAction: ZapierSdk["runAction"];
-  listAuths: ZapierSdk["listAuths"];
+  listAuthentications: ZapierSdk["listAuthentications"];
+  findFirstAuthentication: ZapierSdk["findFirstAuthentication"];
+  findUniqueAuthentication: ZapierSdk["findUniqueAuthentication"];
   listFields: ZapierSdk["listFields"];
   generateTypes: ZapierSdk["generateTypes"];
   bundleCode: ZapierSdk["bundleCode"];
@@ -111,8 +119,12 @@ function createBaseZapierSdk(
       listActions({ ...options, api, token: finalToken }),
     getAction: (options) => getAction({ ...options, api, token: finalToken }),
     runAction: (options) => runAction({ ...options, api, token: finalToken }),
-    listAuths: (options = {}) =>
-      listAuths({ ...options, api, token: finalToken }),
+    listAuthentications: (options = {}) =>
+      listAuthentications({ ...options, api, token: finalToken }),
+    findFirstAuthentication: (options = {}) =>
+      findFirstAuthentication({ ...options, api, token: finalToken }),
+    findUniqueAuthentication: (options = {}) =>
+      findUniqueAuthentication({ ...options, api, token: finalToken }),
     listFields: (options) => listFields({ ...options, api, token: finalToken }),
     generateTypes: (options) =>
       generateTypes({ ...options, api, token: finalToken }),

package/src/types/properties.ts

@@ -1,12 +1,12 @@
 import { z } from "zod";
+import { withPositional } from "../schema-utils";
 
 // Shared property definitions for common parameters across functions
 // These can be reused in function schemas without duplication
 
-export const AppKeyPropertySchema = z
-  .string()
-  .min(1)
-  .describe("App slug (e.g., 'slack', 'github')");
+export const AppKeyPropertySchema = withPositional(
+  z.string().min(1).describe("App slug (e.g., 'slack', 'github')"),
+);
 
 export const ActionTypePropertySchema = z
   .enum(["read", "write", "search", "create", "update", "delete"])