@objectstack/spec 0.9.1 → 1.0.0

package/dist/integration/connector.zod.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { AuthConfigSchema as ConnectorAuthConfigSchema } from '../auth/config.zod';
+import { ConnectorAuthConfigSchema } from '../shared/connector-auth.zod';
 /**
  * Connector Protocol - LEVEL 3: Enterprise Connector
  *
@@ -65,65 +65,79 @@ import { AuthConfigSchema as ConnectorAuthConfigSchema } from '../auth/config.zo
  * @deprecated Use ConnectorAuthConfigSchema from auth/config.zod instead
  * Kept for backward compatibility
  */
-export declare const AuthenticationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const AuthenticationSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     type: z.ZodLiteral<"oauth2">;
     authorizationUrl: z.ZodString;
     tokenUrl: z.ZodString;
     clientId: z.ZodString;
     clientSecret: z.ZodString;
-    scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     redirectUri: z.ZodOptional<z.ZodString>;
     refreshToken: z.ZodOptional<z.ZodString>;
     tokenExpiry: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>, z.ZodObject<{
+}, "strip", z.ZodTypeAny, {
+    type: "oauth2";
+    clientId: string;
+    clientSecret: string;
+    authorizationUrl: string;
+    tokenUrl: string;
+    refreshToken?: string | undefined;
+    scopes?: string[] | undefined;
+    redirectUri?: string | undefined;
+    tokenExpiry?: number | undefined;
+}, {
+    type: "oauth2";
+    clientId: string;
+    clientSecret: string;
+    authorizationUrl: string;
+    tokenUrl: string;
+    refreshToken?: string | undefined;
+    scopes?: string[] | undefined;
+    redirectUri?: string | undefined;
+    tokenExpiry?: number | undefined;
+}>, z.ZodObject<{
     type: z.ZodLiteral<"api-key">;
     key: z.ZodString;
     headerName: z.ZodDefault<z.ZodString>;
     paramName: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
+}, "strip", z.ZodTypeAny, {
+    type: "api-key";
+    key: string;
+    headerName: string;
+    paramName?: string | undefined;
+}, {
+    type: "api-key";
+    key: string;
+    headerName?: string | undefined;
+    paramName?: string | undefined;
+}>, z.ZodObject<{
     type: z.ZodLiteral<"basic">;
     username: z.ZodString;
     password: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
+}, "strip", z.ZodTypeAny, {
+    type: "basic";
+    password: string;
+    username: string;
+}, {
+    type: "basic";
+    password: string;
+    username: string;
+}>, z.ZodObject<{
     type: z.ZodLiteral<"bearer">;
     token: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"jwt">;
-    token: z.ZodOptional<z.ZodString>;
-    secretKey: z.ZodOptional<z.ZodString>;
-    algorithm: z.ZodDefault<z.ZodEnum<{
-        HS256: "HS256";
-        HS384: "HS384";
-        HS512: "HS512";
-        RS256: "RS256";
-        RS384: "RS384";
-        RS512: "RS512";
-        ES256: "ES256";
-        ES384: "ES384";
-        ES512: "ES512";
-    }>>;
-    issuer: z.ZodOptional<z.ZodString>;
-    audience: z.ZodOptional<z.ZodString>;
-    subject: z.ZodOptional<z.ZodString>;
-    expiresIn: z.ZodDefault<z.ZodNumber>;
-    claims: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"saml">;
-    entryPoint: z.ZodString;
-    issuer: z.ZodString;
-    certificate: z.ZodString;
-    privateKey: z.ZodOptional<z.ZodString>;
-    callbackUrl: z.ZodOptional<z.ZodString>;
-    signatureAlgorithm: z.ZodDefault<z.ZodEnum<{
-        sha1: "sha1";
-        sha256: "sha256";
-        sha512: "sha512";
-    }>>;
-    wantAssertionsSigned: z.ZodDefault<z.ZodBoolean>;
-    identifierFormat: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
+}, "strip", z.ZodTypeAny, {
+    type: "bearer";
+    token: string;
+}, {
+    type: "bearer";
+    token: string;
+}>, z.ZodObject<{
     type: z.ZodLiteral<"none">;
-}, z.core.$strip>], "type">;
+}, "strip", z.ZodTypeAny, {
+    type: "none";
+}, {
+    type: "none";
+}>]>;
 export type Authentication = z.infer<typeof ConnectorAuthConfigSchema>;
 /**
  * Field Transformation Function (Connector-specific)
@@ -131,17 +145,18 @@ export type Authentication = z.infer<typeof ConnectorAuthConfigSchema>;
  * @deprecated Use TransformTypeSchema from shared/mapping.zod.ts instead
  */
 export declare const FieldTransformSchema: z.ZodObject<{
-    type: z.ZodEnum<{
-        custom: "custom";
-        trim: "trim";
-        lowercase: "lowercase";
-        uppercase: "uppercase";
-        date_format: "date_format";
-        number_format: "number_format";
-    }>;
+    type: z.ZodEnum<["uppercase", "lowercase", "trim", "date_format", "number_format", "custom"]>;
     params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     function: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    type: "custom" | "trim" | "uppercase" | "lowercase" | "date_format" | "number_format";
+    function?: string | undefined;
+    params?: Record<string, any> | undefined;
+}, {
+    type: "custom" | "trim" | "uppercase" | "lowercase" | "date_format" | "number_format";
+    function?: string | undefined;
+    params?: Record<string, any> | undefined;
+}>;
 export type FieldTransform = z.infer<typeof FieldTransformSchema>;
 /**
  * Connector Field Mapping Configuration
@@ -152,122 +167,205 @@ export type FieldTransform = z.infer<typeof FieldTransformSchema>;
 export declare const FieldMappingSchema: z.ZodObject<{
     source: z.ZodString;
     target: z.ZodString;
-    transform: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    transform: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
         type: z.ZodLiteral<"constant">;
         value: z.ZodAny;
-    }, z.core.$strip>, z.ZodObject<{
+    }, "strip", z.ZodTypeAny, {
+        type: "constant";
+        value?: any;
+    }, {
+        type: "constant";
+        value?: any;
+    }>, z.ZodObject<{
         type: z.ZodLiteral<"cast">;
-        targetType: z.ZodEnum<{
-            string: "string";
-            number: "number";
-            boolean: "boolean";
-            date: "date";
-        }>;
-    }, z.core.$strip>, z.ZodObject<{
+        targetType: z.ZodEnum<["string", "number", "boolean", "date"]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "cast";
+        targetType: "string" | "number" | "boolean" | "date";
+    }, {
+        type: "cast";
+        targetType: "string" | "number" | "boolean" | "date";
+    }>, z.ZodObject<{
         type: z.ZodLiteral<"lookup">;
         table: z.ZodString;
         keyField: z.ZodString;
         valueField: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, "strip", z.ZodTypeAny, {
+        type: "lookup";
+        table: string;
+        keyField: string;
+        valueField: string;
+    }, {
+        type: "lookup";
+        table: string;
+        keyField: string;
+        valueField: string;
+    }>, z.ZodObject<{
         type: z.ZodLiteral<"javascript">;
         expression: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, "strip", z.ZodTypeAny, {
+        type: "javascript";
+        expression: string;
+    }, {
+        type: "javascript";
+        expression: string;
+    }>, z.ZodObject<{
         type: z.ZodLiteral<"map">;
         mappings: z.ZodRecord<z.ZodString, z.ZodAny>;
-    }, z.core.$strip>], "type">>;
+    }, "strip", z.ZodTypeAny, {
+        type: "map";
+        mappings: Record<string, any>;
+    }, {
+        type: "map";
+        mappings: Record<string, any>;
+    }>]>>;
     defaultValue: z.ZodOptional<z.ZodAny>;
-    dataType: z.ZodOptional<z.ZodEnum<{
-        string: "string";
-        number: "number";
-        boolean: "boolean";
-        date: "date";
-        array: "array";
-        datetime: "datetime";
-        json: "json";
-    }>>;
+} & {
+    /**
+     * Data type mapping (connector-specific)
+     */
+    dataType: z.ZodOptional<z.ZodEnum<["string", "number", "boolean", "date", "datetime", "json", "array"]>>;
+    /**
+     * Is this field required?
+     */
     required: z.ZodDefault<z.ZodBoolean>;
