@zapier/zapier-sdk 0.1.0 → 0.1.1

package/dist/functions/findFirstAuthentication/index.d.ts

@@ -0,0 +1,12 @@
+import type { Authentication } from "../../types/domain";
+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 declare function findFirstAuthentication(options?: Partial<FindFirstAuthenticationOptions>): Promise<Authentication | null>;

package/dist/functions/findFirstAuthentication/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findFirstAuthentication = findFirstAuthentication;
+const listAuthentications_1 = require("../listAuthentications");
+/**
+ * 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
+ */
+async function findFirstAuthentication(options = {}) {
+    // Use listAuthentications with limit 1 to get the first result
+    const auths = await (0, listAuthentications_1.listAuthentications)({
+        ...options,
+        limit: 1,
+    });
+    return auths.length > 0 ? auths[0] : null;
+}

package/dist/functions/findFirstAuthentication/info.d.ts

@@ -0,0 +1,30 @@
+import { findFirstAuthentication } from "./index";
+export declare const findFirstAuthenticationInfo: {
+    name: string;
+    inputSchema: import("zod").ZodObject<{
+        appKey: import("zod").ZodOptional<import("zod").ZodString>;
+        search: import("zod").ZodOptional<import("zod").ZodString>;
+        title: import("zod").ZodOptional<import("zod").ZodString>;
+        account_id: import("zod").ZodOptional<import("zod").ZodString>;
+        owner: import("zod").ZodOptional<import("zod").ZodString>;
+        limit: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodNumber>>;
+        offset: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodNumber>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        search?: string | undefined;
+        appKey?: string | undefined;
+        title?: string | undefined;
+        account_id?: string | undefined;
+        owner?: string | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+    }, {
+        search?: string | undefined;
+        appKey?: string | undefined;
+        title?: string | undefined;
+        account_id?: string | undefined;
+        owner?: string | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+    }>;
+    implementation: typeof findFirstAuthentication;
+};

package/dist/functions/findFirstAuthentication/info.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findFirstAuthenticationInfo = void 0;
+const index_1 = require("./index");
+const schemas_1 = require("./schemas");
+// Function registry info - imports both function and schema
+exports.findFirstAuthenticationInfo = {
+    name: index_1.findFirstAuthentication.name,
+    inputSchema: schemas_1.FindFirstAuthenticationSchema,
+    implementation: index_1.findFirstAuthentication,
+};

package/dist/functions/findFirstAuthentication/schemas.d.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import type { Authentication } from "../../types/domain";
+export declare const FindFirstAuthenticationSchema: z.ZodObject<{
+    appKey: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    account_id: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    offset: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    search?: string | undefined;
+    appKey?: string | undefined;
+    title?: string | undefined;
+    account_id?: string | undefined;
+    owner?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}, {
+    search?: string | undefined;
+    appKey?: string | undefined;
+    title?: string | undefined;
+    account_id?: string | undefined;
+    owner?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+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;
+};
+export interface FindFirstAuthenticationSdkFunction {
+    findFirstAuthentication: (options?: Partial<FindFirstAuthenticationOptions>) => Promise<Authentication | null>;
+}

package/dist/functions/findFirstAuthentication/schemas.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindFirstAuthenticationSchema = void 0;
+const zod_1 = require("zod");
+const properties_1 = require("../../types/properties");
+const schema_utils_1 = require("../../schema-utils");
+const Auth_1 = require("../../schemas/Auth");
+// Pure Zod schema - no resolver metadata!
+exports.FindFirstAuthenticationSchema = (0, schema_utils_1.withOutputSchema)(zod_1.z
+    .object({
+    appKey: properties_1.AppKeyPropertySchema.optional().describe("App slug to get authentications for (e.g., 'slack', 'github')"),
+    search: zod_1.z
+        .string()
+        .optional()
+        .describe("Search term to filter authentications by title"),
+    title: zod_1.z
+        .string()
+        .optional()
+        .describe("Filter authentications by exact title match"),
+    account_id: zod_1.z.string().optional().describe("Filter by account ID"),
+    owner: zod_1.z.string().optional().describe("Filter by owner"),
+    limit: properties_1.LimitPropertySchema.optional().describe("Maximum number of items to return (1-200)"),
+    offset: properties_1.OffsetPropertySchema.optional().describe("Number of items to skip for pagination"),
+})
+    .describe("Find the first authentication matching the criteria"), Auth_1.AuthItemSchema);

