@zapier/zapier-sdk 0.4.1 → 0.5.1

package/dist/schemas/Field.d.ts

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

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

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

package/dist/schemas/Field.js

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

package/dist/schemas/UserProfile.d.ts

@@ -0,0 +1,163 @@
+import { z } from "zod";
+export { FormattedItem, FormatMetadata } from "../utils/schema-utils";
+export declare const UserProfileItemSchema: z.ZodObject<Omit<{
+    id: z.ZodNumber;
+    code: z.ZodString;
+    user_id: z.ZodNumber;
+    auto_provisioned: z.ZodBoolean;
+    first_name: z.ZodString;
+    last_name: z.ZodString;
+    username: z.ZodString;
+    personas: z.ZodString;
+    user_generated_personas: z.ZodString;
+    last_login: z.ZodString;
+    email: z.ZodString;
+    email_hash: z.ZodString;
+    email_confirmed: z.ZodBoolean;
+    timezone: z.ZodString;
+    photo_url: z.ZodString;
+    has_seen_notifications: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodBoolean>>;
+    signup: z.ZodString;
+    since_signup: z.ZodString;
+    has_activated: z.ZodBoolean;
+    enable_gz_creator: z.ZodBoolean;
+    should_see_nps_survey: z.ZodBoolean;
+    is_developer: z.ZodBoolean;
+    is_expert: z.ZodBoolean;
+    tos_agreement: z.ZodBoolean;
+    should_renew_tos: z.ZodBoolean;
+    is_gdpr_consented: z.ZodBoolean;
+    disable_ssl_check: z.ZodBoolean;
+    identity: z.ZodNumber;
+    summary_schedule: z.ZodString;
+    alert_triggers: z.ZodString;
+    alert_actions: z.ZodString;
+    is_staff: z.ZodBoolean;
+    is_zt_reviewer: z.ZodBoolean;
+    is_high_value: z.ZodBoolean;
+    is_temporary: z.ZodBoolean;
+    banner_message: z.ZodString;
+    enable_totp_2fa: z.ZodBoolean;
+    viewed_help: z.ZodRecord<z.ZodString, z.ZodBoolean>;
+    show_editor_migration_mesaging: z.ZodBoolean;
+    switches: z.ZodRecord<z.ZodString, z.ZodAny>;
+    organizations: z.ZodArray<z.ZodNullable<z.ZodAny>, "many">;
+    primary_organization: z.ZodNullable<z.ZodAny>;
+    has_active_zaps: z.ZodBoolean;
+    has_google_sso: z.ZodBoolean;
+    auth_realm: z.ZodString;
+    roles: z.ZodArray<z.ZodObject<{
+        account_id: z.ZodNumber;
+        role: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        account_id: number;
+        role: string;
+    }, {
+        account_id: number;
+        role: string;
+    }>, "many">;
+}, "user_id"> & {
+    full_name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    code: string;
+    id: number;
+    auto_provisioned: boolean;
+    first_name: string;
+    last_name: string;
+    username: string;
+    personas: string;
+    user_generated_personas: string;
+    last_login: string;
+    email_hash: string;
+    email_confirmed: boolean;
+    timezone: string;
+    photo_url: string;
+    has_seen_notifications: Record<string, boolean | null>;
+    signup: string;
+    since_signup: string;
+    has_activated: boolean;
+    enable_gz_creator: boolean;
+    should_see_nps_survey: boolean;
+    is_developer: boolean;
+    is_expert: boolean;
+    tos_agreement: boolean;
+    should_renew_tos: boolean;
+    is_gdpr_consented: boolean;
+    disable_ssl_check: boolean;
+    identity: number;
+    summary_schedule: string;
+    alert_triggers: string;
+    alert_actions: string;
+    is_staff: boolean;
+    is_zt_reviewer: boolean;
+    is_high_value: boolean;
+    is_temporary: boolean;
+    banner_message: string;
+    enable_totp_2fa: boolean;
+    viewed_help: Record<string, boolean>;
+    show_editor_migration_mesaging: boolean;
+    switches: Record<string, any>;
+    organizations: any[];
+    has_active_zaps: boolean;
+    has_google_sso: boolean;
+    auth_realm: string;
+    roles: {
+        account_id: number;
+        role: string;
+    }[];
+    full_name: string;
+    primary_organization?: any;
+}, {
+    email: string;
+    code: string;
+    id: number;
+    auto_provisioned: boolean;
+    first_name: string;
+    last_name: string;
+    username: string;
+    personas: string;
+    user_generated_personas: string;
+    last_login: string;
+    email_hash: string;
+    email_confirmed: boolean;
+    timezone: string;
+    photo_url: string;
+    has_seen_notifications: Record<string, boolean | null>;
+    signup: string;
+    since_signup: string;
+    has_activated: boolean;
+    enable_gz_creator: boolean;
+    should_see_nps_survey: boolean;
+    is_developer: boolean;
+    is_expert: boolean;
+    tos_agreement: boolean;
+    should_renew_tos: boolean;
+    is_gdpr_consented: boolean;
+    disable_ssl_check: boolean;
+    identity: number;
+    summary_schedule: string;
+    alert_triggers: string;
+    alert_actions: string;
+    is_staff: boolean;
+    is_zt_reviewer: boolean;
+    is_high_value: boolean;
+    is_temporary: boolean;
+    banner_message: string;
+    enable_totp_2fa: boolean;
+    viewed_help: Record<string, boolean>;
+    show_editor_migration_mesaging: boolean;
+    switches: Record<string, any>;
+    organizations: any[];
+    has_active_zaps: boolean;
+    has_google_sso: boolean;
+    auth_realm: string;
+    roles: {
+        account_id: number;
+        role: string;
+    }[];
+    full_name: string;
+    primary_organization?: any;
+}>;
+export type UserProfileItem = z.infer<typeof UserProfileItemSchema>;
+//# sourceMappingURL=UserProfile.d.ts.map

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

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