-    syncMode: z.ZodDefault<z.ZodEnum<{
-        bidirectional: "bidirectional";
-        read_only: "read_only";
-        write_only: "write_only";
-    }>>;
-}, z.core.$strip>;
+    /**
+     * Bidirectional sync mode (connector-specific)
+     */
+    syncMode: z.ZodDefault<z.ZodEnum<["read_only", "write_only", "bidirectional"]>>;
+}, "strip", z.ZodTypeAny, {
+    source: string;
+    target: string;
+    required: boolean;
+    syncMode: "bidirectional" | "read_only" | "write_only";
+    transform?: {
+        type: "constant";
+        value?: any;
+    } | {
+        type: "cast";
+        targetType: "string" | "number" | "boolean" | "date";
+    } | {
+        type: "lookup";
+        table: string;
+        keyField: string;
+        valueField: string;
+    } | {
+        type: "javascript";
+        expression: string;
+    } | {
+        type: "map";
+        mappings: Record<string, any>;
+    } | undefined;
+    defaultValue?: any;
+    dataType?: "string" | "number" | "boolean" | "date" | "array" | "datetime" | "json" | undefined;
+}, {
+    source: string;
+    target: string;
+    transform?: {
+        type: "constant";
+        value?: any;
+    } | {
+        type: "cast";
+        targetType: "string" | "number" | "boolean" | "date";
+    } | {
+        type: "lookup";
+        table: string;
+        keyField: string;
+        valueField: string;
+    } | {
+        type: "javascript";
+        expression: string;
+    } | {
+        type: "map";
+        mappings: Record<string, any>;
+    } | undefined;
+    defaultValue?: any;
+    required?: boolean | undefined;
+    dataType?: "string" | "number" | "boolean" | "date" | "array" | "datetime" | "json" | undefined;
+    syncMode?: "bidirectional" | "read_only" | "write_only" | undefined;
+}>;
 export type FieldMapping = z.infer<typeof FieldMappingSchema>;
 /**
  * Sync Strategy Schema
  */
-export declare const SyncStrategySchema: z.ZodEnum<{
-    full: "full";
-    upsert: "upsert";
-    incremental: "incremental";
-    append_only: "append_only";
-}>;
+export declare const SyncStrategySchema: z.ZodEnum<["full", "incremental", "upsert", "append_only"]>;
 export type SyncStrategy = z.infer<typeof SyncStrategySchema>;
 /**
  * Conflict Resolution Strategy
  */
-export declare const ConflictResolutionSchema: z.ZodEnum<{
-    manual: "manual";
-    source_wins: "source_wins";
-    latest_wins: "latest_wins";
-    target_wins: "target_wins";
-}>;
+export declare const ConflictResolutionSchema: z.ZodEnum<["source_wins", "target_wins", "latest_wins", "manual"]>;
 export type ConflictResolution = z.infer<typeof ConflictResolutionSchema>;
 /**
  * Data Synchronization Configuration
  */
 export declare const DataSyncConfigSchema: z.ZodObject<{
-    strategy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        full: "full";
-        upsert: "upsert";
-        incremental: "incremental";
-        append_only: "append_only";
-    }>>>;
-    direction: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        import: "import";
-        export: "export";
-        bidirectional: "bidirectional";
-    }>>>;
+    /**
+     * Sync strategy
+     */
+    strategy: z.ZodDefault<z.ZodOptional<z.ZodEnum<["full", "incremental", "upsert", "append_only"]>>>;
+    /**
+     * Sync direction
+     */
+    direction: z.ZodDefault<z.ZodOptional<z.ZodEnum<["import", "export", "bidirectional"]>>>;
+    /**
+     * Sync frequency (cron expression)
+     */
     schedule: z.ZodOptional<z.ZodString>;
+    /**
+     * Enable real-time sync via webhooks
+     */
     realtimeSync: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    /**
+     * Field to track last sync timestamp
+     */
     timestampField: z.ZodOptional<z.ZodString>;
-    conflictResolution: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        manual: "manual";
-        source_wins: "source_wins";
-        latest_wins: "latest_wins";
-        target_wins: "target_wins";
-    }>>>;
+    /**
+     * Conflict resolution strategy
+     */
+    conflictResolution: z.ZodDefault<z.ZodOptional<z.ZodEnum<["source_wins", "target_wins", "latest_wins", "manual"]>>>;
+    /**
+     * Batch size for bulk operations
+     */
     batchSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    deleteMode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        ignore: "ignore";
-        hard_delete: "hard_delete";
-        soft_delete: "soft_delete";
-    }>>>;
+    /**
+     * Delete handling
+     */
+    deleteMode: z.ZodDefault<z.ZodOptional<z.ZodEnum<["hard_delete", "soft_delete", "ignore"]>>>;
+    /**
+     * Filter criteria for selective sync
+     */
     filters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    strategy: "full" | "upsert" | "incremental" | "append_only";
+    batchSize: number;
+    direction: "import" | "export" | "bidirectional";
+    conflictResolution: "manual" | "source_wins" | "latest_wins" | "target_wins";
+    realtimeSync: boolean;
+    deleteMode: "ignore" | "hard_delete" | "soft_delete";
+    filters?: Record<string, any> | undefined;
+    schedule?: string | undefined;
+    timestampField?: string | undefined;
+}, {
+    strategy?: "full" | "upsert" | "incremental" | "append_only" | undefined;
+    filters?: Record<string, any> | undefined;
+    batchSize?: number | undefined;
+    schedule?: string | undefined;
+    direction?: "import" | "export" | "bidirectional" | undefined;
+    conflictResolution?: "manual" | "source_wins" | "latest_wins" | "target_wins" | undefined;
+    realtimeSync?: boolean | undefined;
+    timestampField?: string | undefined;
+    deleteMode?: "ignore" | "hard_delete" | "soft_delete" | undefined;
+}>;
 export type DataSyncConfig = z.infer<typeof DataSyncConfigSchema>;
 /**
  * Webhook Event Schema
  */
-export declare const WebhookEventSchema: z.ZodEnum<{
-    "record.created": "record.created";
-    "record.updated": "record.updated";
-    "record.deleted": "record.deleted";
-    "sync.started": "sync.started";
-    "sync.completed": "sync.completed";
-    "sync.failed": "sync.failed";
-    "auth.expired": "auth.expired";
-    "rate_limit.exceeded": "rate_limit.exceeded";
-}>;
+export declare const WebhookEventSchema: z.ZodEnum<["record.created", "record.updated", "record.deleted", "sync.started", "sync.completed", "sync.failed", "auth.expired", "rate_limit.exceeded"]>;
 export type WebhookEvent = z.infer<typeof WebhookEventSchema>;
 /**
  * Webhook Signature Algorithm
  */