package/dist/functions/findUniqueAuthentication/index.d.ts

@@ -0,0 +1,13 @@
+import type { Authentication } from "../../types/domain";
+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 declare function findUniqueAuthentication(options?: Partial<FindUniqueAuthenticationOptions>): Promise<Authentication>;

package/dist/functions/findUniqueAuthentication/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findUniqueAuthentication = findUniqueAuthentication;
+const listAuthentications_1 = require("../listAuthentications");
+/**
+ * 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
+ */
+async function findUniqueAuthentication(options = {}) {
+    // Use listAuthentications with a reasonable limit to check for uniqueness
+    const auths = await (0, listAuthentications_1.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/dist/functions/findUniqueAuthentication/info.d.ts

@@ -0,0 +1,30 @@
+import { findUniqueAuthentication } from "./index";
+export declare const findUniqueAuthenticationInfo: {
+    name: string;
+    inputSchema: import("zod").ZodObject<{
+        appKey: import("zod").ZodOptional<import("zod").ZodString>;
+        search: import("zod").ZodOptional<import("zod").ZodString>;
+        title: import("zod").ZodOptional<import("zod").ZodString>;
+        account_id: import("zod").ZodOptional<import("zod").ZodString>;
+        owner: import("zod").ZodOptional<import("zod").ZodString>;
+        limit: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodNumber>>;
+        offset: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodNumber>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        search?: string | undefined;
+        appKey?: string | undefined;
+        title?: string | undefined;
+        account_id?: string | undefined;
+        owner?: string | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+    }, {
+        search?: string | undefined;
+        appKey?: string | undefined;
+        title?: string | undefined;
+        account_id?: string | undefined;
+        owner?: string | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+    }>;
+    implementation: typeof findUniqueAuthentication;
+};

package/dist/functions/findUniqueAuthentication/info.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findUniqueAuthenticationInfo = void 0;
+const index_1 = require("./index");
+const schemas_1 = require("./schemas");
+// Function registry info - imports both function and schema
+exports.findUniqueAuthenticationInfo = {
+    name: index_1.findUniqueAuthentication.name,
+    inputSchema: schemas_1.FindUniqueAuthenticationSchema,
+    implementation: index_1.findUniqueAuthentication,
+};

package/dist/functions/findUniqueAuthentication/schemas.d.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import type { Authentication } from "../../types/domain";
+export declare const FindUniqueAuthenticationSchema: z.ZodObject<{
+    appKey: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    account_id: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    offset: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    search?: string | undefined;
+    appKey?: string | undefined;
+    title?: string | undefined;
+    account_id?: string | undefined;
+    owner?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}, {
+    search?: string | undefined;
+    appKey?: string | undefined;
+    title?: string | undefined;
+    account_id?: string | undefined;
+    owner?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+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;
+};
+export interface FindUniqueAuthenticationSdkFunction {
+    findUniqueAuthentication: (options?: Partial<FindUniqueAuthenticationOptions>) => Promise<Authentication>;
+}

package/dist/functions/findUniqueAuthentication/schemas.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindUniqueAuthenticationSchema = void 0;
+const zod_1 = require("zod");
+const properties_1 = require("../../types/properties");
+const schema_utils_1 = require("../../schema-utils");
+const Auth_1 = require("../../schemas/Auth");
+// Pure Zod schema - no resolver metadata!
+exports.FindUniqueAuthenticationSchema = (0, schema_utils_1.withOutputSchema)(zod_1.z
+    .object({
+    appKey: properties_1.AppKeyPropertySchema.optional().describe("App slug to get authentications for (e.g., 'slack', 'github')"),
+    search: zod_1.z
+        .string()
+        .optional()
+        .describe("Search term to filter authentications by title"),
+    title: zod_1.z
+        .string()
+        .optional()
+        .describe("Filter authentications by exact title match"),
+    account_id: zod_1.z.string().optional().describe("Filter by account ID"),
+    owner: zod_1.z.string().optional().describe("Filter by owner"),
+    limit: properties_1.LimitPropertySchema.optional().describe("Maximum number of items to return (1-200)"),
+    offset: properties_1.OffsetPropertySchema.optional().describe("Number of items to skip for pagination"),
+})
+    .describe("Find a unique authentication matching the criteria"), Auth_1.AuthItemSchema);

package/dist/functions/{listAuths → listAuthentications}/index.d.ts

@@ -1,5 +1,5 @@
 import type { Authentication } from "../../types/domain";
-import type { ListAuthsOptions } from "./schemas";
+import type { ListAuthenticationsOptions } from "./schemas";
 /**
  * List available authentications with optional filtering
  *
@@ -9,4 +9,4 @@ import type { ListAuthsOptions } from "./schemas";
  * @param options - Filtering, pagination, and API configuration options
  * @returns Promise<Authentication[]> with pagination metadata
  */
-export declare function listAuths(options?: Partial<ListAuthsOptions>): Promise<Authentication[]>;
+export declare function listAuthentications(options?: Partial<ListAuthenticationsOptions>): Promise<Authentication[]>;

package/dist/functions/{listAuths → listAuthentications}/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.listAuths = listAuths;
+exports.listAuthentications = listAuthentications;
 const api_1 = require("../../api");
 const getApp_1 = require("../getApp");
 /**
@@ -12,14 +12,14 @@ const getApp_1 = require("../getApp");
  * @param options - Filtering, pagination, and API configuration options
  * @returns Promise<Authentication[]> with pagination metadata
  */
-async function listAuths(options = {}) {
+async function listAuthentications(options = {}) {
     const { token } = options;
     if (!token && !process.env.ZAPIER_TOKEN) {
         throw new Error("Authentication token is required to list authentications. Please provide token in options or set ZAPIER_TOKEN environment variable.");
     }
     const api = (0, api_1.getOrCreateApiClient)(options);
     // Local function to handle the actual API fetching
-    const listAuthsInternal = async (options = {}) => {
+    const listAuthenticationsInternal = async (options = {}) => {
         // Build search parameters
         const searchParams = {};
         // Handle appKey filtering by getting the selected_api first
@@ -52,6 +52,13 @@ async function listAuths(options = {}) {
             }
         }
         // 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;
         }
@@ -77,7 +84,16 @@ async function listAuths(options = {}) {
             },
         });
         // 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.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) {
             auths.__pagination = {
@@ -93,7 +109,7 @@ async function listAuths(options = {}) {
     // 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",
         });
@@ -102,7 +118,7 @@ async function listAuths(options = {}) {
             return ownedAuths.slice(0, options.limit);
         }
         // Get all auths up to the original limit to fill remaining slots
-        const allAuths = await listAuthsInternal({
+        const allAuths = await listAuthenticationsInternal({
             ...options,
             owner: undefined,
         });
@@ -114,5 +130,5 @@ async function listAuths(options = {}) {
         return combined.slice(0, options.limit);
     }
     // Standard implementation for non-prioritized requests
-    return listAuthsInternal(options);
+    return listAuthenticationsInternal(options);
 }

package/dist/functions/{listAuths → listAuthentications}/info.d.ts

@@ -1,24 +1,30 @@
-import { listAuths } from "./index";
-export declare const listAuthsInfo: {
+import { listAuthentications } from "./index";
+export declare const listAuthenticationsInfo: {
     name: string;
     inputSchema: import("zod").ZodObject<{
         appKey: import("zod").ZodOptional<import("zod").ZodString>;
+        search: import("zod").ZodOptional<import("zod").ZodString>;
+        title: import("zod").ZodOptional<import("zod").ZodString>;
         account_id: import("zod").ZodOptional<import("zod").ZodString>;
         owner: import("zod").ZodOptional<import("zod").ZodString>;
         limit: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodNumber>>;
         offset: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodNumber>>;
     }, "strip", import("zod").ZodTypeAny, {
+        search?: string | undefined;
         appKey?: string | undefined;
+        title?: string | undefined;
         account_id?: string | undefined;
         owner?: string | undefined;
         limit?: number | undefined;
         offset?: number | undefined;
     }, {
+        search?: string | undefined;
         appKey?: string | undefined;
+        title?: string | undefined;
         account_id?: string | undefined;
         owner?: string | undefined;
         limit?: number | undefined;
         offset?: number | undefined;
     }>;
-    implementation: typeof listAuths;
+    implementation: typeof listAuthentications;
 };

package/dist/functions/listAuthentications/info.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listAuthenticationsInfo = void 0;
+const index_1 = require("./index");
+const schemas_1 = require("./schemas");
+// Function registry info - imports both function and schema
+exports.listAuthenticationsInfo = {
+    name: index_1.listAuthentications.name,
+    inputSchema: schemas_1.ListAuthenticationsSchema,
+    implementation: index_1.listAuthentications,
+};

package/dist/functions/{listAuths → listAuthentications}/schemas.d.ts

@@ -1,25 +1,31 @@
 import { z } from "zod";
 import type { Authentication } from "../../types/domain";
-export declare const ListAuthsSchema: z.ZodObject<{
+export declare const ListAuthenticationsSchema: z.ZodObject<{
     appKey: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
     account_id: z.ZodOptional<z.ZodString>;
     owner: z.ZodOptional<z.ZodString>;
     limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
     offset: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
+    search?: string | undefined;
     appKey?: string | undefined;
+    title?: string | undefined;
     account_id?: string | undefined;
     owner?: string | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
 }, {
+    search?: string | undefined;
     appKey?: string | undefined;
+    title?: string | undefined;
     account_id?: string | undefined;
     owner?: string | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
 }>;
-export type ListAuthsOptions = z.infer<typeof ListAuthsSchema> & {
+export type ListAuthenticationsOptions = z.infer<typeof ListAuthenticationsSchema> & {
     /** Base URL for Zapier API */
     baseUrl?: string;
     /** Authentication token */
@@ -31,6 +37,6 @@ export type ListAuthsOptions = z.infer<typeof ListAuthsSchema> & {
     /** Custom fetch implementation */
     fetch?: typeof globalThis.fetch;
 };
-export interface ListAuthsSdkFunction {
-    listAuths: (options?: Partial<ListAuthsOptions>) => Promise<Authentication[]>;
+export interface ListAuthenticationsSdkFunction {
+    listAuthentications: (options?: Partial<ListAuthenticationsOptions>) => Promise<Authentication[]>;
 }

package/dist/functions/{listAuths → listAuthentications}/schemas.js

@@ -1,14 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ListAuthsSchema = void 0;
+exports.ListAuthenticationsSchema = void 0;
 const zod_1 = require("zod");
 const properties_1 = require("../../types/properties");
 const schema_utils_1 = require("../../schema-utils");
 const Auth_1 = require("../../schemas/Auth");
 // Pure Zod schema - no resolver metadata!
-exports.ListAuthsSchema = (0, schema_utils_1.withOutputSchema)(zod_1.z
+exports.ListAuthenticationsSchema = (0, schema_utils_1.withOutputSchema)(zod_1.z
     .object({
     appKey: properties_1.AppKeyPropertySchema.optional().describe("App slug to get authentications for (e.g., 'slack', 'github')"),
+    search: zod_1.z
+        .string()
+        .optional()
+        .describe("Search term to filter authentications by title"),
+    title: zod_1.z
+        .string()
+        .optional()
+        .describe("Filter authentications by exact title match"),
     account_id: zod_1.z.string().optional().describe("Filter by account ID"),
     owner: zod_1.z.string().optional().describe("Filter by owner"),
     limit: properties_1.LimitPropertySchema.optional().describe("Maximum number of items to return (1-200)"),

package/dist/index.d.ts

@@ -1,8 +1,11 @@
 export * from "./types/domain";
 export * from "./types/properties";
 export * from "./plugins/apps";
+export { isPositional } from "./schema-utils";
 export * from "./resolvers";
-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/dist/index.js

@@ -14,17 +14,24 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createZapierSdk = exports.bundleCode = exports.generateTypes = exports.listFields = exports.runAction = exports.getAction = exports.listActions = exports.getApp = exports.listApps = exports.listAuths = void 0;
+exports.createZapierSdk = exports.bundleCode = exports.generateTypes = exports.listFields = exports.runAction = exports.getAction = exports.listActions = exports.getApp = exports.listApps = exports.findUniqueAuthentication = exports.findFirstAuthentication = exports.listAuthentications = exports.isPositional = void 0;
 // Export everything from types and plugins
 __exportStar(require("./types/domain"), exports);
 __exportStar(require("./types/properties"), exports);
 __exportStar(require("./plugins/apps"), exports);
+// Export schema utilities for CLI
+var schema_utils_1 = require("./schema-utils");
+Object.defineProperty(exports, "isPositional", { enumerable: true, get: function () { return schema_utils_1.isPositional; } });
 // Export resolvers for CLI use
 __exportStar(require("./resolvers"), exports);
 // Note: SdkSchemas is now available via SDK.__registry
 // Export individual functions for tree-shaking
-var listAuths_1 = require("./functions/listAuths");
-Object.defineProperty(exports, "listAuths", { enumerable: true, get: function () { return listAuths_1.listAuths; } });
+var listAuthentications_1 = require("./functions/listAuthentications");
+Object.defineProperty(exports, "listAuthentications", { enumerable: true, get: function () { return listAuthentications_1.listAuthentications; } });
+var findFirstAuthentication_1 = require("./functions/findFirstAuthentication");
+Object.defineProperty(exports, "findFirstAuthentication", { enumerable: true, get: function () { return findFirstAuthentication_1.findFirstAuthentication; } });
+var findUniqueAuthentication_1 = require("./functions/findUniqueAuthentication");
+Object.defineProperty(exports, "findUniqueAuthentication", { enumerable: true, get: function () { return findUniqueAuthentication_1.findUniqueAuthentication; } });
 var listApps_1 = require("./functions/listApps");
 Object.defineProperty(exports, "listApps", { enumerable: true, get: function () { return listApps_1.listApps; } });
 var getApp_1 = require("./functions/getApp");

package/dist/resolvers/authenticationId.js

@@ -6,7 +6,7 @@ exports.authenticationIdResolver = {
     depends: ["appKey"],
     fetch: async (sdk, resolvedParams) => {
         // 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/dist/schema-utils.d.ts

@@ -37,3 +37,8 @@ export interface ResolverConfig {
 export declare function withResolver<T extends z.ZodType>(schema: T, config: ResolverConfig): T;
 export declare function getSchemaDescription(schema: z.ZodSchema): string | undefined;
 export declare function getFieldDescriptions(schema: z.ZodObject<any>): Record<string, string>;
+export interface PositionalMetadata {
+    positional: true;
+}
+export declare function withPositional<T extends z.ZodType>(schema: T): T;
+export declare function isPositional(schema: z.ZodType): boolean;

package/dist/schema-utils.js

@@ -7,6 +7,8 @@ exports.getOutputSchema = getOutputSchema;
 exports.withResolver = withResolver;
 exports.getSchemaDescription = getSchemaDescription;
 exports.getFieldDescriptions = getFieldDescriptions;
+exports.withPositional = withPositional;
+exports.isPositional = isPositional;
 const zod_1 = require("zod");
 // Helper function to add format metadata to schemas
 function withFormatter(schema, formatMeta) {
@@ -50,3 +52,25 @@ function getFieldDescriptions(schema) {
     }
     return descriptions;
 }
+// Helper function to mark a parameter as positional for CLI
+function withPositional(schema) {
+    // Store positional metadata on the schema definition
+    schema._def.positionalMeta = { positional: true };
+    return schema;
+}
+// Helper function to check if a parameter should be positional
+function isPositional(schema) {
+    // Check the current schema first
+    if (schema._def.positionalMeta?.positional) {
+        return true;
+    }
+    // If this is a ZodOptional, check the inner type
+    if (schema instanceof zod_1.z.ZodOptional) {
+        return isPositional(schema._def.innerType);
+    }
+    // If this is a ZodDefault, check the inner type
+    if (schema instanceof zod_1.z.ZodDefault) {
+        return isPositional(schema._def.innerType);
+    }
+    return false;
+}

package/dist/schemas/Auth.d.ts

@@ -2,7 +2,6 @@ import { z } from "zod";
 export declare const AuthItemSchema: z.ZodObject<{
     id: z.ZodNumber;
     title: z.ZodOptional<z.ZodString>;
-    label: z.ZodOptional<z.ZodString>;
     identifier: z.ZodOptional<z.ZodString>;
     account_id: z.ZodOptional<z.ZodString>;
     is_private: z.ZodOptional<z.ZodBoolean>;
@@ -11,7 +10,6 @@ export declare const AuthItemSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     id: number;
     title?: string | undefined;
-    label?: string | undefined;
     identifier?: string | undefined;
     account_id?: string | undefined;
     is_private?: boolean | undefined;
@@ -20,7 +18,6 @@ export declare const AuthItemSchema: z.ZodObject<{
 }, {
     id: number;
     title?: string | undefined;
-    label?: string | undefined;
     identifier?: string | undefined;
     account_id?: string | undefined;
     is_private?: boolean | undefined;