package/dist/schemas/UserProfile.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { withFormatter } from "../utils/schema-utils";
+import { UserProfileSchema } from "../api/schemas";
+// ============================================================================
+// User Profile Item Schema (extends API schema with computed fields and formatting)
+// ============================================================================
+export const UserProfileItemSchema = withFormatter(UserProfileSchema.omit({ user_id: true }).extend({
+    full_name: z.string(), // Computed field: first_name + " " + last_name
+}), {
+    format: (item) => {
+        const details = [];
+        details.push({ text: item.email, style: "dim" });
+        if (item.timezone) {
+            details.push({
+                text: `Timezone: ${item.timezone}`,
+                style: "accent",
+            });
+        }
+        details.push({
+            text: `Member since: ${item.since_signup}`,
+            style: "dim",
+        });
+        return {
+            title: item.full_name,
+            subtitle: `@${item.username}`,
+            details,
+        };
+    },
+});

package/dist/sdk.d.ts

@@ -0,0 +1,10 @@
+import { BaseSdkOptions } from "./types/sdk";
+import type { ZapierSdk } from "./types/sdk";
+import type { Sdk } from "./types/plugin";
+export interface ZapierSdkOptions extends BaseSdkOptions {
+}
+export declare function createSdk<TCurrentSdk = {}, TCurrentContext = {
+    meta: Record<string, any>;
+}>(initialSdk?: TCurrentSdk, initialContext?: TCurrentContext): Sdk<TCurrentSdk, TCurrentContext>;
+export declare function createZapierSdk(options?: ZapierSdkOptions): ZapierSdk;
+//# sourceMappingURL=sdk.d.ts.map

package/dist/sdk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk.d.ts","sourceRoot":"","sources":["../src/sdk.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAM7C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EACV,GAAG,EAIJ,MAAM,gBAAgB,CAAC;AAuBxB,MAAM,WAAW,gBAAiB,SAAQ,cAAc;CAAG;AAG3D,wBAAgB,SAAS,CACvB,WAAW,GAAG,EAAE,EAChB,eAAe,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAAE,EAE/C,UAAU,GAAE,WAA+B,EAC3C,cAAc,GAAE,eAAiD,GAChE,GAAG,CAAC,WAAW,EAAE,eAAe,CAAC,CAgEnC;AAED,wBAAgB,eAAe,CAAC,OAAO,GAAE,gBAAqB,GAAG,SAAS,CAmCzE"}