-export declare const WebhookSignatureAlgorithmSchema: z.ZodEnum<{
-    none: "none";
-    hmac_sha256: "hmac_sha256";
-    hmac_sha512: "hmac_sha512";
-}>;
+export declare const WebhookSignatureAlgorithmSchema: z.ZodEnum<["hmac_sha256", "hmac_sha512", "none"]>;
 export type WebhookSignatureAlgorithm = z.infer<typeof WebhookSignatureAlgorithmSchema>;
 /**
  * Webhook Configuration Schema
@@ -279,401 +377,1146 @@ export declare const WebhookConfigSchema: z.ZodObject<{
     name: z.ZodString;
     label: z.ZodOptional<z.ZodString>;
     object: z.ZodOptional<z.ZodString>;
-    triggers: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        update: "update";
-        delete: "delete";
-        create: "create";
-        api: "api";
-        undelete: "undelete";
-    }>>>;
+    triggers: z.ZodOptional<z.ZodArray<z.ZodEnum<["create", "update", "delete", "undelete", "api"]>, "many">>;
     url: z.ZodString;
-    method: z.ZodDefault<z.ZodEnum<{
-        GET: "GET";
-        POST: "POST";
-        PUT: "PUT";
-        DELETE: "DELETE";
-        PATCH: "PATCH";
-    }>>;
+    method: z.ZodDefault<z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>>;
     headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     body: z.ZodOptional<z.ZodAny>;
-    payloadFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    payloadFields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     includeSession: z.ZodDefault<z.ZodBoolean>;
     authentication: z.ZodOptional<z.ZodObject<{
-        type: z.ZodEnum<{
-            none: "none";
-            "api-key": "api-key";
-            basic: "basic";
-            bearer: "bearer";
-        }>;
+        type: z.ZodEnum<["none", "bearer", "basic", "api-key"]>;
         credentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    }, z.core.$strip>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "none" | "api-key" | "basic" | "bearer";
+        credentials?: Record<string, string> | undefined;
+    }, {
+        type: "none" | "api-key" | "basic" | "bearer";
+        credentials?: Record<string, string> | undefined;
+    }>>;
     retryPolicy: z.ZodOptional<z.ZodObject<{
         maxRetries: z.ZodDefault<z.ZodNumber>;
-        backoffStrategy: z.ZodDefault<z.ZodEnum<{
-            fixed: "fixed";
-            linear: "linear";
-            exponential: "exponential";
-        }>>;
+        backoffStrategy: z.ZodDefault<z.ZodEnum<["exponential", "linear", "fixed"]>>;
         initialDelayMs: z.ZodDefault<z.ZodNumber>;
         maxDelayMs: z.ZodDefault<z.ZodNumber>;
-    }, z.core.$strip>>;
+    }, "strip", z.ZodTypeAny, {
+        maxRetries: number;
+        backoffStrategy: "fixed" | "linear" | "exponential";
+        initialDelayMs: number;
+        maxDelayMs: number;
+    }, {
+        maxRetries?: number | undefined;
+        backoffStrategy?: "fixed" | "linear" | "exponential" | undefined;
+        initialDelayMs?: number | undefined;
+        maxDelayMs?: number | undefined;
+    }>>;
     timeoutMs: z.ZodDefault<z.ZodNumber>;
     secret: z.ZodOptional<z.ZodString>;
     isActive: z.ZodDefault<z.ZodBoolean>;
     description: z.ZodOptional<z.ZodString>;
-    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    events: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        "record.created": "record.created";
-        "record.updated": "record.updated";
-        "record.deleted": "record.deleted";
-        "sync.started": "sync.started";
-        "sync.completed": "sync.completed";
-        "sync.failed": "sync.failed";
-        "auth.expired": "auth.expired";
-        "rate_limit.exceeded": "rate_limit.exceeded";
-    }>>>;
-    signatureAlgorithm: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        none: "none";
-        hmac_sha256: "hmac_sha256";
-        hmac_sha512: "hmac_sha512";
-    }>>>;
-}, z.core.$strip>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+} & {
+    /**
+     * Events to listen for
+     * Connector-specific events like sync completion, auth expiry, etc.
+     */
+    events: z.ZodOptional<z.ZodArray<z.ZodEnum<["record.created", "record.updated", "record.deleted", "sync.started", "sync.completed", "sync.failed", "auth.expired", "rate_limit.exceeded"]>, "many">>;
+    /**
+     * Signature algorithm for webhook security
+     */
+    signatureAlgorithm: z.ZodDefault<z.ZodOptional<z.ZodEnum<["hmac_sha256", "hmac_sha512", "none"]>>>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    name: string;
+    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    timeoutMs: number;
+    includeSession: boolean;
+    isActive: boolean;
+    signatureAlgorithm: "none" | "hmac_sha256" | "hmac_sha512";
+    object?: string | undefined;
+    tags?: string[] | undefined;
+    label?: string | undefined;
+    description?: string | undefined;
+    events?: ("record.created" | "record.updated" | "record.deleted" | "sync.started" | "sync.completed" | "sync.failed" | "auth.expired" | "rate_limit.exceeded")[] | undefined;
+    headers?: Record<string, string> | undefined;
+    authentication?: {
+        type: "none" | "api-key" | "basic" | "bearer";
+        credentials?: Record<string, string> | undefined;
+    } | undefined;
+    body?: any;
+    secret?: string | undefined;
+    retryPolicy?: {
+        maxRetries: number;
+        backoffStrategy: "fixed" | "linear" | "exponential";
+        initialDelayMs: number;
+        maxDelayMs: number;
+    } | undefined;
+    triggers?: ("update" | "delete" | "create" | "api" | "undelete")[] | undefined;
+    payloadFields?: string[] | undefined;
+}, {
+    url: string;
+    name: string;
+    object?: string | undefined;
+    tags?: string[] | undefined;
+    label?: string | undefined;
+    description?: string | undefined;
+    events?: ("record.created" | "record.updated" | "record.deleted" | "sync.started" | "sync.completed" | "sync.failed" | "auth.expired" | "rate_limit.exceeded")[] | undefined;
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | undefined;
+    headers?: Record<string, string> | undefined;
+    authentication?: {
+        type: "none" | "api-key" | "basic" | "bearer";
+        credentials?: Record<string, string> | undefined;
+    } | undefined;
+    body?: any;
+    secret?: string | undefined;
+    retryPolicy?: {
+        maxRetries?: number | undefined;
+        backoffStrategy?: "fixed" | "linear" | "exponential" | undefined;
+        initialDelayMs?: number | undefined;
+        maxDelayMs?: number | undefined;
+    } | undefined;
+    timeoutMs?: number | undefined;
+    triggers?: ("update" | "delete" | "create" | "api" | "undelete")[] | undefined;
+    payloadFields?: string[] | undefined;
+    includeSession?: boolean | undefined;
+    isActive?: boolean | undefined;
+    signatureAlgorithm?: "none" | "hmac_sha256" | "hmac_sha512" | undefined;
+}>;
 export type WebhookConfig = z.infer<typeof WebhookConfigSchema>;
 /**
  * Rate Limiting Strategy
  */
-export declare const RateLimitStrategySchema: z.ZodEnum<{
-    sliding_window: "sliding_window";
-    token_bucket: "token_bucket";
-    fixed_window: "fixed_window";
-    leaky_bucket: "leaky_bucket";
-}>;
+export declare const RateLimitStrategySchema: z.ZodEnum<["fixed_window", "sliding_window", "token_bucket", "leaky_bucket"]>;
 export type RateLimitStrategy = z.infer<typeof RateLimitStrategySchema>;
 /**
  * Rate Limiting Configuration
  */
 export declare const RateLimitConfigSchema: z.ZodObject<{
-    strategy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        sliding_window: "sliding_window";
-        token_bucket: "token_bucket";
-        fixed_window: "fixed_window";
-        leaky_bucket: "leaky_bucket";
-    }>>>;
+    /**
+     * Rate limiting strategy
+     */
+    strategy: z.ZodDefault<z.ZodOptional<z.ZodEnum<["fixed_window", "sliding_window", "token_bucket", "leaky_bucket"]>>>;
+    /**
+     * Maximum requests per window
+     */
     maxRequests: z.ZodNumber;
+    /**
+     * Time window in seconds
+     */
     windowSeconds: z.ZodNumber;
+    /**
+     * Burst capacity (for token bucket)
+     */
     burstCapacity: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Respect external system rate limits
