@nangohq/types 0.71.3 → 0.71.5

package/dist/auth/http.api.d.ts

@@ -1,4 +1,5 @@
 import type { ApiEndpoint, ApiError } from '../api.js';
+import type { AuditPolicy } from '../audit-trail/event.js';
 export type ConnectionQueryString = {
     connection_id?: string | undefined;
     params?: Record<string, any> | undefined;
@@ -35,10 +36,7 @@ export interface WebSocketConnectionResponseSuccess {
 }
 type AuthErrors = ApiError<'invalid_body'> | ApiError<'invalid_query_params'> | ApiError<'unknown_provider_config'> | ApiError<'unknown_provider_template'> | ApiError<'invalid_auth_mode'> | ApiError<'invalid_credentials'> | ApiError<'integration_not_allowed'> | ApiError<'invalid_connection'> | ApiError<'connection_test_failed'> | ApiError<'connection_validation_failed'>;
 export type PostPublicApiKeyAuthorization = ApiEndpoint<{
-    Audit: {
-        kind: 'no-audit';
-        reason: 'TODO: audit coverage pending';
-    };
+    Audit: AuditPolicy<'connection', 'created', 'environment'>;
     Method: 'POST';
     Body: {
         apiKey: string;
@@ -52,10 +50,7 @@ export type PostPublicApiKeyAuthorization = ApiEndpoint<{
     Success: ConnectionResponseSuccess;
 }>;
 export type PostPublicBasicAuthorization = ApiEndpoint<{
-    Audit: {
-        kind: 'no-audit';
-        reason: 'TODO: audit coverage pending';
-    };
+    Audit: AuditPolicy<'connection', 'created', 'environment'>;
     Method: 'POST';
     Body: {
         username: string;
@@ -70,10 +65,7 @@ export type PostPublicBasicAuthorization = ApiEndpoint<{
     Success: ConnectionResponseSuccess;
 }>;
 export type PostPublicTbaAuthorization = ApiEndpoint<{
-    Audit: {
-        kind: 'no-audit';
-        reason: 'TODO: audit coverage pending';
-    };
+    Audit: AuditPolicy<'connection', 'created', 'environment'>;
     Method: 'POST';
     Body: {
         token_id: string;
@@ -91,10 +83,7 @@ export type PostPublicTbaAuthorization = ApiEndpoint<{
     Success: ConnectionResponseSuccess;
 }>;
 export type PostPublicJwtAuthorization = ApiEndpoint<{
-    Audit: {
-        kind: 'no-audit';
-        reason: 'TODO: audit coverage pending';
-    };
+    Audit: AuditPolicy<'connection', 'created', 'environment'>;
     Method: 'POST';
     Body: Record<string, any>;
     Querystring: ConnectionQueryString;
@@ -106,10 +95,7 @@ export type PostPublicJwtAuthorization = ApiEndpoint<{
     Success: ConnectionResponseSuccess;
 }>;
 export type PostPublicUnauthenticatedAuthorization = ApiEndpoint<{
-    Audit: {
-        kind: 'no-audit';
-        reason: 'TODO: audit coverage pending';
-    };
+    Audit: AuditPolicy<'connection', 'created', 'environment'>;
     Method: 'POST';
     Querystring: ConnectionQueryString;
     Params: {
@@ -120,10 +106,7 @@ export type PostPublicUnauthenticatedAuthorization = ApiEndpoint<{
     Success: ConnectionResponseSuccess;
 }>;
 export type PostPublicBillAuthorization = ApiEndpoint<{
-    Audit: {
-        kind: 'no-audit';
-        reason: 'TODO: audit coverage pending';
-    };
+    Audit: AuditPolicy<'connection', 'created', 'environment'>;
     Method: 'POST';
     Body: {
         username: string;
@@ -140,10 +123,7 @@ export type PostPublicBillAuthorization = ApiEndpoint<{
     Success: ConnectionResponseSuccess;
 }>;
 export type PostPublicTwoStepAuthorization = ApiEndpoint<{
-    Audit: {
-        kind: 'no-audit';
-        reason: 'TODO: audit coverage pending';
-    };
+    Audit: AuditPolicy<'connection', 'created', 'environment'>;
     Method: 'POST';
     Body: Record<string, any>;
     Querystring: ConnectionQueryString;
@@ -155,10 +135,7 @@ export type PostPublicTwoStepAuthorization = ApiEndpoint<{
     Success: ConnectionResponseSuccess;
 }>;
 export type PostPublicSignatureAuthorization = ApiEndpoint<{
-    Audit: {
-        kind: 'no-audit';
-        reason: 'TODO: audit coverage pending';
-    };
+    Audit: AuditPolicy<'connection', 'created', 'environment'>;
     Method: 'POST';
     Body: {
         username: string;
@@ -174,10 +151,7 @@ export type PostPublicSignatureAuthorization = ApiEndpoint<{
 }>;
 type AwsSigV4AuthErrors = AuthErrors | ApiError<'invalid_aws_sigv4_config'> | ApiError<'missing_aws_sigv4_service'> | ApiError<'missing_aws_sigv4_sts_endpoint'> | ApiError<'missing_aws_sigv4_builtin_credentials'> | ApiError<'missing_aws_sigv4_region'> | ApiError<'aws_sigv4_sts_request_failed'>;
 export type PostPublicAwsSigV4Authorization = ApiEndpoint<{
-    Audit: {
-        kind: 'no-audit';
-        reason: 'TODO: audit coverage pending';
-    };
+    Audit: AuditPolicy<'connection', 'created', 'environment'>;
     Method: 'POST';
     Body: {
         role_arn: string;
@@ -192,10 +166,7 @@ export type PostPublicAwsSigV4Authorization = ApiEndpoint<{
     Success: ConnectionResponseSuccess;
 }>;
 export type PostPublicOauthOutboundAuthorization = ApiEndpoint<{
-    Audit: {
-        kind: 'no-audit';
-        reason: 'TODO: audit coverage pending';
-    };
+    Audit: AuditPolicy<'connection', 'created', 'environment'>;
     Method: 'POST';
     Body: {
         username: string;

package/dist/authz/types.d.ts

@@ -1,6 +1,6 @@
 import type { Role } from '../user/db.js';
 export type Action = 'create' | 'read' | 'update' | 'delete' | '*';
-export type Resource = 'team' | 'team_member' | 'invite' | 'connect_ui_settings' | 'billing' | 'plan' | 'environment' | 'environment_production_flag' | 'environment_key' | 'environment_variable' | 'webhook' | 'integration' | 'connection' | 'flow' | 'sync_command' | 'secret_key' | 'connection_credential' | 'log' | 'audit_trail' | '*';
+export type Resource = 'team' | 'team_member' | 'invite' | 'connect_ui_settings' | 'billing' | 'plan' | 'environment' | 'environment_production_flag' | 'environment_key' | 'account_key' | 'environment_variable' | 'webhook' | 'integration' | 'connection' | 'flow' | 'sync_command' | 'secret_key' | 'connection_credential' | 'log' | 'audit_trail' | '*';
 export type Scope = 'production' | 'non-production' | 'global';
 export interface Permission {
     action: Action;

package/dist/billing/types.d.ts

@@ -8,6 +8,14 @@ export interface BillingClient {
     getCustomer: (accountId: number) => Promise<Result<BillingCustomer>>;
     putCustomer: (accountId: number, invoicingDetails: BillingInvoicingDetails) => Promise<Result<BillingCustomer>>;
     getSubscription: (accountId: number) => Promise<Result<BillingSubscription | null>>;
+    getOverdueInvoices: (accountId: number) => Promise<Result<BillingOverdueInvoices>>;
+    getUpcomingInvoice: (subscriptionId: string) => Promise<Result<BillingUpcomingInvoice | null>>;
+    getPeriodCosts: (subscriptionId: string) => Promise<Result<BillingPeriodCosts | null>>;
+    getSpendAlert: (subscriptionId: string) => Promise<Result<BillingSpendAlert | null>>;
+    setSpendAlert: (subscriptionId: string, opts: {
+        thresholdInCents: number;
+    }) => Promise<Result<BillingSpendAlert>>;
+    removeSpendAlert: (subscriptionId: string) => Promise<Result<void>>;
     createSubscription: (team: DBTeam, planExternalId: string) => Promise<Result<BillingSubscription>>;
     getUsage: (subscriptionId: string, opts?: GetBillingUsageOpts) => Promise<Result<BillingUsageMetrics>>;
     upgrade: (opts: {
@@ -49,6 +57,7 @@ export interface BillingCustomer {
 export interface BillingInvoicingDetails {
     legalEntityName: string;
     email: string;
+    additionalEmails: string[];
     address: BillingAddress | null;
     taxId: BillingTaxId | null;
 }
@@ -70,6 +79,42 @@ export interface BillingSubscription {
     pendingChangeId?: string | undefined;
     planExternalId: string;
 }
+export interface BillingOverdueInvoices {
+    hasOverdue: boolean;
+}
+/** Orb's upcoming invoice for a subscription — the whole invoice, not a month's slice of it. */
+export interface BillingUpcomingInvoice {
+    amountInCents: number;
+    /** ISO 4217, uppercased. Orb's `credits` is rejected upstream. */
+    currency: string;
+}
+/** Orb's single `cost_exceeded` alert for a subscription; Orb holds all of its state. */
+export interface BillingSpendAlert {
+    id: string;
+    thresholdInCents: number;
+    /** ISO 4217, uppercased. Null when Orb reports a unit that isn't a currency. */
+    currency: string | null;
+}
+export interface BillingPeriodCosts {
+    /** Integer cents charged this billing period per metric, excluding every fixed price. A metric is
+     *  absent when the subscription carries no price for it, which is not the same as being charged 0. */
+    metrics: Partial<Record<UsageMetric, number>>;
+    /** Metrics with a real price whose charge we couldn't read — an unparseable amount, or a currency
+     *  other prices don't share. A charge exists; we just can't state it, so it reads as a dash, not $0. */
+    malformedMetrics: UsageMetric[];
+    /** False when a price maps to no metric of ours, so an unpriced row can't safely claim $0 — the
+     *  money might be one of theirs. */
+    fullyAttributed: boolean;
+    /** The individual prices behind `malformedMetrics` and a false `fullyAttributed`, for alerting —
+     *  not sent over HTTP. */
+    flagged: {
+        priceId: string;
+        priceName: string;
+        metric: UsageMetric | null;
+        amountInCents: number | null;
+    }[];
+    currency: string;
+}
 export type CounterUsageMetric = Exclude<UsageMetric, 'records' | 'connections'>;
 export type AvgUsageMetric = Extract<UsageMetric, 'records' | 'connections'>;
 export interface BreakdownDimensions {
@@ -77,6 +122,7 @@ export interface BreakdownDimensions {
     function_executions: 'environment_id' | 'integration_id' | 'connection_id' | 'function_name' | 'function_type' | 'success';
     function_logs: 'environment_id' | 'integration_id' | 'connection_id' | 'function_name' | 'function_type' | 'success';
     function_compute_gbms: 'environment_id' | 'integration_id' | 'connection_id' | 'function_name' | 'function_type' | 'success';
+    function_duration_seconds: 'environment_id' | 'integration_id' | 'connection_id' | 'function_name' | 'function_type' | 'success';
     webhook_forwards: 'environment_id' | 'integration_id' | 'connection_id' | 'success';
     records: 'environment_id' | 'integration_id' | 'connection_id' | 'model';
     connections: 'environment_id' | 'integration_id';

package/dist/connection/api/get.d.ts

@@ -171,7 +171,7 @@ export type GetPublicConnection = ApiEndpoint<{
         refresh_github_app_jwt_token?: boolean | undefined;
     };
     Path: '/connection/:connectionId';
-    Error: ApiError<'unknown_provider_config' | 'invalid_credentials'>;
+    Error: ApiError<'unknown_provider_config' | 'not_found' | 'invalid_credentials' | 'server_error'>;
     Success: ApiPublicConnectionFull;
 }>;
 export type PatchPublicConnection = ApiEndpoint<{

package/dist/connection/api/metadata.d.ts

@@ -8,7 +8,10 @@ export interface MetadataBody {
 }
 type MetadataError = ApiError<'invalid_body'> | ApiError<'unknown_connection'>;
 export type SetMetadata = ApiEndpoint<{
-    Audit: AuditPolicy<'connection', 'metadata_updated', 'environment'>;
+    Audit: {
+        kind: 'no-audit';
+        reason: 'data-plane operation';
+    };
     Method: 'POST';
     Body: MetadataBody;
     Path: '/connection/metadata';
@@ -16,7 +19,10 @@ export type SetMetadata = ApiEndpoint<{
     Success: MetadataBody;
 }>;
 export type UpdateMetadata = ApiEndpoint<{
-    Audit: AuditPolicy<'connection', 'metadata_updated', 'environment'>;
+    Audit: {
+        kind: 'no-audit';
+        reason: 'data-plane operation';
+    };
     Method: 'PATCH';
     Path: '/connection/metadata';
     Body: MetadataBody;

package/dist/environment/api/index.d.ts

@@ -30,6 +30,39 @@ export type PostEnvironment = ApiEndpoint<{
     Success: {
         data: Pick<DBEnvironment, 'id' | 'name'>;
     };
+    Error: ApiError<'conflict' | 'resource_capped' | 'invalid_is_prod_flag'>;
+}>;
+export type PostPublicEnvironment = ApiEndpoint<{
+    Audit: AuditPolicy<'environment', 'created', 'account'>;
+    Method: 'POST';
+    Path: '/environments';
+    Body: {
+        name: string;
+        is_production?: boolean | undefined;
+        callback_url?: string | undefined;
+        hmac_key?: string | undefined;
+        hmac_enabled?: boolean | undefined;
+        slack_notifications?: boolean | undefined;
+        otlp_endpoint?: string | undefined;
+        otlp_headers?: {
+            name: string;
+            value: string;
+        }[] | undefined;
+    };
+    Success: {
+        data: Pick<DBEnvironment, 'id' | 'name'>;
+    };
+    Error: ApiError<'conflict' | 'resource_capped' | 'invalid_is_prod_flag'>;
+}>;
+export type DeletePublicEnvironment = ApiEndpoint<{
+    Audit: AuditPolicy<'environment', 'deleted', 'account'>;
+    Method: 'DELETE';
+    Path: '/environments/:environmentId';
+    Params: {
+        environmentId: number;
+    };
+    Success: never;
+    Error: ApiError<'cannot_delete_prod_environment'>;
 }>;
 export type GetEnvironment = ApiEndpoint<{
     Audit: {
@@ -82,6 +115,28 @@ export type DeleteEnvironment = ApiEndpoint<{
     Success: never;
     Error: ApiError<'cannot_delete_prod_environment'>;
 }>;
+export type PostRotateWebhookSigningKey = ApiEndpoint<{
+    Audit: AuditPolicy<'environment', 'webhook_signing_key_rotated', 'environment'>;
+    Method: 'POST';
+    Path: '/api/v1/environment/webhook-signing-key/rotate';
+    Success: {
+        data: {
+            webhook_signing_key: string;
+        };
+    };
+    Error: ApiError<'not_found'> | ApiError<'multiple_webhook_signing_keys'> | ApiError<'rotation_failed'>;
+}>;
+export type PostPublicRotateWebhookSigningKey = ApiEndpoint<{
+    Audit: AuditPolicy<'environment', 'webhook_signing_key_rotated', 'environment'>;
+    Method: 'POST';
+    Path: '/environment/webhook-signing-key/rotate';
+    Success: {
+        data: {
+            webhook_signing_key: string;
+        };
+    };
+    Error: ApiError<'not_found'> | ApiError<'multiple_webhook_signing_keys'> | ApiError<'rotation_failed'>;
+}>;
 export type GetPublicEnvironmentVariables = ApiEndpoint<{
     Audit: {
         kind: 'no-audit';
@@ -131,6 +186,37 @@ export type CreateApiKey = ApiEndpoint<{
     };
     Error: ApiError<'conflict' | 'resource_capped'>;
 }>;
+export type PostPublicApiKey = ApiEndpoint<{
+    Audit: AuditPolicy<'api_key', 'created', 'environment'>;
+    Method: 'POST';
+    Path: '/environment/api-keys';
+    Body: {
+        environment_id: number;
+        display_name: string;
+    };
+    Success: {
+        data: {
+            id: number;
+            display_name: string;
+            scopes: ApiKeyScope[];
+            secret: string;
+            created_at: string;
+        };
+    };
+    Error: ApiError<'conflict' | 'resource_capped'>;
+}>;
+export type DeletePublicApiKey = ApiEndpoint<{
+    Audit: AuditPolicy<'api_key', 'deleted', 'environment'>;
+    Method: 'DELETE';
+    Path: '/environment/api-keys';
+    Body: {
+        environment_id: number;
+        key_id: number;
+    };
+    Success: {
+        success: true;
+    };
+}>;
 export type DeleteApiKey = ApiEndpoint<{
     Audit: AuditPolicy<'api_key', 'deleted', 'environment'>;
     Method: 'DELETE';

package/dist/{functions → function}/config.d.ts

@@ -1,4 +1,11 @@
 import type { OnEventType } from '../scripts/on-events/api.js';
+export interface FunctionCapabilities {
+    usesRecords: boolean;
+    usesOutbound: boolean;
+    usesCheckpoints: boolean;
+    usesMetadata: boolean;
+    usesInvoke: boolean;
+}
 /**
  * Declares where the debounce/coalescing key is extracted from:
  * - `{ body: '$.portalId' }`: dot notation path into the body
@@ -12,13 +19,13 @@ export type DebounceKeySource = {
 /** Coalesces a burst of inbound HTTP requests into a single function run within a sliding window. */
 export interface DebounceOptions {
     /** Events sharing the same resolved key coalesce together. */
-    keyBy?: DebounceKeySource | DebounceKeySource[];
+    keyBy?: DebounceKeySource | DebounceKeySource[] | undefined;
     /** Sliding window in milliseconds. */
     windowMs: number;
     /** When exceeded, the window stops sliding. */
-    maxEntities?: number;
+    maxEntities?: number | undefined;
     /** Which payloads from the coalesced window the handler receives. */
-    take?: 'latest' | 'first' | 'all';
+    take?: 'latest' | 'first' | 'all' | undefined;
 }
 /**
  * Declares how a function is initiated from outside; `kind` discriminates the source.
@@ -32,11 +39,11 @@ export type FunctionTriggerDefinition = {
 } | {
     kind: 'schedule';
     frequency: string;
-    autoStart?: boolean;
+    autoStart?: boolean | undefined;
 } | {
     kind: 'http';
-    subscriptions?: string[];
-    debounce?: DebounceOptions;
+    subscriptions?: string[] | undefined;
+    debounce?: DebounceOptions | undefined;
 } | {
     kind: 'event';
     events: OnEventType[];
@@ -45,14 +52,14 @@ export type FunctionConcurrencyLimit = 1 | 'max';
 export interface FunctionLimits {
     concurrency?: {
         perConnection: FunctionConcurrencyLimit;
-    };
+    } | undefined;
 }
-export type Requires = {
-    connection?: true;
-    outbound?: boolean;
-    invoke?: boolean;
+export type FunctionRequires = {
+    connection?: true | undefined;
+    outbound?: boolean | undefined;
+    invoke?: boolean | undefined;
 } | {
     connection: false;
-    outbound?: false;
-    invoke?: boolean;
+    outbound?: false | undefined;
+    invoke?: boolean | undefined;
 };

package/dist/function/db.d.ts

@@ -1,7 +1,6 @@
 import type { TimestampsAndDeletedAt } from '../db.js';
-import type { FunctionCapabilities } from '../functions/capabilities.js';
-import type { FunctionLimits, FunctionTriggerDefinition, Requires } from '../functions/config.js';
 import type { FunctionSource } from '../syncConfigs/db.js';
+import type { FunctionCapabilities, FunctionLimits, FunctionRequires, FunctionTriggerDefinition } from './config.js';
 import type { JSONSchema7 } from 'json-schema';
 export interface DBFunctionConfig extends TimestampsAndDeletedAt {
     id: number;
@@ -19,7 +18,7 @@ export interface DBFunctionConfigVersion extends TimestampsAndDeletedAt {
     version: string;
     source: FunctionSource;
     trigger: FunctionTriggerDefinition;
-    requires: Requires;
+    requires: FunctionRequires;
     capabilities: FunctionCapabilities;
     limits: FunctionLimits;
     input_schema_ref: string | null;

package/dist/function/trigger.d.ts

@@ -0,0 +1,61 @@
+import type { HTTP_METHOD } from '../nangoYaml/index.js';
+import type { OnEventType } from '../scripts/on-events/api.js';
+import type { FunctionTriggerDefinition } from './config.js';
+import type { JsonValue } from 'type-fest';
+export type HttpRequest = {
+    method: HTTP_METHOD;
+    path: string;
+    headers: Record<string, string>;
+    query: Record<string, string>;
+    body: JsonValue;
+};
+export type CoalescedInfo = {
+    count: number;
+    firstSeenAt: string;
+    lastSeenAt: string;
+};
+type HttpPayload<TTrigger, TInput> = TTrigger extends {
+    debounce: {
+        take: 'all';
+    };
+} ? TInput[] : TInput;
+type TriggerBase = {
+    /**
+     * Present when the run carries connection context (invoke calls may pass one;
+     * HTTP/event may resolve one). Undefined for connection-less runs.
+     */
+    connection?: {
+        connectionId: string;
+        integrationId: string;
+    };
+};
+export type InvokeTrigger<TInput> = TriggerBase & {
+    kind: 'invoke';
+    input: TInput;
+};
+export type ScheduleTrigger = TriggerBase & {
+    kind: 'schedule';
+    input: null;
+};
+export type HttpTrigger<TTrigger, TInput> = TriggerBase & {
+    kind: 'http';
+    input: HttpPayload<TTrigger, TInput>;
+    request: HttpRequest;
+    subscriptions?: string[];
+    coalesced?: CoalescedInfo;
+};
+export type EventTrigger = TriggerBase & {
+    kind: 'event';
+    input: {
+        event: OnEventType;
+    };
+};
+export type Trigger<TTrigger extends FunctionTriggerDefinition | undefined, TInput> = TTrigger extends {
+    kind: 'schedule';
+} ? ScheduleTrigger : TTrigger extends {
+    kind: 'http';
+} ? HttpTrigger<TTrigger, TInput> : TTrigger extends {
+    kind: 'event';
+} ? EventTrigger : InvokeTrigger<TInput>;
+export type FunctionTrigger = Trigger<FunctionTriggerDefinition, JsonValue>;
+export {};

package/dist/functions/api.d.ts

@@ -1,6 +1,8 @@
 import type { ApiEndpoint, ApiError } from '../api.js';
 import type { AuditPolicy } from '../audit-trail/event.js';
+import type { FunctionCapabilities, FunctionLimits, FunctionRequires, FunctionTriggerDefinition } from '../function/config.js';
 import type { DeployedNangoFunction, FunctionType, NangoActionFunction, NangoFunctionTemplate, NangoSyncFunction } from './domain.js';
+import type { JSONSchema7 } from 'json-schema';
 export type RunnableFunctionType = Extract<FunctionType, 'action' | 'sync'>;
 export type FunctionErrorCode = 'invalid_request' | 'server_error' | 'integration_not_found' | 'compilation_error' | 'dryrun_error' | 'deployment_error' | 'connection_not_found' | 'dryrun_not_found' | 'deployment_not_found' | 'function_disabled' | 'execution_environment_unavailable' | 'timeout' | 'validation_error';
 export interface ProxyCall {
@@ -219,6 +221,40 @@ export type PostFunctionDeploymentResult = ApiEndpoint<{
         ok: true;
     };
 }>;
+export type FunctionInvocationType = 'wait' | 'no_wait';
+export type FunctionInvocationErrorCode = 'function_failed' | 'server_error' | 'connection_not_found' | 'function_not_found' | 'function_disabled' | 'validation_error' | 'invalid_invocation';
+type FunctionInvocationSuccess = any;
+export type PostFunctionInvocation = ApiEndpoint<{
+    Audit: {
+        kind: 'no-audit';
+        reason: 'non-auditable';
+    };
+    Method: 'POST';
+    Path: '/functions/invocations';
+    Body: {
+        connection_id: string;
+        integration_id: string;
+        name: string;
+        input?: unknown | undefined;
+        invocation_type: FunctionInvocationType;
+        options?: Record<string, unknown> | undefined;
+    };
+    Error: ApiError<FunctionInvocationErrorCode>;
+    Success: FunctionInvocationSuccess;
+}>;
+export type GetFunctionInvocation = ApiEndpoint<{
+    Audit: {
+        kind: 'no-audit';
+        reason: 'non-auditable';
+    };
+    Method: 'GET';
+    Path: '/functions/invocations/:id';
+    Params: {
+        id: string;
+    };
+    Error: ApiError<'invalid_uri_params' | 'not_found' | 'function_failed' | 'server_error'>;
+    Success: FunctionInvocationSuccess;
+}>;
 export interface FunctionListFilters {
     type?: FunctionType;
     search?: string;
@@ -380,3 +416,70 @@ export type GetIntegrationTemplates = ApiEndpoint<{
         data: NangoFunctionTemplate[];
     };
 }>;
+export interface FunctionDeploymentArtifact {
+    name: string;
+    integrationId: string;
+    description: string;
+    trigger: FunctionTriggerDefinition;
+    requires: FunctionRequires;
+    capabilities: FunctionCapabilities;
+    limits: FunctionLimits;
+    input_schema_ref: string | null;
+    output_schema_ref: string | null;
+    model_schema_refs: string[];
+    metadata_schema_ref: string | null;
+    checkpoint_schema_ref: string | null;
+    json_schema: JSONSchema7;
+    fileBody: {
+        js: string;
+        ts: string;
+    };
+}
+export type FunctionReconciliationScope = {
+    kind: 'environment';
+} | {
+    kind: 'integration';
+    integrationId: string;
+};
+export interface FunctionDeploymentBundleBody {
+    reconciliationScope: FunctionReconciliationScope;
+    functions: FunctionDeploymentArtifact[];
+}
+export interface FunctionDeploymentBundleSuccess {
+    created: {
+        integrationId: string;
+        name: string;
+    }[];
+    updated: {
+        integrationId: string;
+        name: string;
+    }[];
+    unchanged: {
+        integrationId: string;
+        name: string;
+    }[];
+    deleted: {
+        integrationId: string;
+        name: string;
+    }[];
+}
+export type PostFunctionDeploymentBundlePreview = ApiEndpoint<{
+    Audit: {
+        kind: 'no-audit';
+        reason: 'non-auditable';
+    };
+    Method: 'POST';
+    Path: '/functions/deployments/bundle/preview';
+    Body: FunctionDeploymentBundleBody;
+    Error: ApiError<'functions_deployment_error' | 'integration_not_found'>;
+    Success: FunctionDeploymentBundleSuccess;
+}>;
+export type PostFunctionDeploymentBundle = ApiEndpoint<{
+    Audit: AuditPolicy<'function', 'deployed', 'environment'>;
+    Method: 'POST';
+    Path: '/functions/deployments/bundle';
+    Body: FunctionDeploymentBundleBody;
+    Error: ApiError<'functions_deployment_error' | 'concurrent_deployment' | 'integration_not_found'>;
+    Success: FunctionDeploymentBundleSuccess;
+}>;
+export {};

package/dist/index.d.ts

@@ -11,6 +11,11 @@ export type * from './logs/api.js';
 export type * from './logs/messages.js';
 export type * from './keystore/index.js';
 export type * from './action/api.js';
+export type * from './agent/api.js';
+export type * from './agent/connections.js';
+export type * from './agent/mcp.api.js';
+export type * from './agent/session.js';
+export type * from './agent/toolset.js';
 export type * from './admin/http.api.js';
 export type * from './account/api.js';
 export type * from './account/context.js';
@@ -71,8 +76,8 @@ export type * from './proxy/http.api.js';
 export type * from './dbConfig/db.js';
 export type * from './nangoYaml/index.js';
 export type * from './environment/db.js';
-export { ALL_SCOPES, API_KEY_SCOPES } from './api-keys/scopes.js';
-export type { ApiKeyScope } from './api-keys/scopes.js';
+export type { ACCOUNT_API_KEY_SCOPES, AccountApiKeyScope, API_KEY_SCOPES, ApiKeyScope, ConcreteAccountApiKeyScope, ConcreteApiKeyScope, CustomerKeyScope, WildcardsFor } from './api-keys/scopes.js';
+export type * from './api-keys/auth.js';
 export type * from './environment/api/index.js';
 export type * from './environment/api/webhook.js';
 export type * from './environment/api/otlp.js';
@@ -94,11 +99,12 @@ export type * from './checkpoint/types.js';
 export type * from './checkpoint/db.js';
 export type * from './mcp/api.js';
 export type * from './mfa/api.js';
+export type * from './mfa/credential.js';
 export type * from './mfa/db.js';
+export type * from './function/config.js';
 export type * from './function/db.js';
+export type * from './function/trigger.js';
 export type * from './functions/api.js';
-export type * from './functions/capabilities.js';
-export type * from './functions/config.js';
 export type * from './functions/domain.js';
 export type * from './lambda/index.js';
 export type * from './authz/types.js';

package/dist/integration/api.d.ts

@@ -58,6 +58,7 @@ export type PostPublicIntegration = ApiEndpoint<{
         credentials?: ApiPublicIntegrationCredentials | undefined;
         forward_webhooks?: boolean | undefined;
         integration_config?: Record<string, string> | undefined;
+        custom?: Record<string, string> | undefined;
     };
     Success: {
         data: ApiPublicIntegration;