package/dist/sdk.js

@@ -0,0 +1,94 @@
+// Import plugin functions
+import { appsPlugin } from "./plugins/apps/index";
+import { fetchPlugin } from "./plugins/fetch/index";
+import { registryPlugin } from "./plugins/registry/index";
+import { apiPlugin } from "./plugins/api/index";
+import { getProfilePlugin } from "./plugins/getProfile";
+import { listAppsPlugin } from "./plugins/listApps";
+import { getAppPlugin } from "./plugins/getApp";
+import { listActionsPlugin } from "./plugins/listActions";
+import { getActionPlugin } from "./plugins/getAction";
+import { runActionPlugin } from "./plugins/runAction";
+import { listAuthenticationsPlugin } from "./plugins/listAuthentications";
+import { getAuthenticationPlugin } from "./plugins/getAuthentication";
+import { findFirstAuthenticationPlugin } from "./plugins/findFirstAuthentication";
+import { findUniqueAuthenticationPlugin } from "./plugins/findUniqueAuthentication";
+import { listInputFieldsPlugin } from "./plugins/listInputFields";
+import { requestPlugin } from "./plugins/request";
+// Create SDK that supports flat plugins - returns an SDK, not a builder
+export function createSdk(initialSdk = {}, initialContext = { meta: {} }) {
+    return {
+        ...initialSdk,
+        getContext: () => initialContext,
+        addPlugin(plugin, options = {}) {
+            // Create SDK with getContext method for plugins to use
+            const currentSdkWithContext = {
+                ...initialSdk,
+                getContext: () => initialContext,
+            };
+            // Apply the plugin with options merged in
+            const pluginResult = plugin({
+                sdk: currentSdkWithContext,
+                context: initialContext,
+                ...options,
+            });
+            // Extract context from plugin result if present
+            const { context: pluginContext, ...sdkProperties } = pluginResult;
+            // Merge SDK properties directly (flat structure)
+            const newSdk = { ...initialSdk, ...sdkProperties };
+            // Merge context additions if plugin returned any
+            // Ensure meta is always present, starting with existing or empty object
+            let newContext = {
+                ...initialContext,
+                meta: initialContext.meta || {},
+            };
+            if (pluginContext) {
+                // Extract meta from plugin context for special merging
+                const { meta: pluginMeta, ...otherPluginContext } = pluginContext;
+                newContext = {
+                    ...newContext,
+                    ...otherPluginContext,
+                };
+                // Merge meta separately to avoid overwriting
+                if (pluginMeta) {
+                    newContext = {
+                        ...newContext,
+                        meta: {
+                            ...newContext.meta, // Existing meta (now guaranteed to exist)
+                            ...pluginMeta, // New meta from plugin
+                        },
+                    };
+                }
+            }
+            // Recursively create new SDK with updated properties
+            return createSdk(newSdk, newContext);
+        },
+    };
+}
+export function createZapierSdk(options = {}) {
+    return (createSdk()
+        // Provides the API client in context
+        .addPlugin(apiPlugin, options)
+        // Apps/actions/fields
+        .addPlugin(listAppsPlugin)
+        .addPlugin(getAppPlugin)
+        .addPlugin(listActionsPlugin)
+        .addPlugin(getActionPlugin)
+        .addPlugin(listInputFieldsPlugin)
+        // Run action
+        .addPlugin(runActionPlugin)
+        // Authentications
+        .addPlugin(listAuthenticationsPlugin)
+        .addPlugin(getAuthenticationPlugin)
+        .addPlugin(findFirstAuthenticationPlugin)
+        .addPlugin(findUniqueAuthenticationPlugin)
+        // Relay fetching
+        .addPlugin(requestPlugin)
+        .addPlugin(fetchPlugin)
+        // Magic apps plugin
+        .addPlugin(appsPlugin)
+        // Profile
+        .addPlugin(getProfilePlugin)
+        // Register plugins for CLI/MCP metadata
+        .addPlugin(registryPlugin));
+}

package/dist/sdk.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sdk.test.d.ts.map

package/dist/sdk.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk.test.d.ts","sourceRoot":"","sources":["../src/sdk.test.ts"],"names":[],"mappings":""}