+     */
     respectUpstreamLimits: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    /**
+     * Custom rate limit headers to check
+     */
     rateLimitHeaders: z.ZodOptional<z.ZodObject<{
         remaining: z.ZodDefault<z.ZodOptional<z.ZodString>>;
         limit: z.ZodDefault<z.ZodOptional<z.ZodString>>;
         reset: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        limit: string;
+        remaining: string;
+        reset: string;
+    }, {
+        limit?: string | undefined;
+        remaining?: string | undefined;
+        reset?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    maxRequests: number;
+    strategy: "sliding_window" | "token_bucket" | "fixed_window" | "leaky_bucket";
+    windowSeconds: number;
+    respectUpstreamLimits: boolean;
+    burstCapacity?: number | undefined;
+    rateLimitHeaders?: {
+        limit: string;
+        remaining: string;
+        reset: string;
+    } | undefined;
+}, {
+    maxRequests: number;
+    windowSeconds: number;
+    strategy?: "sliding_window" | "token_bucket" | "fixed_window" | "leaky_bucket" | undefined;
+    burstCapacity?: number | undefined;
+    respectUpstreamLimits?: boolean | undefined;
+    rateLimitHeaders?: {
+        limit?: string | undefined;
+        remaining?: string | undefined;
+        reset?: string | undefined;
+    } | undefined;
+}>;
 export type RateLimitConfig = z.infer<typeof RateLimitConfigSchema>;
 /**
  * Retry Strategy
  */
-export declare const RetryStrategySchema: z.ZodEnum<{
-    no_retry: "no_retry";
-    exponential_backoff: "exponential_backoff";
-    linear_backoff: "linear_backoff";
-    fixed_delay: "fixed_delay";
-}>;
+export declare const RetryStrategySchema: z.ZodEnum<["exponential_backoff", "linear_backoff", "fixed_delay", "no_retry"]>;
 export type RetryStrategy = z.infer<typeof RetryStrategySchema>;
 /**
  * Retry Configuration
  */
 export declare const RetryConfigSchema: z.ZodObject<{
-    strategy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        no_retry: "no_retry";
-        exponential_backoff: "exponential_backoff";
-        linear_backoff: "linear_backoff";
-        fixed_delay: "fixed_delay";
-    }>>>;
+    /**
+     * Retry strategy
+     */
+    strategy: z.ZodDefault<z.ZodOptional<z.ZodEnum<["exponential_backoff", "linear_backoff", "fixed_delay", "no_retry"]>>>;
+    /**
+     * Maximum retry attempts
+     */
     maxAttempts: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    /**
+     * Initial delay in milliseconds
+     */
     initialDelayMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    /**
+     * Maximum delay in milliseconds
+     */
     maxDelayMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    /**
+     * Backoff multiplier (for exponential backoff)
+     */
     backoffMultiplier: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    retryableStatusCodes: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodNumber>>>;
+    /**
+     * HTTP status codes to retry
+     */
+    retryableStatusCodes: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>>;
+    /**
+     * Retry on network errors
+     */
     retryOnNetworkError: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    /**
+     * Jitter to add randomness to retry delays
+     */
     jitter: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    strategy: "no_retry" | "exponential_backoff" | "linear_backoff" | "fixed_delay";
+    maxAttempts: number;
+    backoffMultiplier: number;
+    initialDelayMs: number;
+    maxDelayMs: number;
+    retryableStatusCodes: number[];
+    retryOnNetworkError: boolean;
+    jitter: boolean;
+}, {
+    strategy?: "no_retry" | "exponential_backoff" | "linear_backoff" | "fixed_delay" | undefined;
+    maxAttempts?: number | undefined;
+    backoffMultiplier?: number | undefined;
+    initialDelayMs?: number | undefined;
+    maxDelayMs?: number | undefined;
+    retryableStatusCodes?: number[] | undefined;
+    retryOnNetworkError?: boolean | undefined;
+    jitter?: boolean | undefined;
+}>;
 export type RetryConfig = z.infer<typeof RetryConfigSchema>;
 /**
  * Connector Type
  */
-export declare const ConnectorTypeSchema: z.ZodEnum<{
-    custom: "custom";
-    database: "database";
-    api: "api";
-    saas: "saas";
-    file_storage: "file_storage";
-    message_queue: "message_queue";
-}>;
+export declare const ConnectorTypeSchema: z.ZodEnum<["saas", "database", "file_storage", "message_queue", "api", "custom"]>;
 export type ConnectorType = z.infer<typeof ConnectorTypeSchema>;
 /**
  * Connector Status
  */
-export declare const ConnectorStatusSchema: z.ZodEnum<{
-    error: "error";
-    active: "active";
-    inactive: "inactive";
-    configuring: "configuring";
-}>;
+export declare const ConnectorStatusSchema: z.ZodEnum<["active", "inactive", "error", "configuring"]>;
 export type ConnectorStatus = z.infer<typeof ConnectorStatusSchema>;
