@superdurable/connector-insightly 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Super Durable
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,7 @@
-# Temporary Holding Version
+# Insightly TypeScript connector
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+This package implements `listContacts` and `getContact` for Dex TypeScript Flows. Both operations replay the Go reference's provider requests, branches, retries, and exact outputs through shared conformance scenarios. Results contain contact IDs, names, and email addresses; custom fields and links remain outside Flow results.
+
+Sign in to [Insightly CRM](https://login.insightly.com/), open the top-right user icon > **User Settings > User Settings > API**, and copy your personal API key into Dex secret `api_key`. Copy the pod-specific v3.1 API URL into `baseUrl` if it differs from the displayed na1 default. See the [connector README](../README.md) and [contact discovery example](examples/contact-discovery/README.md).
+
+JavaScript numbers cannot represent provider numeric IDs above the safe integer limit exactly; such responses select `invalidResponse`. Live Insightly authorization and responses have not been verified locally. Package release is independent of the Go and Python releases.

package/dex-connector.json

@@ -0,0 +1,119 @@
+{
+  "connectorId": "insightly",
+  "releaseTag": "connectors/insightly/go/v0.1.0",
+  "package": {
+    "ecosystem": "npm",
+    "name": "@superdurable/connector-insightly",
+    "version": "0.1.0"
+  },
+  "factories": [
+    {
+      "name": "newListContactsStep",
+      "kind": "query",
+      "operationId": "listContacts",
+      "inputType": "ListContactsInput",
+      "description": "List contact IDs, names, and email addresses with a bounded page size and offset.",
+      "fields": {
+        "stepType": "stepType",
+        "annotations": "annotations",
+        "connectionName": "connectionName",
+        "resultAttribute": "resultAttribute"
+      },
+      "branches": [
+        {
+          "id": "listed",
+          "field": "listed",
+          "optional": false
+        },
+        {
+          "id": "providerRejected",
+          "field": "providerRejected",
+          "optional": true
+        },
+        {
+          "id": "invalidResponse",
+          "field": "invalidResponse",
+          "optional": true
+        },
+        {
+          "id": "defect",
+          "field": "defect",
+          "optional": true
+        }
+      ],
+      "inputSchema": {
+        "additionalProperties": false,
+        "description": "ListContactsInput selects a bounded Insightly contact page.",
+        "properties": {
+          "skip": {
+            "description": "Skip is the nonnegative number of contacts to omit before this page.",
+            "type": "integer"
+          },
+          "top": {
+            "description": "Top is the maximum page size, from 1 to 500 records.",
+            "type": "integer"
+          }
+        },
+        "required": [
+          "skip",
+          "top"
+        ],
+        "type": "object"
+      }
+    },
+    {
+      "name": "newGetContactStep",
+      "kind": "query",
+      "operationId": "getContact",
+      "inputType": "GetContactInput",
+      "description": "Read a contact's ID, names, and email address by ID.",
+      "fields": {
+        "stepType": "stepType",
+        "annotations": "annotations",
+        "connectionName": "connectionName",
+        "resultAttribute": "resultAttribute"
+      },
+      "branches": [
+        {
+          "id": "found",
+          "field": "found",
+          "optional": false
+        },
+        {
+          "id": "notFound",
+          "field": "notFound",
+          "optional": true
+        },
+        {
+          "id": "providerRejected",
+          "field": "providerRejected",
+          "optional": true
+        },
+        {
+          "id": "invalidResponse",
+          "field": "invalidResponse",
+          "optional": true
+        },
+        {
+          "id": "defect",
+          "field": "defect",
+          "optional": true
+        }
+      ],
+      "inputSchema": {
+        "additionalProperties": false,
+        "description": "GetContactInput selects one Insightly contact by its numeric ID.",
+        "properties": {
+          "contactId": {
+            "description": "ContactID is the decimal ID shown in Insightly and returned by its API.",
+            "type": "string"
+          }
+        },
+        "required": [
+          "contactId"
+        ],
+        "type": "object"
+      }
+    }
+  ]
+}

package/dist/chunk-PTFX7RNO.js

@@ -0,0 +1,144 @@
+// src/generated/models.ts
+import { z } from "zod";
+import { SecretString } from "@superdurable/connectors-sdk";
+var ConfigSchema = z.object({
+  "baseUrl": z.string().optional(),
+  "timeoutMs": z.number().int().optional(),
+  "maxResponseBytes": z.number().int().optional()
+});
+function decodeCredentials(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError("credential fields are invalid");
+  const fields = value;
+  const allowed = /* @__PURE__ */ new Set(["api_key"]);
+  if (Object.keys(fields).some((key) => !allowed.has(key))) throw new TypeError("stored credential does not match the connector credential fields");
+  if (fields["api_key"] != null && !(typeof fields["api_key"] === "string")) throw new TypeError("credential api_key has an invalid type");
+  const credentials = {};
+  if (!fields["api_key"]) throw new TypeError("credential api_key is required");
+  credentials.apiKey = new SecretString(fields["api_key"] ?? "");
+  return credentials;
+}
+var ListContactsInputSchema = z.strictObject({
+  "top": z.number().int(),
+  "skip": z.number().int()
+});
+var ContactMetadataSchema = z.strictObject({
+  "id": z.number().int(),
+  "firstName": z.string(),
+  "lastName": z.string(),
+  "emailAddress": z.string()
+});
+var ContactsPageSchema = z.strictObject({
+  "contacts": z.array(ContactMetadataSchema).nullable()
+});
+var GetContactInputSchema = z.strictObject({
+  "contactId": z.string()
+});
+
+// src/generated/definitions.ts
+var ConnectorID = "insightly";
+var ProviderID = "insightly";
+var ListContactsBranch = {
+  Listed: "listed",
+  ProviderRejected: "providerRejected",
+  InvalidResponse: "invalidResponse",
+  Defect: "defect"
+};
+var ListContactsBranchListed = ListContactsBranch.Listed;
+var ListContactsBranchProviderRejected = ListContactsBranch.ProviderRejected;
+var ListContactsBranchInvalidResponse = ListContactsBranch.InvalidResponse;
+var ListContactsBranchDefect = ListContactsBranch.Defect;
+var ListContactsDefinition = {
+  operation: { connectorId: ConnectorID, operationId: "listContacts" },
+  branches: [
+    { id: "listed", description: "Insightly returned the requested contact page." },
+    { id: "providerRejected", description: "Insightly conclusively rejected the request.", optional: true },
+    { id: "invalidResponse", description: "Insightly returned malformed or oversized JSON.", optional: true },
+    { id: "defect", description: "Invalid page input or connection credentials.", optional: true }
+  ],
+  stepDefaults: { executeMethodTimeoutMs: 3e4, executeDurability: "async" }
+};
+var ListContactsMetadata = { kind: "query", idempotency: "none", authorization: "required" };
+var GetContactBranch = {
+  Found: "found",
+  NotFound: "notFound",
+  ProviderRejected: "providerRejected",
+  InvalidResponse: "invalidResponse",
+  Defect: "defect"
+};
+var GetContactBranchFound = GetContactBranch.Found;
+var GetContactBranchNotFound = GetContactBranch.NotFound;
+var GetContactBranchProviderRejected = GetContactBranch.ProviderRejected;
+var GetContactBranchInvalidResponse = GetContactBranch.InvalidResponse;
+var GetContactBranchDefect = GetContactBranch.Defect;
+var GetContactDefinition = {
+  operation: { connectorId: ConnectorID, operationId: "getContact" },
+  branches: [
+    { id: "found", description: "Insightly returned the selected contact." },
+    { id: "notFound", description: "No contact matches this ID.", optional: true },
+    { id: "providerRejected", description: "Insightly conclusively rejected the request.", optional: true },
+    { id: "invalidResponse", description: "Insightly returned malformed or oversized JSON.", optional: true },
+    { id: "defect", description: "Invalid contact ID or unavailable credentials.", optional: true }
+  ],
+  stepDefaults: { executeMethodTimeoutMs: 3e4, executeDurability: "async" }
+};
+var GetContactMetadata = { kind: "query", idempotency: "none", authorization: "required" };
+
+// src/generated/connection.ts
+import { ConnectionRefSchema } from "@superdurable/connectors-sdk";
+var Connection = class {
+  /** Stable provider and connection name. */
+  reference;
+  /** Bound provider operations. */
+  operations;
+  /** Validate a reference and bind operations. */
+  constructor(reference, operations) {
+    this.reference = ConnectionRefSchema.parse(reference);
+    if (this.reference.provider !== ProviderID) throw new TypeError("connection provider differs from the manifest");
+    if (!operations) throw new TypeError("connector operations are required");
+    this.operations = operations;
+  }
+};
+function newConnection(client, reference) {
+  if (!client) throw new TypeError("connector client is required");
+  return new Connection(reference, client);
+}
+function newConnectionWithOperations(operations, reference) {
+  return new Connection(reference, operations);
+}
+function newProjectConnection(project, connectionName, createClient) {
+  if (!project) throw new TypeError("loaded project is required");
+  const reference = ConnectionRefSchema.parse({ provider: ProviderID, name: connectionName });
+  const selected = project.configuration.connections.find((entry) => entry.connectorId === ConnectorID && entry.connectionName === connectionName);
+  if (!selected || selected.provider !== ProviderID) throw new TypeError("project connection is not configured");
+  return newConnection(createClient(project, connectionName), reference);
+}
+
+export {
+  ConfigSchema,
+  decodeCredentials,
+  ListContactsInputSchema,
+  ContactMetadataSchema,
+  ContactsPageSchema,
+  GetContactInputSchema,
+  ConnectorID,
+  ProviderID,
+  ListContactsBranch,
+  ListContactsBranchListed,
+  ListContactsBranchProviderRejected,
+  ListContactsBranchInvalidResponse,
+  ListContactsBranchDefect,
+  ListContactsDefinition,
+  ListContactsMetadata,
+  GetContactBranch,
+  GetContactBranchFound,
+  GetContactBranchNotFound,
+  GetContactBranchProviderRejected,
+  GetContactBranchInvalidResponse,
+  GetContactBranchDefect,
+  GetContactDefinition,
+  GetContactMetadata,
+  Connection,
+  newConnection,
+  newConnectionWithOperations,
+  newProjectConnection
+};

package/dist/connection-lTitKWJP.d.ts

@@ -0,0 +1,103 @@
+import { CredentialProvider, SecretString, Query, ConnectionRef } from '@superdurable/connectors-sdk';
+import { z } from 'zod';
+
+/** Connector configuration; omitted fields use manifest defaults. */
+interface Config {
+    /** HTTPS Insightly CRM API v3.1 root. In Insightly CRM at https://login.insightly.com/, open the top-right user icon > User Settings > User Settings > API and copy your API URL including its pod; blank uses the displayed na1 default only for na1 accounts. */
+    baseUrl?: string;
+    /** Maximum duration of one API request as a positive Go duration such as 15s or 1m. Blank uses the displayed default; increase for slow responses. Runtime value in milliseconds. */
+    timeoutMs?: number;
+    /** Positive maximum complete API response in bytes. Blank uses the displayed default; increase for large contact pages. Oversized responses select invalidResponse. */
+    maxResponseBytes?: number;
+}
+/** Runtime schema for manifest configuration. */
+declare const ConfigSchema: z.ZodObject<{
+    baseUrl: z.ZodOptional<z.ZodString>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    maxResponseBytes: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/** Private connector credentials resolved by the host. */
+interface Credentials {
+    /** Secret Insightly CRM API key. At https://login.insightly.com/, open the top-right user icon > User Settings > User Settings > API and copy the full key; blank makes calls select defect. Generate New API Key there to revoke the previous key. */
+    apiKey: SecretString;
+}
+/** Decode private credential fields for the connector. */
+declare function decodeCredentials(value: unknown): Credentials;
+/** Host-owned source of private connector credentials. */
+type CredentialSource = CredentialProvider<Credentials>;
+/** ListContactsInput selects a bounded Insightly contact page. */
+interface ListContactsInput {
+    /** Top is the maximum page size, from 1 to 500 records. */
+    "top": number;
+    /** Skip is the nonnegative number of contacts to omit before this page. */
+    "skip": number;
+}
+/** ContactMetadata contains public contact identity without custom fields or links. */
+interface ContactMetadata {
+    /** ID is the stable Insightly contact identifier. */
+    "id": number;
+    /** FirstName is the contact's given name when available. */
+    "firstName": string;
+    /** LastName is the contact's family name when available. */
+    "lastName": string;
+    /** EmailAddress is the contact's primary email address when available. */
+    "emailAddress": string;
+}
+/** ContactsPage contains the requested contact page. */
+interface ContactsPage {
+    /** Contacts contains only contact identity fields. */
+    "contacts": Array<ContactMetadata> | null;
+}
+/** GetContactInput selects one Insightly contact by its numeric ID. */
+interface GetContactInput {
+    /** ContactID is the decimal ID shown in Insightly and returned by its API. */
+    "contactId": string;
+}
+/** Runtime validator for ListContactsInput. */
+declare const ListContactsInputSchema: z.ZodObject<{
+    top: z.ZodNumber;
+    skip: z.ZodNumber;
+}, z.core.$strict>;
+/** Runtime validator for ContactMetadata. */
+declare const ContactMetadataSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    firstName: z.ZodString;
+    lastName: z.ZodString;
+    emailAddress: z.ZodString;
+}, z.core.$strict>;
+/** Runtime validator for ContactsPage. */
+declare const ContactsPageSchema: z.ZodObject<{
+    contacts: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        firstName: z.ZodString;
+        lastName: z.ZodString;
+        emailAddress: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+/** Runtime validator for GetContactInput. */
+declare const GetContactInputSchema: z.ZodObject<{
+    contactId: z.ZodString;
+}, z.core.$strict>;
+
+/** Typed operations supplied by a client or mock. */
+interface Operations {
+    /** Invoke listContacts through this connection. */
+    listContacts(): Query<ListContactsInput, ContactsPage>;
+    /** Invoke getContact through this connection. */
+    getContact(): Query<GetContactInput, ContactMetadata>;
+}
+/** Named connector connection kept outside Flow state. */
+declare class Connection<BoundOperations = Operations> {
+    /** Stable provider and connection name. */
+    readonly reference: ConnectionRef;
+    /** Bound provider operations. */
+    readonly operations: BoundOperations;
+    /** Validate a reference and bind operations. */
+    constructor(reference: ConnectionRef, operations: BoundOperations);
+}
+/** Bind a client to a named connection. */
+declare function newConnection(client: Operations, reference: ConnectionRef): Connection;
+/** Bind scripted operations to a named connection. */
+declare function newConnectionWithOperations(operations: Operations, reference: ConnectionRef): Connection;
+
+export { type ContactMetadata as C, type GetContactInput as G, type ListContactsInput as L, type Operations as O, Connection as a, type ContactsPage as b, type Config as c, type Credentials as d, ConfigSchema as e, ContactMetadataSchema as f, ContactsPageSchema as g, type CredentialSource as h, GetContactInputSchema as i, ListContactsInputSchema as j, decodeCredentials as k, newConnectionWithOperations as l, newConnection as n };

package/dist/index.d.ts

@@ -0,0 +1,149 @@
+import { G as GetContactInput, C as ContactMetadata, a as Connection, L as ListContactsInput, b as ContactsPage, O as Operations, c as Config, d as Credentials } from './connection-lTitKWJP.js';
+export { e as ConfigSchema, f as ContactMetadataSchema, g as ContactsPageSchema, h as CredentialSource, i as GetContactInputSchema, j as ListContactsInputSchema, k as decodeCredentials, n as newConnection, l as newConnectionWithOperations } from './connection-lTitKWJP.js';
+import { QueryDefinition, QueryStepConfig, Query, QueryResult, QueryStep, CredentialProvider, Call, QueryAttempt, Failure } from '@superdurable/connectors-sdk';
+import { StepTarget } from '@superdurable/dex';
+import { LoadedProject } from '@superdurable/connectors-sdk/projectconfig';
+import { ProviderRequest, ProviderResponse } from '@superdurable/connectors-sdk/providerhttp';
+import 'zod';
+
+/** Stable connector identity. */
+declare const ConnectorID = "insightly";
+/** Provider identity for named connections. */
+declare const ProviderID = "insightly";
+/** Branch IDs for listContacts. */
+declare const ListContactsBranch: {
+    readonly Listed: "listed";
+    readonly ProviderRejected: "providerRejected";
+    readonly InvalidResponse: "invalidResponse";
+    readonly Defect: "defect";
+};
+/** Insightly returned the requested contact page. */
+declare const ListContactsBranchListed: "listed";
+/** Insightly conclusively rejected the request. */
+declare const ListContactsBranchProviderRejected: "providerRejected";
+/** Insightly returned malformed or oversized JSON. */
+declare const ListContactsBranchInvalidResponse: "invalidResponse";
+/** Invalid page input or connection credentials. */
+declare const ListContactsBranchDefect: "defect";
+/** Manifest definition for listContacts. */
+declare const ListContactsDefinition: QueryDefinition;
+/** Manifest metadata for listContacts. */
+declare const ListContactsMetadata: {
+    readonly kind: "query";
+    readonly idempotency: "none";
+    readonly authorization: "required";
+};
+/** Branch IDs for getContact. */
+declare const GetContactBranch: {
+    readonly Found: "found";
+    readonly NotFound: "notFound";
+    readonly ProviderRejected: "providerRejected";
+    readonly InvalidResponse: "invalidResponse";
+    readonly Defect: "defect";
+};
+/** Insightly returned the selected contact. */
+declare const GetContactBranchFound: "found";
+/** No contact matches this ID. */
+declare const GetContactBranchNotFound: "notFound";
+/** Insightly conclusively rejected the request. */
+declare const GetContactBranchProviderRejected: "providerRejected";
+/** Insightly returned malformed or oversized JSON. */
+declare const GetContactBranchInvalidResponse: "invalidResponse";
+/** Invalid contact ID or unavailable credentials. */
+declare const GetContactBranchDefect: "defect";
+/** Manifest definition for getContact. */
+declare const GetContactDefinition: QueryDefinition;
+/** Manifest metadata for getContact. */
+declare const GetContactMetadata: {
+    readonly kind: "query";
+    readonly idempotency: "none";
+    readonly authorization: "required";
+};
+
+/** Configuration for the listContacts connector Step. */
+interface ListContactsStepConfig<StepInput, OperationInput = ListContactsInput, OperationOutput = ContactsPage> extends Omit<QueryStepConfig<StepInput, OperationInput, OperationOutput>, 'operation' | 'connection' | 'branches'> {
+    /** Named connection supplying this operation. */
+    connection: Connection<{
+        listContacts(): Query<OperationInput, OperationOutput>;
+    }>;
+    /** Name matching the bound connection. */
+    connectionName: string;
+    /** Insightly returned the requested contact page. */
+    listed: StepTarget<QueryResult<OperationOutput>>;
+    /** Insightly conclusively rejected the request. */
+    providerRejected?: StepTarget<QueryResult<OperationOutput>>;
+    /** Insightly returned malformed or oversized JSON. */
+    invalidResponse?: StepTarget<QueryResult<OperationOutput>>;
+    /** Invalid page input or connection credentials. */
+    defect?: StepTarget<QueryResult<OperationOutput>>;
+}
+/** Build the listContacts Step from a named connection. */
+declare function newListContactsStep<StepInput, OperationInput = ListContactsInput, OperationOutput = ContactsPage>(configuration: ListContactsStepConfig<StepInput, OperationInput, OperationOutput>): QueryStep<StepInput, OperationInput, OperationOutput>;
+/** Configuration for the getContact connector Step. */
+interface GetContactStepConfig<StepInput, OperationInput = GetContactInput, OperationOutput = ContactMetadata> extends Omit<QueryStepConfig<StepInput, OperationInput, OperationOutput>, 'operation' | 'connection' | 'branches'> {
+    /** Named connection supplying this operation. */
+    connection: Connection<{
+        getContact(): Query<OperationInput, OperationOutput>;
+    }>;
+    /** Name matching the bound connection. */
+    connectionName: string;
+    /** Insightly returned the selected contact. */
+    found: StepTarget<QueryResult<OperationOutput>>;
+    /** No contact matches this ID. */
+    notFound?: StepTarget<QueryResult<OperationOutput>>;
+    /** Insightly conclusively rejected the request. */
+    providerRejected?: StepTarget<QueryResult<OperationOutput>>;
+    /** Insightly returned malformed or oversized JSON. */
+    invalidResponse?: StepTarget<QueryResult<OperationOutput>>;
+    /** Invalid contact ID or unavailable credentials. */
+    defect?: StepTarget<QueryResult<OperationOutput>>;
+}
+/** Build the getContact Step from a named connection. */
+declare function newGetContactStep<StepInput, OperationInput = GetContactInput, OperationOutput = ContactMetadata>(configuration: GetContactStepConfig<StepInput, OperationInput, OperationOutput>): QueryStep<StepInput, OperationInput, OperationOutput>;
+
+/** Open one named Insightly connection from Dex project configuration. */
+declare function newProjectConnection(project: LoadedProject, connectionName: string): Connection<Operations>;
+
+/** Optional transport dependency for provider tests and local Dex examples. */
+interface InsightlyClientOptions {
+    /** One bounded provider request sender. */ send?: (request: ProviderRequest) => Promise<ProviderResponse>;
+}
+interface ProviderOutcome {
+    body?: Uint8Array;
+    branch?: string;
+    failure?: Failure;
+    retry?: boolean;
+    retryAfterMs?: number;
+}
+/** Authenticated Insightly CRM API v3.1 client with call-time credential resolution. */
+declare class InsightlyClient {
+    private readonly credentials;
+    private readonly baseUrl;
+    private readonly timeoutMs;
+    private readonly maxResponseBytes;
+    private readonly sendRequest;
+    /** Validate connection configuration without contacting Insightly. */
+    constructor(config: Config, credentials: CredentialProvider<Credentials>, options?: InsightlyClientOptions);
+    /** Bind the contact page Query. */ listContacts(): ListContactsOperation;
+    /** Bind the contact metadata Query. */ getContact(): GetContactOperation;
+    /** Send one read and classify transport, HTTP, and response-size outcomes. */
+    exchange(call: Call, operation: string, path: string, hasNotFound: boolean): Promise<ProviderOutcome>;
+}
+/** List Insightly contact IDs, names, and email addresses. */
+declare class ListContactsOperation implements Query<ListContactsInput, ContactsPage> {
+    private readonly client;
+    /** Bind the provider client. */ constructor(client: InsightlyClient);
+    /** Return the manifest-generated operation definition. */ definition(): QueryDefinition;
+    /** Read a bounded contact page. */
+    invoke(call: Call, input: ListContactsInput): Promise<QueryAttempt<ContactsPage>>;
+}
+/** Read one Insightly contact's identity without custom fields. */
+declare class GetContactOperation implements Query<GetContactInput, ContactMetadata> {
+    private readonly client;
+    /** Bind the provider client. */ constructor(client: InsightlyClient);
+    /** Return the manifest-generated operation definition. */ definition(): QueryDefinition;
+    /** Validate the contact ID and read its metadata. */
+    invoke(call: Call, input: GetContactInput): Promise<QueryAttempt<ContactMetadata>>;
+}
+
+export { Config, Connection, ConnectorID, ContactMetadata, ContactsPage, Credentials, GetContactBranch, GetContactBranchDefect, GetContactBranchFound, GetContactBranchInvalidResponse, GetContactBranchNotFound, GetContactBranchProviderRejected, GetContactDefinition, GetContactInput, GetContactMetadata, GetContactOperation, type GetContactStepConfig, InsightlyClient, type InsightlyClientOptions, ListContactsBranch, ListContactsBranchDefect, ListContactsBranchInvalidResponse, ListContactsBranchListed, ListContactsBranchProviderRejected, ListContactsDefinition, ListContactsInput, ListContactsMetadata, ListContactsOperation, type ListContactsStepConfig, ProviderID, newGetContactStep, newListContactsStep, newProjectConnection };

package/dist/index.js

@@ -0,0 +1,286 @@
+import {
+  ConfigSchema,
+  Connection,
+  ConnectorID,
+  ContactMetadataSchema,
+  ContactsPageSchema,
+  GetContactBranch,
+  GetContactBranchDefect,
+  GetContactBranchFound,
+  GetContactBranchInvalidResponse,
+  GetContactBranchNotFound,
+  GetContactBranchProviderRejected,
+  GetContactDefinition,
+  GetContactInputSchema,
+  GetContactMetadata,
+  ListContactsBranch,
+  ListContactsBranchDefect,
+  ListContactsBranchInvalidResponse,
+  ListContactsBranchListed,
+  ListContactsBranchProviderRejected,
+  ListContactsDefinition,
+  ListContactsInputSchema,
+  ListContactsMetadata,
+  ProviderID,
+  decodeCredentials,
+  newConnection,
+  newConnectionWithOperations,
+  newProjectConnection
+} from "./chunk-PTFX7RNO.js";
+
+// src/generated/steps.ts
+import { goToBranch, newQueryStep } from "@superdurable/connectors-sdk";
+function newListContactsStep(configuration) {
+  const { connection, connectionName, listed, providerRejected, invalidResponse, defect, ...stepConfiguration } = configuration;
+  if (!connection || connection.reference.name !== connectionName) throw new TypeError("Step connection name differs from the bound connection");
+  return newQueryStep({ ...stepConfiguration, operation: connection.operations.listContacts(), connection: connection.reference, branches: [
+    goToBranch("listed", listed),
+    ...providerRejected ? [goToBranch("providerRejected", providerRejected)] : [],
+    ...invalidResponse ? [goToBranch("invalidResponse", invalidResponse)] : [],
+    ...defect ? [goToBranch("defect", defect)] : []
+  ] });
+}
+function newGetContactStep(configuration) {
+  const { connection, connectionName, found, notFound, providerRejected, invalidResponse, defect, ...stepConfiguration } = configuration;
+  if (!connection || connection.reference.name !== connectionName) throw new TypeError("Step connection name differs from the bound connection");
+  return newQueryStep({ ...stepConfiguration, operation: connection.operations.getContact(), connection: connection.reference, branches: [
+    goToBranch("found", found),
+    ...notFound ? [goToBranch("notFound", notFound)] : [],
+    ...providerRejected ? [goToBranch("providerRejected", providerRejected)] : [],
+    ...invalidResponse ? [goToBranch("invalidResponse", invalidResponse)] : [],
+    ...defect ? [goToBranch("defect", defect)] : []
+  ] });
+}
+
+// src/project.ts
+import { SecretString as SecretString2 } from "@superdurable/connectors-sdk";
+import { z } from "zod";
+
+// src/client.ts
+import { SecretString, newQueryBranch, newQueryRetry } from "@superdurable/connectors-sdk";
+import { BodyTooLargeError, isHeaderSafeCredential, parseRetryAfter, sendProviderRequest, validateBaseURL } from "@superdurable/connectors-sdk/providerhttp";
+var emptyPage = () => ({ contacts: [] });
+var emptyContact = () => ({ id: 0, firstName: "", lastName: "", emailAddress: "" });
+var userAgent = "Dex Connector (https://superdurable.io)";
+var InsightlyClient = class {
+  /** Validate connection configuration without contacting Insightly. */
+  constructor(config, credentials, options = {}) {
+    this.credentials = credentials;
+    if (!credentials) throw new TypeError("Insightly credential source is required");
+    this.baseUrl = validateBaseURL(config.baseUrl || "https://api.na1.insightly.com/v3.1");
+    this.timeoutMs = config.timeoutMs || 15e3;
+    this.maxResponseBytes = config.maxResponseBytes || 1048576;
+    if (!Number.isSafeInteger(this.timeoutMs) || this.timeoutMs <= 0) throw new TypeError("Insightly timeout is invalid");
+    if (!Number.isSafeInteger(this.maxResponseBytes) || this.maxResponseBytes <= 0) throw new TypeError("Insightly response limit is invalid");
+    this.sendRequest = options.send ?? sendProviderRequest;
+  }
+  credentials;
+  baseUrl;
+  timeoutMs;
+  maxResponseBytes;
+  sendRequest;
+  /** Bind the contact page Query. */
+  listContacts() {
+    return new ListContactsOperation(this);
+  }
+  /** Bind the contact metadata Query. */
+  getContact() {
+    return new GetContactOperation(this);
+  }
+  /** Send one read and classify transport, HTTP, and response-size outcomes. */
+  async exchange(call, operation, path, hasNotFound) {
+    let apiKey;
+    try {
+      const resolved = await this.credentials.resolve(call, call.context.cancellationSignal);
+      apiKey = resolved.apiKey instanceof SecretString ? resolved.apiKey.reveal() : "";
+    } catch {
+      return { branch: "defect", failure: failure(operation, "AUTHENTICATION", "connection credentials are unavailable or invalid") };
+    }
+    if (!isHeaderSafeCredential(apiKey)) return { branch: "defect", failure: failure(operation, "AUTHENTICATION", "connection credentials are unavailable or invalid") };
+    const request = {
+      url: `${this.baseUrl}${path}`,
+      method: "GET",
+      headers: { Accept: "application/json", Authorization: `Basic ${Buffer.from(`${apiKey}:`).toString("base64")}`, "User-Agent": userAgent },
+      maxResponseBytes: this.maxResponseBytes,
+      timeoutMs: this.timeoutMs,
+      addressPolicy: this.baseUrl.startsWith("https://") ? "publicHTTPS" : "privateNetworkHTTP",
+      signal: call.context.cancellationSignal
+    };
+    let response;
+    try {
+      response = await this.sendRequest(request);
+    } catch (error) {
+      if (error instanceof BodyTooLargeError && error.status !== void 0) {
+        response = { status: error.status, headers: error.headers ?? {}, body: new Uint8Array() };
+        if (response.status === 200) return { branch: "invalidResponse", failure: failure(operation, "RESPONSE_TOO_LARGE", "Insightly response exceeded the configured limit") };
+      } else return { retry: true, failure: failure(operation, "TRANSPORT", "Insightly request failed") };
+    }
+    const status = response.status;
+    const retryAfter = parseRetryAfter(headerValue(response.headers["retry-after"]));
+    if (status === 429) return { retry: true, retryAfterMs: retryAfter, failure: failure(operation, "RATE_LIMIT", "Insightly rate limited the request") };
+    if (status === 408 || status >= 500) return { retry: true, retryAfterMs: retryAfter, failure: failure(operation, "AVAILABILITY", "Insightly is temporarily unavailable") };
+    if (status === 404 && hasNotFound) return { branch: "notFound", failure: failure(operation, "NOT_FOUND", "Insightly did not find the resource") };
+    if (status !== 200) return { branch: "providerRejected", failure: failure(operation, "PROVIDER_REJECTION", `Insightly rejected HTTP ${status}`) };
+    if (response.body.length > this.maxResponseBytes) return { branch: "invalidResponse", failure: failure(operation, "RESPONSE_TOO_LARGE", "Insightly response exceeded the configured limit") };
+    return { body: response.body };
+  }
+};
+var ListContactsOperation = class {
+  /** Bind the provider client. */
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Return the manifest-generated operation definition. */
+  definition() {
+    return ListContactsDefinition;
+  }
+  /** Read a bounded contact page. */
+  async invoke(call, input) {
+    if (!input || !Number.isSafeInteger(input.top) || input.top < 1 || input.top > 500 || !Number.isSafeInteger(input.skip) || input.skip < 0) return terminal("listContacts", "defect", "VALIDATION", "contact page size or offset is invalid", emptyPage());
+    const result = await this.client.exchange(call, "listContacts", `/Contacts?skip=${input.skip}&top=${input.top}`, false);
+    if (result.retry) return newQueryRetry(result.failure, result.retryAfterMs);
+    if (result.failure) return newQueryBranch(result.branch, emptyPage(), {}, result.failure);
+    const document = parseJSON(result.body);
+    if (!Array.isArray(document)) return invalid("listContacts", emptyPage());
+    const contacts = [];
+    for (const item of document) {
+      const contact = decodeContact(item);
+      if (!contact) return invalid("listContacts", emptyPage());
+      contacts.push(contact);
+    }
+    return newQueryBranch("listed", { contacts });
+  }
+};
+var GetContactOperation = class {
+  /** Bind the provider client. */
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Return the manifest-generated operation definition. */
+  definition() {
+    return GetContactDefinition;
+  }
+  /** Validate the contact ID and read its metadata. */
+  async invoke(call, input) {
+    if (!isValidContactID(input)) return terminal("getContact", "defect", "VALIDATION", "contact ID must be a positive decimal identifier", emptyContact());
+    const result = await this.client.exchange(call, "getContact", `/Contacts/${input.contactId}`, true);
+    if (result.retry) return newQueryRetry(result.failure, result.retryAfterMs);
+    if (result.failure) return newQueryBranch(result.branch, emptyContact(), {}, result.failure);
+    const contact = decodeContact(parseJSON(result.body));
+    if (!contact) return invalid("getContact", emptyContact());
+    return newQueryBranch("found", contact);
+  }
+};
+function isValidContactID(input) {
+  if (!input || typeof input.contactId !== "string" || !/^[0-9]+$/.test(input.contactId)) return false;
+  const significantDigits = input.contactId.replace(/^0+/, "");
+  return significantDigits.length > 0 && significantDigits.length <= 19 && BigInt(significantDigits) <= 9223372036854775807n;
+}
+function decodeContact(value) {
+  if (!isObject(value) || !isPositiveSafeInteger(value.CONTACT_ID)) return void 0;
+  const firstName = optionalString(value.FIRST_NAME);
+  const lastName = optionalString(value.LAST_NAME);
+  const emailAddress = optionalString(value.EMAIL_ADDRESS);
+  if (firstName === void 0 || lastName === void 0 || emailAddress === void 0) return void 0;
+  return { id: value.CONTACT_ID, firstName, lastName, emailAddress };
+}
+function optionalString(value) {
+  return value === void 0 || value === null ? "" : typeof value === "string" ? value : void 0;
+}
+function isPositiveSafeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function failure(operation, kind, message) {
+  return { provider: "insightly", operation, kind, message };
+}
+function terminal(operation, branch, kind, message, empty) {
+  return newQueryBranch(branch, empty, {}, failure(operation, kind, message));
+}
+function invalid(operation, empty) {
+  return terminal(operation, "invalidResponse", "PROTOCOL", "Insightly returned invalid JSON", empty);
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseJSON(body) {
+  try {
+    return JSON.parse(Buffer.from(body).toString("utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function headerValue(value) {
+  return Array.isArray(value) ? value[0] ?? "" : value ?? "";
+}
+
+// src/project.ts
+function newProjectConnection2(project, connectionName) {
+  return newProjectConnection(project, connectionName, (loadedProject, name) => {
+    const selected = loadedProject.configuration.connections.find((entry) => entry.connectorId === "insightly" && entry.connectionName === name);
+    if (!selected) throw new TypeError("Insightly project connection is not configured");
+    const fields = z.strictObject({ baseUrl: z.string().optional(), timeout: z.union([z.string(), z.number().int()]).optional(), maxResponseBytes: z.number().int().optional() }).parse(selected.configuration);
+    const timeoutMs = typeof fields.timeout === "number" ? Math.ceil(fields.timeout / 1e6) : fields.timeout ? parseDurationMilliseconds(fields.timeout) : void 0;
+    const config = {
+      ...fields.baseUrl ? { baseUrl: fields.baseUrl } : {},
+      ...timeoutMs !== void 0 ? { timeoutMs } : {},
+      ...fields.maxResponseBytes !== void 0 ? { maxResponseBytes: fields.maxResponseBytes } : {}
+    };
+    const credentials = {
+      async resolve(_call, signal) {
+        const privateFields = await loadedProject.resolveCredential("insightly", name, signal);
+        if (typeof privateFields.api_key !== "string") throw new TypeError("Insightly credentials are unavailable");
+        return { apiKey: new SecretString2(privateFields.api_key) };
+      }
+    };
+    return new InsightlyClient(config, credentials);
+  });
+}
+function parseDurationMilliseconds(value) {
+  let remaining = value;
+  let milliseconds = 0;
+  const units = { ns: 1e-6, us: 1e-3, "\xB5s": 1e-3, ms: 1, s: 1e3, m: 6e4, h: 36e5 };
+  while (remaining) {
+    const part = /^(\d+(?:\.\d+)?)(ns|us|µs|ms|s|m|h)/.exec(remaining);
+    if (!part) throw new TypeError("Insightly timeout must be a positive Go duration");
+    milliseconds += Number(part[1]) * (units[part[2] ?? ""] ?? NaN);
+    remaining = remaining.slice(part[0].length);
+  }
+  if (!Number.isSafeInteger(milliseconds) || milliseconds <= 0) throw new TypeError("Insightly timeout must resolve to positive whole milliseconds");
+  return milliseconds;
+}
+export {
+  ConfigSchema,
+  Connection,
+  ConnectorID,
+  ContactMetadataSchema,
+  ContactsPageSchema,
+  GetContactBranch,
+  GetContactBranchDefect,
+  GetContactBranchFound,
+  GetContactBranchInvalidResponse,
+  GetContactBranchNotFound,
+  GetContactBranchProviderRejected,
+  GetContactDefinition,
+  GetContactInputSchema,
+  GetContactMetadata,
+  GetContactOperation,
+  InsightlyClient,
+  ListContactsBranch,
+  ListContactsBranchDefect,
+  ListContactsBranchInvalidResponse,
+  ListContactsBranchListed,
+  ListContactsBranchProviderRejected,
+  ListContactsDefinition,
+  ListContactsInputSchema,
+  ListContactsMetadata,
+  ListContactsOperation,
+  ProviderID,
+  decodeCredentials,
+  newConnection,
+  newConnectionWithOperations,
+  newGetContactStep,
+  newListContactsStep,
+  newProjectConnection2 as newProjectConnection
+};

package/dist/mock.d.ts

@@ -0,0 +1,54 @@
+import { MockQuery, Case } from '@superdurable/connectors-sdk/connectormock';
+import { Failure } from '@superdurable/connectors-sdk';
+import { O as Operations, a as Connection, L as ListContactsInput, b as ContactsPage, G as GetContactInput, C as ContactMetadata } from './connection-lTitKWJP.js';
+import 'zod';
+
+/** Go zero value for ListContactsInput in scripted cases. */
+declare const emptyListContactsInput: ListContactsInput;
+/** Go zero value for ContactMetadata in scripted cases. */
+declare const emptyContactMetadata: ContactMetadata;
+/** Go zero value for ContactsPage in scripted cases. */
+declare const emptyContactsPage: ContactsPage;
+/** Go zero value for GetContactInput in scripted cases. */
+declare const emptyGetContactInput: GetContactInput;
+/** Script the listed branch. */
+declare function listContactsListed(value: ContactsPage, failure?: Failure): Case<ContactsPage>;
+/** Script the providerRejected branch. */
+declare function listContactsProviderRejected(value: ContactsPage, failure?: Failure): Case<ContactsPage>;
+/** Script the invalidResponse branch. */
+declare function listContactsInvalidResponse(value: ContactsPage, failure?: Failure): Case<ContactsPage>;
+/** Script the defect branch. */
+declare function listContactsDefect(value: ContactsPage, failure?: Failure): Case<ContactsPage>;
+/** Script a safe retry of listContacts. */
+declare function listContactsRetry(failure: Failure, retryAfterMs?: number): Case<ContactsPage>;
+/** Manifest scenario listedDefault for listContacts. */
+declare function listContactsListedDefault(): Case<ContactsPage>;
+/** Default listContacts scenario. */
+declare function listContactsDefault(): Case<ContactsPage>;
+/** Script the found branch. */
+declare function getContactFound(value: ContactMetadata, failure?: Failure): Case<ContactMetadata>;
+/** Script the notFound branch. */
+declare function getContactNotFound(value: ContactMetadata, failure?: Failure): Case<ContactMetadata>;
+/** Script the providerRejected branch. */
+declare function getContactProviderRejected(value: ContactMetadata, failure?: Failure): Case<ContactMetadata>;
+/** Script the invalidResponse branch. */
+declare function getContactInvalidResponse(value: ContactMetadata, failure?: Failure): Case<ContactMetadata>;
+/** Script the defect branch. */
+declare function getContactDefect(value: ContactMetadata, failure?: Failure): Case<ContactMetadata>;
+/** Script a safe retry of getContact. */
+declare function getContactRetry(failure: Failure, retryAfterMs?: number): Case<ContactMetadata>;
+/** Manifest scenario foundDefault for getContact. */
+declare function getContactFoundDefault(): Case<ContactMetadata>;
+/** Default getContact scenario. */
+declare function getContactDefault(): Case<ContactMetadata>;
+/** Scripted operations and manifest defaults for this connector. */
+declare class GeneratedMock implements Operations {
+    #private;
+    constructor(connectionName: string);
+    connection(): Connection;
+    listContacts(): MockQuery<ListContactsInput, ContactsPage>;
+    getContact(): MockQuery<GetContactInput, ContactMetadata>;
+    assertNoFailures(): void;
+}
+
+export { GeneratedMock, GeneratedMock as Mock, emptyContactMetadata, emptyContactsPage, emptyGetContactInput, emptyListContactsInput, getContactDefault, getContactDefect, getContactFound, getContactFoundDefault, getContactInvalidResponse, getContactNotFound, getContactProviderRejected, getContactRetry, listContactsDefault, listContactsDefect, listContactsInvalidResponse, listContactsListed, listContactsListedDefault, listContactsProviderRejected, listContactsRetry };

package/dist/mock.js

@@ -0,0 +1,122 @@
+import {
+  ContactMetadataSchema,
+  ContactsPageSchema,
+  GetContactDefinition,
+  GetContactInputSchema,
+  ListContactsDefinition,
+  ListContactsInputSchema,
+  ProviderID,
+  newConnectionWithOperations
+} from "./chunk-PTFX7RNO.js";
+
+// src/generated/mock.ts
+import { branchCase, retryCase, newQuery } from "@superdurable/connectors-sdk/connectormock";
+var emptyListContactsInput = ListContactsInputSchema.parse({
+  "top": 0,
+  "skip": 0
+});
+var emptyContactMetadata = ContactMetadataSchema.parse({
+  "id": 0,
+  "firstName": "",
+  "lastName": "",
+  "emailAddress": ""
+});
+var emptyContactsPage = ContactsPageSchema.parse({
+  "contacts": []
+});
+var emptyGetContactInput = GetContactInputSchema.parse({
+  "contactId": ""
+});
+function listContactsListed(value, failure) {
+  return branchCase("listed", value, failure);
+}
+function listContactsProviderRejected(value, failure) {
+  return branchCase("providerRejected", value, failure);
+}
+function listContactsInvalidResponse(value, failure) {
+  return branchCase("invalidResponse", value, failure);
+}
+function listContactsDefect(value, failure) {
+  return branchCase("defect", value, failure);
+}
+function listContactsRetry(failure, retryAfterMs = 0) {
+  return retryCase(failure, retryAfterMs);
+}
+function listContactsListedDefault() {
+  const value = ContactsPageSchema.parse({ "contacts": [{ "emailAddress": "ada@example.com", "firstName": "Ada", "id": 45678, "lastName": "Lovelace" }] });
+  return branchCase("listed", value);
+}
+function listContactsDefault() {
+  return listContactsListedDefault();
+}
+function getContactFound(value, failure) {
+  return branchCase("found", value, failure);
+}
+function getContactNotFound(value, failure) {
+  return branchCase("notFound", value, failure);
+}
+function getContactProviderRejected(value, failure) {
+  return branchCase("providerRejected", value, failure);
+}
+function getContactInvalidResponse(value, failure) {
+  return branchCase("invalidResponse", value, failure);
+}
+function getContactDefect(value, failure) {
+  return branchCase("defect", value, failure);
+}
+function getContactRetry(failure, retryAfterMs = 0) {
+  return retryCase(failure, retryAfterMs);
+}
+function getContactFoundDefault() {
+  const value = ContactMetadataSchema.parse({ "emailAddress": "ada@example.com", "firstName": "Ada", "id": 45678, "lastName": "Lovelace" });
+  return branchCase("found", value);
+}
+function getContactDefault() {
+  return getContactFoundDefault();
+}
+var GeneratedMock = class {
+  #listContacts;
+  #getContact;
+  #connection;
+  constructor(connectionName) {
+    this.#listContacts = newQuery(ListContactsDefinition).default(listContactsDefault());
+    this.#getContact = newQuery(GetContactDefinition).default(getContactDefault());
+    this.#connection = newConnectionWithOperations(this, { provider: ProviderID, name: connectionName });
+  }
+  connection() {
+    return this.#connection;
+  }
+  listContacts() {
+    return this.#listContacts;
+  }
+  getContact() {
+    return this.#getContact;
+  }
+  assertNoFailures() {
+    this.#listContacts.assertNoFailures();
+    this.#getContact.assertNoFailures();
+  }
+};
+export {
+  GeneratedMock,
+  GeneratedMock as Mock,
+  emptyContactMetadata,
+  emptyContactsPage,
+  emptyGetContactInput,
+  emptyListContactsInput,
+  getContactDefault,
+  getContactDefect,
+  getContactFound,
+  getContactFoundDefault,
+  getContactInvalidResponse,
+  getContactNotFound,
+  getContactProviderRejected,
+  getContactRetry,
+  listContactsDefault,
+  listContactsDefect,
+  listContactsInvalidResponse,
+  listContactsListed,
+  listContactsListedDefault,
+  listContactsProviderRejected,
+  listContactsRetry
+};

package/package.json

@@ -1,6 +1,61 @@
 {
   "name": "@superdurable/connector-insightly",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "license": "MIT",
+  "description": "Insightly connector for Dex TypeScript applications",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/superdurable/dex-connectors-library.git",
+    "directory": "connectors/insightly/typescript"
+  },
+  "type": "module",
+  "engines": {
+    "node": "^22.0.0 || ^24.0.0"
+  },
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./mock": {
+      "types": "./dist/mock.d.ts",
+      "import": "./dist/mock.js"
+    },
+    "./dex-connector.json": "./dex-connector.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "dex-connector.json"
+  ],
+  "scripts": {
+    "prepack": "npm run build",
+    "build": "tsup src/index.ts src/mock.ts --format esm --dts --clean",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src test examples",
+    "test": "vitest run --exclude test/integration/**",
+    "test:integration": "vitest run test/integration/*.integration.test.ts",
+    "example:worker": "tsx examples/contact-discovery/worker.ts",
+    "example:start": "tsx examples/contact-discovery/start.ts",
+    "check": "npm run typecheck && npm run lint && npm test && npm run build"
+  },
+  "dependencies": {
+    "@superdurable/connectors-sdk": "0.1.1",
+    "@superdurable/dex": ">=1.28.0",
+    "zod": "^4.1.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.0.0",
+    "@types/node": "^22.0.0",
+    "eslint": "^9.0.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.23.15",
+    "typescript": "^5.9.0",
+    "typescript-eslint": "^8.0.0",
+    "vitest": "^3.0.0",
+    "yaml": "^2.9.1"
+  }
+}