+/**
+ * Connector Action Definition
+ */
+export declare const ConnectorActionSchema: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    label: string;
+    key: string;
+    description?: string | undefined;
+    inputSchema?: Record<string, any> | undefined;
+    outputSchema?: Record<string, any> | undefined;
+}, {
+    label: string;
+    key: string;
+    description?: string | undefined;
+    inputSchema?: Record<string, any> | undefined;
+    outputSchema?: Record<string, any> | undefined;
+}>;
+/**
+ * Connector Trigger Definition
+ */
+export declare const ConnectorTriggerSchema: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    type: z.ZodEnum<["polling", "webhook"]>;
+    interval: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "webhook" | "polling";
+    label: string;
+    key: string;
+    description?: string | undefined;
+    interval?: number | undefined;
+}, {
+    type: "webhook" | "polling";
+    label: string;
+    key: string;
+    description?: string | undefined;
+    interval?: number | undefined;
+}>;
 /**
  * Base Connector Schema
  * Core connector configuration shared across all connector types
  */
 export declare const ConnectorSchema: z.ZodObject<{
+    /**
+     * Machine name (snake_case)
+     */
     name: z.ZodString;
+    /**
+     * Human-readable label
+     */
     label: z.ZodString;
-    type: z.ZodEnum<{
-        custom: "custom";
-        database: "database";
-        api: "api";
-        saas: "saas";
-        file_storage: "file_storage";
-        message_queue: "message_queue";
-    }>;
+    /**
+     * Connector type
+     */
+    type: z.ZodEnum<["saas", "database", "file_storage", "message_queue", "api", "custom"]>;
+    /**
+     * Description
+     */
     description: z.ZodOptional<z.ZodString>;
+    /**
+     * Icon identifier
+     */
     icon: z.ZodOptional<z.ZodString>;
-    authentication: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    /**
+     * Authentication configuration
+     */
+    authentication: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
         type: z.ZodLiteral<"oauth2">;
         authorizationUrl: z.ZodString;
         tokenUrl: z.ZodString;
         clientId: z.ZodString;
         clientSecret: z.ZodString;
-        scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         redirectUri: z.ZodOptional<z.ZodString>;
         refreshToken: z.ZodOptional<z.ZodString>;
         tokenExpiry: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>, z.ZodObject<{
+    }, "strip", z.ZodTypeAny, {
+        type: "oauth2";
+        clientId: string;
+        clientSecret: string;
+        authorizationUrl: string;
+        tokenUrl: string;
+        refreshToken?: string | undefined;
+        scopes?: string[] | undefined;
+        redirectUri?: string | undefined;
+        tokenExpiry?: number | undefined;
+    }, {
+        type: "oauth2";
+        clientId: string;
+        clientSecret: string;
+        authorizationUrl: string;
+        tokenUrl: string;
+        refreshToken?: string | undefined;
+        scopes?: string[] | undefined;
+        redirectUri?: string | undefined;
+        tokenExpiry?: number | undefined;
+    }>, z.ZodObject<{
         type: z.ZodLiteral<"api-key">;
         key: z.ZodString;
         headerName: z.ZodDefault<z.ZodString>;
         paramName: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
+    }, "strip", z.ZodTypeAny, {
+        type: "api-key";
+        key: string;
+        headerName: string;
+        paramName?: string | undefined;
+    }, {
+        type: "api-key";
+        key: string;
+        headerName?: string | undefined;
+        paramName?: string | undefined;
+    }>, z.ZodObject<{
         type: z.ZodLiteral<"basic">;
         username: z.ZodString;
         password: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, "strip", z.ZodTypeAny, {
+        type: "basic";
+        password: string;
+        username: string;
+    }, {
+        type: "basic";
+        password: string;
+        username: string;
+    }>, z.ZodObject<{
         type: z.ZodLiteral<"bearer">;
         token: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"jwt">;
-        token: z.ZodOptional<z.ZodString>;
-        secretKey: z.ZodOptional<z.ZodString>;
-        algorithm: z.ZodDefault<z.ZodEnum<{
-            HS256: "HS256";
-            HS384: "HS384";
-            HS512: "HS512";
-            RS256: "RS256";
-            RS384: "RS384";
-            RS512: "RS512";
-            ES256: "ES256";
-            ES384: "ES384";
-            ES512: "ES512";
-        }>>;
-        issuer: z.ZodOptional<z.ZodString>;
-        audience: z.ZodOptional<z.ZodString>;
-        subject: z.ZodOptional<z.ZodString>;
-        expiresIn: z.ZodDefault<z.ZodNumber>;
-        claims: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"saml">;
-        entryPoint: z.ZodString;
-        issuer: z.ZodString;
-        certificate: z.ZodString;
-        privateKey: z.ZodOptional<z.ZodString>;
-        callbackUrl: z.ZodOptional<z.ZodString>;
-        signatureAlgorithm: z.ZodDefault<z.ZodEnum<{
-            sha1: "sha1";
-            sha256: "sha256";
-            sha512: "sha512";
-        }>>;
-        wantAssertionsSigned: z.ZodDefault<z.ZodBoolean>;
-        identifierFormat: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
+    }, "strip", z.ZodTypeAny, {
+        type: "bearer";
+        token: string;
+    }, {
+        type: "bearer";
+        token: string;
+    }>, z.ZodObject<{
         type: z.ZodLiteral<"none">;
-    }, z.core.$strip>], "type">;
+    }, "strip", z.ZodTypeAny, {
+        type: "none";
+    }, {
+        type: "none";
+    }>]>;
+    /** Zapier-style Capabilities */
+    actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        inputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        key: string;
+        description?: string | undefined;
+        inputSchema?: Record<string, any> | undefined;
+        outputSchema?: Record<string, any> | undefined;
+    }, {
+        label: string;
+        key: string;
+        description?: string | undefined;
+        inputSchema?: Record<string, any> | undefined;
+        outputSchema?: Record<string, any> | undefined;
+    }>, "many">>;
+    triggers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        type: z.ZodEnum<["polling", "webhook"]>;
+        interval: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "webhook" | "polling";
+        label: string;
+        key: string;
+        description?: string | undefined;
+        interval?: number | undefined;
+    }, {
+        type: "webhook" | "polling";
+        label: string;
+        key: string;
+        description?: string | undefined;
+        interval?: number | undefined;
+    }>, "many">>;
+    /**
+     * Data synchronization configuration
+     */
     syncConfig: z.ZodOptional<z.ZodObject<{
-        strategy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-            full: "full";
-            upsert: "upsert";
-            incremental: "incremental";
-            append_only: "append_only";
-        }>>>;
-        direction: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-            import: "import";
-            export: "export";
-            bidirectional: "bidirectional";
-        }>>>;
+        /**
+         * Sync strategy
+         */
+        strategy: z.ZodDefault<z.ZodOptional<z.ZodEnum<["full", "incremental", "upsert", "append_only"]>>>;
+        /**
+         * Sync direction
+         */
+        direction: z.ZodDefault<z.ZodOptional<z.ZodEnum<["import", "export", "bidirectional"]>>>;
+        /**
+         * Sync frequency (cron expression)
+         */
         schedule: z.ZodOptional<z.ZodString>;
+        /**
+         * Enable real-time sync via webhooks
+         */
         realtimeSync: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        /**
+         * Field to track last sync timestamp
+         */
         timestampField: z.ZodOptional<z.ZodString>;
-        conflictResolution: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-            manual: "manual";
-            source_wins: "source_wins";
-            latest_wins: "latest_wins";
-            target_wins: "target_wins";
-        }>>>;
+        /**
+         * Conflict resolution strategy
+         */
+        conflictResolution: z.ZodDefault<z.ZodOptional<z.ZodEnum<["source_wins", "target_wins", "latest_wins", "manual"]>>>;
+        /**
+         * Batch size for bulk operations
+         */
         batchSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-        deleteMode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-            ignore: "ignore";
-            hard_delete: "hard_delete";
-            soft_delete: "soft_delete";
-        }>>>;
+        /**
+         * Delete handling
+         */
+        deleteMode: z.ZodDefault<z.ZodOptional<z.ZodEnum<["hard_delete", "soft_delete", "ignore"]>>>;
+        /**
+         * Filter criteria for selective sync
+         */
         filters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    }, z.core.$strip>>;
+    }, "strip", z.ZodTypeAny, {
+        strategy: "full" | "upsert" | "incremental" | "append_only";
+        batchSize: number;
+        direction: "import" | "export" | "bidirectional";
+        conflictResolution: "manual" | "source_wins" | "latest_wins" | "target_wins";
+        realtimeSync: boolean;
+        deleteMode: "ignore" | "hard_delete" | "soft_delete";
+        filters?: Record<string, any> | undefined;
+        schedule?: string | undefined;
+        timestampField?: string | undefined;
+    }, {
+        strategy?: "full" | "upsert" | "incremental" | "append_only" | undefined;
+        filters?: Record<string, any> | undefined;
+        batchSize?: number | undefined;
+        schedule?: string | undefined;
+        direction?: "import" | "export" | "bidirectional" | undefined;
+        conflictResolution?: "manual" | "source_wins" | "latest_wins" | "target_wins" | undefined;
+        realtimeSync?: boolean | undefined;
+        timestampField?: string | undefined;
+        deleteMode?: "ignore" | "hard_delete" | "soft_delete" | undefined;
+    }>>;
+    /**
+     * Field mappings
+     */
     fieldMappings: z.ZodOptional<z.ZodArray<z.ZodObject<{
         source: z.ZodString;
         target: z.ZodString;
-        transform: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        transform: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
             type: z.ZodLiteral<"constant">;
             value: z.ZodAny;
-        }, z.core.$strip>, z.ZodObject<{
+        }, "strip", z.ZodTypeAny, {
+            type: "constant";
+            value?: any;
+        }, {
+            type: "constant";
+            value?: any;
+        }>, z.ZodObject<{
             type: z.ZodLiteral<"cast">;
-            targetType: z.ZodEnum<{
-                string: "string";
-                number: "number";
-                boolean: "boolean";
-                date: "date";
-            }>;
-        }, z.core.$strip>, z.ZodObject<{
+            targetType: z.ZodEnum<["string", "number", "boolean", "date"]>;
+        }, "strip", z.ZodTypeAny, {
+            type: "cast";
+            targetType: "string" | "number" | "boolean" | "date";
+        }, {
+            type: "cast";
+            targetType: "string" | "number" | "boolean" | "date";
+        }>, z.ZodObject<{
             type: z.ZodLiteral<"lookup">;
             table: z.ZodString;
             keyField: z.ZodString;
             valueField: z.ZodString;
-        }, z.core.$strip>, z.ZodObject<{
+        }, "strip", z.ZodTypeAny, {
+            type: "lookup";
+            table: string;
+            keyField: string;
+            valueField: string;
+        }, {
+            type: "lookup";
+            table: string;
+            keyField: string;
+            valueField: string;
+        }>, z.ZodObject<{
             type: z.ZodLiteral<"javascript">;
             expression: z.ZodString;
-        }, z.core.$strip>, z.ZodObject<{
+        }, "strip", z.ZodTypeAny, {
+            type: "javascript";
+            expression: string;
+        }, {
+            type: "javascript";
+            expression: string;
+        }>, z.ZodObject<{
             type: z.ZodLiteral<"map">;
             mappings: z.ZodRecord<z.ZodString, z.ZodAny>;
-        }, z.core.$strip>], "type">>;
+        }, "strip", z.ZodTypeAny, {
+            type: "map";
+            mappings: Record<string, any>;
+        }, {
+            type: "map";
+            mappings: Record<string, any>;
+        }>]>>;
         defaultValue: z.ZodOptional<z.ZodAny>;
-        dataType: z.ZodOptional<z.ZodEnum<{
-            string: "string";
-            number: "number";
-            boolean: "boolean";
-            date: "date";
-            array: "array";
-            datetime: "datetime";
-            json: "json";
-        }>>;
+    } & {
+        /**
+         * Data type mapping (connector-specific)
+         */
+        dataType: z.ZodOptional<z.ZodEnum<["string", "number", "boolean", "date", "datetime", "json", "array"]>>;
+        /**
+         * Is this field required?
+         */
         required: z.ZodDefault<z.ZodBoolean>;
-        syncMode: z.ZodDefault<z.ZodEnum<{
-            bidirectional: "bidirectional";
-            read_only: "read_only";
-            write_only: "write_only";
-        }>>;
-    }, z.core.$strip>>>;
+        /**
+         * Bidirectional sync mode (connector-specific)
+         */
+        syncMode: z.ZodDefault<z.ZodEnum<["read_only", "write_only", "bidirectional"]>>;
+    }, "strip", z.ZodTypeAny, {
+        source: string;
+        target: string;
+        required: boolean;
+        syncMode: "bidirectional" | "read_only" | "write_only";
+        transform?: {
+            type: "constant";
+            value?: any;
+        } | {
+            type: "cast";
+            targetType: "string" | "number" | "boolean" | "date";
+        } | {
+            type: "lookup";
+            table: string;
+            keyField: string;
+            valueField: string;
+        } | {
+            type: "javascript";
+            expression: string;
+        } | {
+            type: "map";
+            mappings: Record<string, any>;
+        } | undefined;
+        defaultValue?: any;
+        dataType?: "string" | "number" | "boolean" | "date" | "array" | "datetime" | "json" | undefined;
+    }, {
+        source: string;
+        target: string;
+        transform?: {
+            type: "constant";
+            value?: any;
+        } | {
+            type: "cast";
+            targetType: "string" | "number" | "boolean" | "date";
+        } | {
+            type: "lookup";
+            table: string;
+            keyField: string;
+            valueField: string;
+        } | {
+            type: "javascript";
+            expression: string;
+        } | {
+            type: "map";
+            mappings: Record<string, any>;
+        } | undefined;
+        defaultValue?: any;
+        required?: boolean | undefined;
+        dataType?: "string" | "number" | "boolean" | "date" | "array" | "datetime" | "json" | undefined;
+        syncMode?: "bidirectional" | "read_only" | "write_only" | undefined;
+    }>, "many">>;
+    /**
+     * Webhook configuration
+     */
     webhooks: z.ZodOptional<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         label: z.ZodOptional<z.ZodString>;
         object: z.ZodOptional<z.ZodString>;
-        triggers: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-            update: "update";
-            delete: "delete";
-            create: "create";
-            api: "api";
-            undelete: "undelete";
-        }>>>;
+        triggers: z.ZodOptional<z.ZodArray<z.ZodEnum<["create", "update", "delete", "undelete", "api"]>, "many">>;
         url: z.ZodString;
-        method: z.ZodDefault<z.ZodEnum<{
-            GET: "GET";
-            POST: "POST";
-            PUT: "PUT";
-            DELETE: "DELETE";
-            PATCH: "PATCH";
-        }>>;
+        method: z.ZodDefault<z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>>;
         headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         body: z.ZodOptional<z.ZodAny>;
-        payloadFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        payloadFields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         includeSession: z.ZodDefault<z.ZodBoolean>;
         authentication: z.ZodOptional<z.ZodObject<{
-            type: z.ZodEnum<{
-                none: "none";
-                "api-key": "api-key";
-                basic: "basic";
-                bearer: "bearer";
-            }>;
+            type: z.ZodEnum<["none", "bearer", "basic", "api-key"]>;
             credentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            type: "none" | "api-key" | "basic" | "bearer";
+            credentials?: Record<string, string> | undefined;
+        }, {
+            type: "none" | "api-key" | "basic" | "bearer";
+            credentials?: Record<string, string> | undefined;
+        }>>;
         retryPolicy: z.ZodOptional<z.ZodObject<{
             maxRetries: z.ZodDefault<z.ZodNumber>;
-            backoffStrategy: z.ZodDefault<z.ZodEnum<{
-                fixed: "fixed";
-                linear: "linear";
-                exponential: "exponential";
-            }>>;
+            backoffStrategy: z.ZodDefault<z.ZodEnum<["exponential", "linear", "fixed"]>>;
             initialDelayMs: z.ZodDefault<z.ZodNumber>;
             maxDelayMs: z.ZodDefault<z.ZodNumber>;
-        }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            maxRetries: number;
+            backoffStrategy: "fixed" | "linear" | "exponential";
+            initialDelayMs: number;
+            maxDelayMs: number;
+        }, {
+            maxRetries?: number | undefined;
+            backoffStrategy?: "fixed" | "linear" | "exponential" | undefined;
+            initialDelayMs?: number | undefined;
+            maxDelayMs?: number | undefined;
+        }>>;
         timeoutMs: z.ZodDefault<z.ZodNumber>;
         secret: z.ZodOptional<z.ZodString>;
         isActive: z.ZodDefault<z.ZodBoolean>;
         description: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        events: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-            "record.created": "record.created";
-            "record.updated": "record.updated";
-            "record.deleted": "record.deleted";
-            "sync.started": "sync.started";
-            "sync.completed": "sync.completed";
-            "sync.failed": "sync.failed";
-            "auth.expired": "auth.expired";
-            "rate_limit.exceeded": "rate_limit.exceeded";
-        }>>>;
-        signatureAlgorithm: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-            none: "none";
-            hmac_sha256: "hmac_sha256";
-            hmac_sha512: "hmac_sha512";
-        }>>>;
-    }, z.core.$strip>>>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    } & {
+        /**
+         * Events to listen for
+         * Connector-specific events like sync completion, auth expiry, etc.
+         */
+        events: z.ZodOptional<z.ZodArray<z.ZodEnum<["record.created", "record.updated", "record.deleted", "sync.started", "sync.completed", "sync.failed", "auth.expired", "rate_limit.exceeded"]>, "many">>;
+        /**
+         * Signature algorithm for webhook security
+         */
+        signatureAlgorithm: z.ZodDefault<z.ZodOptional<z.ZodEnum<["hmac_sha256", "hmac_sha512", "none"]>>>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        name: string;
+        method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+        timeoutMs: number;
+        includeSession: boolean;
+        isActive: boolean;
+        signatureAlgorithm: "none" | "hmac_sha256" | "hmac_sha512";
+        object?: string | undefined;
+        tags?: string[] | undefined;
+        label?: string | undefined;
+        description?: string | undefined;
+        events?: ("record.created" | "record.updated" | "record.deleted" | "sync.started" | "sync.completed" | "sync.failed" | "auth.expired" | "rate_limit.exceeded")[] | undefined;
+        headers?: Record<string, string> | undefined;
+        authentication?: {
+            type: "none" | "api-key" | "basic" | "bearer";
+            credentials?: Record<string, string> | undefined;
+        } | undefined;
+        body?: any;
+        secret?: string | undefined;
+        retryPolicy?: {
+            maxRetries: number;
+            backoffStrategy: "fixed" | "linear" | "exponential";
+            initialDelayMs: number;
+            maxDelayMs: number;
+        } | undefined;
+        triggers?: ("update" | "delete" | "create" | "api" | "undelete")[] | undefined;
+        payloadFields?: string[] | undefined;
+    }, {
+        url: string;
+        name: string;
+        object?: string | undefined;
+        tags?: string[] | undefined;
+        label?: string | undefined;
+        description?: string | undefined;
+        events?: ("record.created" | "record.updated" | "record.deleted" | "sync.started" | "sync.completed" | "sync.failed" | "auth.expired" | "rate_limit.exceeded")[] | undefined;
+        method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | undefined;
+        headers?: Record<string, string> | undefined;
+        authentication?: {
+            type: "none" | "api-key" | "basic" | "bearer";
+            credentials?: Record<string, string> | undefined;
+        } | undefined;
+        body?: any;
+        secret?: string | undefined;
+        retryPolicy?: {
+            maxRetries?: number | undefined;
+            backoffStrategy?: "fixed" | "linear" | "exponential" | undefined;
+            initialDelayMs?: number | undefined;
+            maxDelayMs?: number | undefined;
+        } | undefined;
+        timeoutMs?: number | undefined;
+        triggers?: ("update" | "delete" | "create" | "api" | "undelete")[] | undefined;
+        payloadFields?: string[] | undefined;
+        includeSession?: boolean | undefined;
+        isActive?: boolean | undefined;
+        signatureAlgorithm?: "none" | "hmac_sha256" | "hmac_sha512" | undefined;
+    }>, "many">>;
+    /**
+     * Rate limiting configuration
+     */
     rateLimitConfig: z.ZodOptional<z.ZodObject<{
-        strategy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-            sliding_window: "sliding_window";
-            token_bucket: "token_bucket";
-            fixed_window: "fixed_window";
-            leaky_bucket: "leaky_bucket";
-        }>>>;
+        /**
+         * Rate limiting strategy
+         */
+        strategy: z.ZodDefault<z.ZodOptional<z.ZodEnum<["fixed_window", "sliding_window", "token_bucket", "leaky_bucket"]>>>;
+        /**
+         * Maximum requests per window
+         */
         maxRequests: z.ZodNumber;
+        /**
+         * Time window in seconds
+         */
         windowSeconds: z.ZodNumber;
+        /**
+         * Burst capacity (for token bucket)
+         */
         burstCapacity: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Respect external system rate limits
+         */
         respectUpstreamLimits: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        /**
+         * Custom rate limit headers to check
+         */
         rateLimitHeaders: z.ZodOptional<z.ZodObject<{
             remaining: z.ZodDefault<z.ZodOptional<z.ZodString>>;
             limit: z.ZodDefault<z.ZodOptional<z.ZodString>>;
             reset: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
+        }, "strip", z.ZodTypeAny, {
+            limit: string;
+            remaining: string;
+            reset: string;
+        }, {
+            limit?: string | undefined;
+            remaining?: string | undefined;
+            reset?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        maxRequests: number;
+        strategy: "sliding_window" | "token_bucket" | "fixed_window" | "leaky_bucket";
+        windowSeconds: number;
+        respectUpstreamLimits: boolean;
+        burstCapacity?: number | undefined;
+        rateLimitHeaders?: {
+            limit: string;
+            remaining: string;
+            reset: string;
+        } | undefined;
+    }, {
+        maxRequests: number;
+        windowSeconds: number;
+        strategy?: "sliding_window" | "token_bucket" | "fixed_window" | "leaky_bucket" | undefined;
+        burstCapacity?: number | undefined;
+        respectUpstreamLimits?: boolean | undefined;
+        rateLimitHeaders?: {
+            limit?: string | undefined;
+            remaining?: string | undefined;
+            reset?: string | undefined;
+        } | undefined;
+    }>>;
+    /**
+     * Retry configuration
+     */
     retryConfig: z.ZodOptional<z.ZodObject<{
-        strategy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-            no_retry: "no_retry";
-            exponential_backoff: "exponential_backoff";
-            linear_backoff: "linear_backoff";
-            fixed_delay: "fixed_delay";
-        }>>>;
+        /**
+         * Retry strategy
+         */
+        strategy: z.ZodDefault<z.ZodOptional<z.ZodEnum<["exponential_backoff", "linear_backoff", "fixed_delay", "no_retry"]>>>;
+        /**
+         * Maximum retry attempts
+         */
         maxAttempts: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        /**
+         * Initial delay in milliseconds
+         */
         initialDelayMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        /**
+         * Maximum delay in milliseconds
+         */
         maxDelayMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        /**
+         * Backoff multiplier (for exponential backoff)
+         */
         backoffMultiplier: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-        retryableStatusCodes: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodNumber>>>;
+        /**
+         * HTTP status codes to retry
+         */
+        retryableStatusCodes: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>>;
+        /**
+         * Retry on network errors
+         */
         retryOnNetworkError: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        /**
+         * Jitter to add randomness to retry delays
+         */
         jitter: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    }, z.core.$strip>>;
+    }, "strip", z.ZodTypeAny, {
+        strategy: "no_retry" | "exponential_backoff" | "linear_backoff" | "fixed_delay";
+        maxAttempts: number;
+        backoffMultiplier: number;
+        initialDelayMs: number;
+        maxDelayMs: number;
+        retryableStatusCodes: number[];
+        retryOnNetworkError: boolean;
+        jitter: boolean;
+    }, {
+        strategy?: "no_retry" | "exponential_backoff" | "linear_backoff" | "fixed_delay" | undefined;
+        maxAttempts?: number | undefined;
+        backoffMultiplier?: number | undefined;
+        initialDelayMs?: number | undefined;
+        maxDelayMs?: number | undefined;
+        retryableStatusCodes?: number[] | undefined;
+        retryOnNetworkError?: boolean | undefined;
+        jitter?: boolean | undefined;
+    }>>;
+    /**
+     * Connection timeout in milliseconds
+     */
     connectionTimeoutMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    /**
+     * Request timeout in milliseconds
+     */
     requestTimeoutMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    status: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        error: "error";
-        active: "active";
-        inactive: "inactive";
-        configuring: "configuring";
-    }>>>;
+    /**
+     * Connector status
+     */
+    status: z.ZodDefault<z.ZodOptional<z.ZodEnum<["active", "inactive", "error", "configuring"]>>>;
+    /**
+     * Enable connector
+     */
     enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    /**
+     * Custom metadata
+     */
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    type: "custom" | "database" | "api" | "saas" | "file_storage" | "message_queue";
+    status: "active" | "error" | "inactive" | "configuring";
+    enabled: boolean;
+    label: string;
+    name: string;
+    authentication: {
+        type: "oauth2";
+        clientId: string;
+        clientSecret: string;
+        authorizationUrl: string;
+        tokenUrl: string;
+        refreshToken?: string | undefined;
+        scopes?: string[] | undefined;
+        redirectUri?: string | undefined;
+        tokenExpiry?: number | undefined;
+    } | {
+        type: "api-key";
+        key: string;
+        headerName: string;
+        paramName?: string | undefined;
+    } | {
+        type: "basic";
+        password: string;
+        username: string;
+    } | {
+        type: "bearer";
+        token: string;
+    } | {
+        type: "none";
+    };
+    connectionTimeoutMs: number;
+    requestTimeoutMs: number;
+    description?: string | undefined;
+    icon?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+    fieldMappings?: {
+        source: string;
+        target: string;
+        required: boolean;
+        syncMode: "bidirectional" | "read_only" | "write_only";
+        transform?: {
+            type: "constant";
+            value?: any;
+        } | {
+            type: "cast";
+            targetType: "string" | "number" | "boolean" | "date";
+        } | {
+            type: "lookup";
+            table: string;
+            keyField: string;
+            valueField: string;
+        } | {
+            type: "javascript";
+            expression: string;
+        } | {
+            type: "map";
+            mappings: Record<string, any>;
+        } | undefined;
+        defaultValue?: any;
+        dataType?: "string" | "number" | "boolean" | "date" | "array" | "datetime" | "json" | undefined;
+    }[] | undefined;
+    actions?: {
+        label: string;
+        key: string;
+        description?: string | undefined;
+        inputSchema?: Record<string, any> | undefined;
+        outputSchema?: Record<string, any> | undefined;
+    }[] | undefined;
+    webhooks?: {
+        url: string;
+        name: string;
+        method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+        timeoutMs: number;
+        includeSession: boolean;
+        isActive: boolean;
+        signatureAlgorithm: "none" | "hmac_sha256" | "hmac_sha512";
+        object?: string | undefined;
+        tags?: string[] | undefined;
+        label?: string | undefined;
+        description?: string | undefined;
+        events?: ("record.created" | "record.updated" | "record.deleted" | "sync.started" | "sync.completed" | "sync.failed" | "auth.expired" | "rate_limit.exceeded")[] | undefined;
+        headers?: Record<string, string> | undefined;
+        authentication?: {
+            type: "none" | "api-key" | "basic" | "bearer";
+            credentials?: Record<string, string> | undefined;
+        } | undefined;
+        body?: any;
+        secret?: string | undefined;
+        retryPolicy?: {
+            maxRetries: number;
+            backoffStrategy: "fixed" | "linear" | "exponential";
+            initialDelayMs: number;
+            maxDelayMs: number;
+        } | undefined;
+        triggers?: ("update" | "delete" | "create" | "api" | "undelete")[] | undefined;
+        payloadFields?: string[] | undefined;
+    }[] | undefined;
+    triggers?: {
+        type: "webhook" | "polling";
+        label: string;
+        key: string;
+        description?: string | undefined;
+        interval?: number | undefined;
+    }[] | undefined;
+    syncConfig?: {
+        strategy: "full" | "upsert" | "incremental" | "append_only";
+        batchSize: number;
+        direction: "import" | "export" | "bidirectional";
+        conflictResolution: "manual" | "source_wins" | "latest_wins" | "target_wins";
+        realtimeSync: boolean;
+        deleteMode: "ignore" | "hard_delete" | "soft_delete";
+        filters?: Record<string, any> | undefined;
+        schedule?: string | undefined;
+        timestampField?: string | undefined;
+    } | undefined;
+    rateLimitConfig?: {
+        maxRequests: number;
+        strategy: "sliding_window" | "token_bucket" | "fixed_window" | "leaky_bucket";
+        windowSeconds: number;
+        respectUpstreamLimits: boolean;
+        burstCapacity?: number | undefined;
+        rateLimitHeaders?: {
+            limit: string;
+            remaining: string;
+            reset: string;
+        } | undefined;
+    } | undefined;
+    retryConfig?: {
+        strategy: "no_retry" | "exponential_backoff" | "linear_backoff" | "fixed_delay";
+        maxAttempts: number;
+        backoffMultiplier: number;
+        initialDelayMs: number;
+        maxDelayMs: number;
+        retryableStatusCodes: number[];
+        retryOnNetworkError: boolean;
+        jitter: boolean;
+    } | undefined;
+}, {
+    type: "custom" | "database" | "api" | "saas" | "file_storage" | "message_queue";
+    label: string;
+    name: string;
+    authentication: {
+        type: "oauth2";
+        clientId: string;
+        clientSecret: string;
+        authorizationUrl: string;
+        tokenUrl: string;
+        refreshToken?: string | undefined;
+        scopes?: string[] | undefined;
+        redirectUri?: string | undefined;
+        tokenExpiry?: number | undefined;
+    } | {
+        type: "api-key";
+        key: string;
+        headerName?: string | undefined;
+        paramName?: string | undefined;
+    } | {
+        type: "basic";
+        password: string;
+        username: string;
+    } | {
+        type: "bearer";
+        token: string;
+    } | {
+        type: "none";
+    };
+    status?: "active" | "error" | "inactive" | "configuring" | undefined;
+    enabled?: boolean | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+    fieldMappings?: {
+        source: string;
+        target: string;
+        transform?: {
+            type: "constant";
+            value?: any;
+        } | {
+            type: "cast";
+            targetType: "string" | "number" | "boolean" | "date";
+        } | {
+            type: "lookup";
+            table: string;
+            keyField: string;
+            valueField: string;
+        } | {
+            type: "javascript";
+            expression: string;
+        } | {
+            type: "map";
+            mappings: Record<string, any>;
+        } | undefined;
+        defaultValue?: any;
+        required?: boolean | undefined;
+        dataType?: "string" | "number" | "boolean" | "date" | "array" | "datetime" | "json" | undefined;
+        syncMode?: "bidirectional" | "read_only" | "write_only" | undefined;
+    }[] | undefined;
+    actions?: {
+        label: string;
+        key: string;
+        description?: string | undefined;
+        inputSchema?: Record<string, any> | undefined;
+        outputSchema?: Record<string, any> | undefined;
+    }[] | undefined;
+    webhooks?: {
+        url: string;
+        name: string;
+        object?: string | undefined;
+        tags?: string[] | undefined;
+        label?: string | undefined;
+        description?: string | undefined;
+        events?: ("record.created" | "record.updated" | "record.deleted" | "sync.started" | "sync.completed" | "sync.failed" | "auth.expired" | "rate_limit.exceeded")[] | undefined;
+        method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | undefined;
+        headers?: Record<string, string> | undefined;
+        authentication?: {
+            type: "none" | "api-key" | "basic" | "bearer";
+            credentials?: Record<string, string> | undefined;
+        } | undefined;
+        body?: any;
+        secret?: string | undefined;
+        retryPolicy?: {
+            maxRetries?: number | undefined;
+            backoffStrategy?: "fixed" | "linear" | "exponential" | undefined;
+            initialDelayMs?: number | undefined;
+            maxDelayMs?: number | undefined;
+        } | undefined;
+        timeoutMs?: number | undefined;
+        triggers?: ("update" | "delete" | "create" | "api" | "undelete")[] | undefined;
+        payloadFields?: string[] | undefined;
+        includeSession?: boolean | undefined;
+        isActive?: boolean | undefined;
+        signatureAlgorithm?: "none" | "hmac_sha256" | "hmac_sha512" | undefined;
+    }[] | undefined;
+    triggers?: {
+        type: "webhook" | "polling";
+        label: string;
+        key: string;
+        description?: string | undefined;
+        interval?: number | undefined;
+    }[] | undefined;
+    syncConfig?: {
+        strategy?: "full" | "upsert" | "incremental" | "append_only" | undefined;
+        filters?: Record<string, any> | undefined;
+        batchSize?: number | undefined;
+        schedule?: string | undefined;
+        direction?: "import" | "export" | "bidirectional" | undefined;
+        conflictResolution?: "manual" | "source_wins" | "latest_wins" | "target_wins" | undefined;
+        realtimeSync?: boolean | undefined;
+        timestampField?: string | undefined;
+        deleteMode?: "ignore" | "hard_delete" | "soft_delete" | undefined;
+    } | undefined;
+    rateLimitConfig?: {
+        maxRequests: number;
+        windowSeconds: number;
+        strategy?: "sliding_window" | "token_bucket" | "fixed_window" | "leaky_bucket" | undefined;
+        burstCapacity?: number | undefined;
+        respectUpstreamLimits?: boolean | undefined;
+        rateLimitHeaders?: {
+            limit?: string | undefined;
+            remaining?: string | undefined;
+            reset?: string | undefined;
+        } | undefined;
+    } | undefined;
+    retryConfig?: {
+        strategy?: "no_retry" | "exponential_backoff" | "linear_backoff" | "fixed_delay" | undefined;
+        maxAttempts?: number | undefined;
+        backoffMultiplier?: number | undefined;
+        initialDelayMs?: number | undefined;
+        maxDelayMs?: number | undefined;
+        retryableStatusCodes?: number[] | undefined;
+        retryOnNetworkError?: boolean | undefined;
+        jitter?: boolean | undefined;
+    } | undefined;
+    connectionTimeoutMs?: number | undefined;
+    requestTimeoutMs?: number | undefined;
+}>;
 export type Connector = z.infer<typeof ConnectorSchema>;
 //# sourceMappingURL=connector.zod.d.ts.map