@decaf-ts/integrations 0.7.0 → 0.9.0

package/lib/types/secrets/model/index.d.mts

@@ -5,4 +5,5 @@
  */
 export * from "./Secret.d.mts";
 export * from "./ModelSecretServiceConfig.d.mts";
+export * from "./ModelSecretEnvironment.d.mts";
 export * from "./ModelSecretService.d.mts";

package/lib/types/secrets/onepassword/OnePasswordSecretEnvironment.d.cts

@@ -0,0 +1,17 @@
+export interface OnePasswordSecretEnvironmentConfig {
+    connectHost: string;
+    connectToken?: string;
+    vaultId?: string;
+    itemIdTemplate?: string;
+    keyId?: string;
+}
+export interface OnePasswordSecretEnvironmentShape {
+    secrets: {
+        onePassword: OnePasswordSecretEnvironmentConfig;
+    };
+}
+export declare const OnePasswordSecretEnvironment: import("@decaf-ts/logging").AccumulatedEnvironment<{
+    app: string | undefined;
+} & import("@decaf-ts/logging").LoggingConfig<object> & {
+    env: any;
+} & import("..").SecretCommonEnvironmentShape & OnePasswordSecretEnvironmentShape>;

package/lib/types/secrets/onepassword/OnePasswordSecretEnvironment.d.mts

@@ -0,0 +1,17 @@
+export interface OnePasswordSecretEnvironmentConfig {
+    connectHost: string;
+    connectToken?: string;
+    vaultId?: string;
+    itemIdTemplate?: string;
+    keyId?: string;
+}
+export interface OnePasswordSecretEnvironmentShape {
+    secrets: {
+        onePassword: OnePasswordSecretEnvironmentConfig;
+    };
+}
+export declare const OnePasswordSecretEnvironment: import("@decaf-ts/logging").AccumulatedEnvironment<{
+    app: string | undefined;
+} & import("@decaf-ts/logging").LoggingConfig<object> & {
+    env: any;
+} & import("..").SecretCommonEnvironmentShape & OnePasswordSecretEnvironmentShape>;

package/lib/types/secrets/onepassword/OnePasswordSecretService.d.cts

@@ -1,9 +1,10 @@
-import { SecretError, SecretProvider } from "../../secrets/core/index.d.cts";
+import { ClientBasedSecretService, SecretError, SecretProvider } from "../../secrets/core/index.d.cts";
 import { SecretName, SecretPayload, SecretReference, SecretMetadata } from "../../secrets/core/index.d.cts";
-import { ClientBasedService, type ContextualArgs, type MaybeContextualArg } from "@decaf-ts/core";
+import { type ContextualArgs, type MaybeContextualArg } from "@decaf-ts/core";
 import { OnePasswordSecretServiceConfig } from "./OnePasswordSecretServiceConfig.d.cts";
-export declare class OnePasswordSecretService extends ClientBasedService<unknown, OnePasswordSecretServiceConfig> {
+export declare class OnePasswordSecretService extends ClientBasedSecretService<unknown, OnePasswordSecretServiceConfig> {
     readonly provider: SecretProvider;
+    protected configFromEnvironment(): OnePasswordSecretServiceConfig | undefined;
     initialize(...args: ContextualArgs<any>): Promise<{
         config: OnePasswordSecretServiceConfig;
         client: unknown;

package/lib/types/secrets/onepassword/OnePasswordSecretService.d.mts

@@ -1,9 +1,10 @@
-import { SecretError, SecretProvider } from "../../secrets/core/index.d.mts";
+import { ClientBasedSecretService, SecretError, SecretProvider } from "../../secrets/core/index.d.mts";
 import { SecretName, SecretPayload, SecretReference, SecretMetadata } from "../../secrets/core/index.d.mts";
-import { ClientBasedService, type ContextualArgs, type MaybeContextualArg } from "@decaf-ts/core";
+import { type ContextualArgs, type MaybeContextualArg } from "@decaf-ts/core";
 import { OnePasswordSecretServiceConfig } from "./OnePasswordSecretServiceConfig.d.mts";
-export declare class OnePasswordSecretService extends ClientBasedService<unknown, OnePasswordSecretServiceConfig> {
+export declare class OnePasswordSecretService extends ClientBasedSecretService<unknown, OnePasswordSecretServiceConfig> {
     readonly provider: SecretProvider;
+    protected configFromEnvironment(): OnePasswordSecretServiceConfig | undefined;
     initialize(...args: ContextualArgs<any>): Promise<{
         config: OnePasswordSecretServiceConfig;
         client: unknown;

package/lib/types/secrets/onepassword/index.d.cts

@@ -5,3 +5,4 @@
  */
 export * from "./OnePasswordSecretService.d.cts";
 export * from "./OnePasswordSecretServiceConfig.d.cts";
+export * from "./OnePasswordSecretEnvironment.d.cts";

package/lib/types/secrets/onepassword/index.d.mts

@@ -5,3 +5,4 @@
  */
 export * from "./OnePasswordSecretService.d.mts";
 export * from "./OnePasswordSecretServiceConfig.d.mts";
+export * from "./OnePasswordSecretEnvironment.d.mts";

package/lib/types/secrets/vault/VaultSecretEnvironment.d.cts

@@ -0,0 +1,17 @@
+export interface VaultSecretEnvironmentConfig {
+    address: string;
+    token: string;
+    path: string;
+    namespace?: string;
+    keyId?: string;
+}
+export interface VaultSecretEnvironmentShape {
+    secrets: {
+        vault: VaultSecretEnvironmentConfig;
+    };
+}
+export declare const VaultSecretEnvironment: import("@decaf-ts/logging").AccumulatedEnvironment<{
+    app: string | undefined;
+} & import("@decaf-ts/logging").LoggingConfig<object> & {
+    env: any;
+} & import("..").SecretCommonEnvironmentShape & VaultSecretEnvironmentShape>;

package/lib/types/secrets/vault/VaultSecretEnvironment.d.mts

@@ -0,0 +1,17 @@
+export interface VaultSecretEnvironmentConfig {
+    address: string;
+    token: string;
+    path: string;
+    namespace?: string;
+    keyId?: string;
+}
+export interface VaultSecretEnvironmentShape {
+    secrets: {
+        vault: VaultSecretEnvironmentConfig;
+    };
+}
+export declare const VaultSecretEnvironment: import("@decaf-ts/logging").AccumulatedEnvironment<{
+    app: string | undefined;
+} & import("@decaf-ts/logging").LoggingConfig<object> & {
+    env: any;
+} & import("..").SecretCommonEnvironmentShape & VaultSecretEnvironmentShape>;

package/lib/types/secrets/vault/VaultSecretService.d.cts

@@ -1,7 +1,7 @@
-import { SecretProvider } from "../../secrets/core/index.d.cts";
+import { ClientBasedSecretService, SecretProvider } from "../../secrets/core/index.d.cts";
 import { SecretName, SecretPayload, SecretReference, SecretMetadata } from "../../secrets/core/index.d.cts";
 import { StoreSecretOptions, ListSecretsOptions } from "../../secrets/core/index.d.cts";
-import { ClientBasedService, type MaybeContextualArg } from "@decaf-ts/core";
+import { type MaybeContextualArg } from "@decaf-ts/core";
 import { VaultSecretServiceConfig } from "./VaultSecretServiceConfig.d.cts";
 export declare class VaultKvV2Client {
     private baseUrl;
@@ -21,8 +21,9 @@ export declare class VaultKvV2Client {
     list(path: string): Promise<string[]>;
     metadata(path: string): Promise<any>;
 }
-export declare class VaultSecretService extends ClientBasedService<VaultKvV2Client, VaultSecretServiceConfig> {
+export declare class VaultSecretService extends ClientBasedSecretService<VaultKvV2Client, VaultSecretServiceConfig> {
     readonly provider: SecretProvider;
+    protected configFromEnvironment(): VaultSecretServiceConfig | undefined;
     initialize(...args: MaybeContextualArg<any>): Promise<{
         config: VaultSecretServiceConfig;
         client: VaultKvV2Client;

package/lib/types/secrets/vault/VaultSecretService.d.mts

@@ -1,7 +1,7 @@
-import { SecretProvider } from "../../secrets/core/index.d.mts";
+import { ClientBasedSecretService, SecretProvider } from "../../secrets/core/index.d.mts";
 import { SecretName, SecretPayload, SecretReference, SecretMetadata } from "../../secrets/core/index.d.mts";
 import { StoreSecretOptions, ListSecretsOptions } from "../../secrets/core/index.d.mts";
-import { ClientBasedService, type MaybeContextualArg } from "@decaf-ts/core";
+import { type MaybeContextualArg } from "@decaf-ts/core";
 import { VaultSecretServiceConfig } from "./VaultSecretServiceConfig.d.mts";
 export declare class VaultKvV2Client {
     private baseUrl;
@@ -21,8 +21,9 @@ export declare class VaultKvV2Client {
     list(path: string): Promise<string[]>;
     metadata(path: string): Promise<any>;
 }
-export declare class VaultSecretService extends ClientBasedService<VaultKvV2Client, VaultSecretServiceConfig> {
+export declare class VaultSecretService extends ClientBasedSecretService<VaultKvV2Client, VaultSecretServiceConfig> {
     readonly provider: SecretProvider;
+    protected configFromEnvironment(): VaultSecretServiceConfig | undefined;
     initialize(...args: MaybeContextualArg<any>): Promise<{
         config: VaultSecretServiceConfig;
         client: VaultKvV2Client;

package/lib/types/secrets/vault/index.d.cts

@@ -5,3 +5,4 @@
  */
 export * from "./VaultSecretService.d.cts";
 export * from "./VaultSecretServiceConfig.d.cts";
+export * from "./VaultSecretEnvironment.d.cts";

package/lib/types/secrets/vault/index.d.mts

@@ -5,3 +5,4 @@
  */
 export * from "./VaultSecretService.d.mts";
 export * from "./VaultSecretServiceConfig.d.mts";
+export * from "./VaultSecretEnvironment.d.mts";

package/lib/types/sftp/aws/AwsSftpEnvironment.d.cts

@@ -0,0 +1,24 @@
+export interface AwsSftpEnvironmentConfig {
+    sourceId: string;
+    host: string;
+    port?: number;
+    username: string;
+    password?: string;
+    privateKey?: string;
+    passphrase?: string;
+    remotePath?: string;
+    region: string;
+    bucket: string;
+    s3Prefix?: string;
+    serverId?: string;
+}
+export interface AwsSftpEnvironmentShape {
+    sftp: {
+        aws: AwsSftpEnvironmentConfig;
+    };
+}
+export declare const AwsSftpEnvironment: import("@decaf-ts/logging").AccumulatedEnvironment<{
+    app: string | undefined;
+} & import("@decaf-ts/logging").LoggingConfig<object> & {
+    env: any;
+} & import("..").SftpCommonEnvironmentShape & AwsSftpEnvironmentShape>;

package/lib/types/sftp/aws/AwsSftpEnvironment.d.mts

@@ -0,0 +1,24 @@
+export interface AwsSftpEnvironmentConfig {
+    sourceId: string;
+    host: string;
+    port?: number;
+    username: string;
+    password?: string;
+    privateKey?: string;
+    passphrase?: string;
+    remotePath?: string;
+    region: string;
+    bucket: string;
+    s3Prefix?: string;
+    serverId?: string;
+}
+export interface AwsSftpEnvironmentShape {
+    sftp: {
+        aws: AwsSftpEnvironmentConfig;
+    };
+}
+export declare const AwsSftpEnvironment: import("@decaf-ts/logging").AccumulatedEnvironment<{
+    app: string | undefined;
+} & import("@decaf-ts/logging").LoggingConfig<object> & {
+    env: any;
+} & import("..").SftpCommonEnvironmentShape & AwsSftpEnvironmentShape>;

package/lib/types/sftp/aws/AwsSftpService.d.cts

@@ -0,0 +1,38 @@
+import { type ContextualArgs, type MaybeContextualArg } from "@decaf-ts/core";
+import { SftpSource, type SftpFileEntry, type SftpFileResult, type SftpSourceConfig } from "../core/SftpSource.d.cts";
+export interface AwsTransferSftpConfig extends SftpSourceConfig {
+    provider: "aws-transfer";
+    region: string;
+    bucket: string;
+    s3Prefix?: string;
+    serverId?: string;
+}
+interface S3ListObjectsV2Output {
+    Contents?: Array<{
+        Key?: string;
+        Size?: number;
+        LastModified?: Date;
+    }>;
+    NextContinuationToken?: string;
+}
+interface S3LikeClient {
+    listObjectsV2(params: unknown): Promise<S3ListObjectsV2Output>;
+    getObject(params: unknown): Promise<{
+        body: AsyncIterable<Uint8Array>;
+    }>;
+    deleteObject(params: unknown): Promise<unknown>;
+}
+export declare class AwsSftpService extends SftpSource<S3LikeClient, AwsTransferSftpConfig> {
+    constructor();
+    protected configFromEnvironment(): AwsTransferSftpConfig | undefined;
+    initialize(...args: ContextualArgs<any>): Promise<{
+        config: AwsTransferSftpConfig;
+        client: S3LikeClient;
+    }>;
+    private s3Prefix;
+    list(remoteDir?: string, ...args: MaybeContextualArg<any>): Promise<SftpFileEntry[]>;
+    fetch(remotePath: string, ...args: MaybeContextualArg<any>): Promise<SftpFileResult>;
+    delete(remotePath: string, ...args: MaybeContextualArg<any>): Promise<void>;
+    close(...args: MaybeContextualArg<any>): Promise<void>;
+}
+export {};

package/lib/types/sftp/aws/AwsSftpService.d.mts

@@ -0,0 +1,38 @@
+import { type ContextualArgs, type MaybeContextualArg } from "@decaf-ts/core";
+import { SftpSource, type SftpFileEntry, type SftpFileResult, type SftpSourceConfig } from "../core/SftpSource.d.mts";
+export interface AwsTransferSftpConfig extends SftpSourceConfig {
+    provider: "aws-transfer";
+    region: string;
+    bucket: string;
+    s3Prefix?: string;
+    serverId?: string;
+}
+interface S3ListObjectsV2Output {
+    Contents?: Array<{
+        Key?: string;
+        Size?: number;
+        LastModified?: Date;
+    }>;
+    NextContinuationToken?: string;
+}
+interface S3LikeClient {
+    listObjectsV2(params: unknown): Promise<S3ListObjectsV2Output>;
+    getObject(params: unknown): Promise<{
+        body: AsyncIterable<Uint8Array>;
+    }>;
+    deleteObject(params: unknown): Promise<unknown>;
+}
+export declare class AwsSftpService extends SftpSource<S3LikeClient, AwsTransferSftpConfig> {
+    constructor();
+    protected configFromEnvironment(): AwsTransferSftpConfig | undefined;
+    initialize(...args: ContextualArgs<any>): Promise<{
+        config: AwsTransferSftpConfig;
+        client: S3LikeClient;
+    }>;
+    private s3Prefix;
+    list(remoteDir?: string, ...args: MaybeContextualArg<any>): Promise<SftpFileEntry[]>;
+    fetch(remotePath: string, ...args: MaybeContextualArg<any>): Promise<SftpFileResult>;
+    delete(remotePath: string, ...args: MaybeContextualArg<any>): Promise<void>;
+    close(...args: MaybeContextualArg<any>): Promise<void>;
+}
+export {};

package/lib/types/sftp/core/SftpEnvironment.d.cts

@@ -0,0 +1,11 @@
+import type { SftpProvider } from "./SftpSource.d.cts";
+export interface SftpCommonEnvironmentShape {
+    sftp: {
+        provider: SftpProvider;
+    };
+}
+export declare const SftpEnvironment: import("@decaf-ts/logging").AccumulatedEnvironment<{
+    app: string | undefined;
+} & import("@decaf-ts/logging").LoggingConfig<object> & {
+    env: any;
+} & SftpCommonEnvironmentShape>;

package/lib/types/sftp/core/SftpEnvironment.d.mts

@@ -0,0 +1,11 @@
+import type { SftpProvider } from "./SftpSource.d.mts";
+export interface SftpCommonEnvironmentShape {
+    sftp: {
+        provider: SftpProvider;
+    };
+}
+export declare const SftpEnvironment: import("@decaf-ts/logging").AccumulatedEnvironment<{
+    app: string | undefined;
+} & import("@decaf-ts/logging").LoggingConfig<object> & {
+    env: any;
+} & SftpCommonEnvironmentShape>;

package/lib/types/sftp/core/SftpSource.d.cts

@@ -0,0 +1,47 @@
+import { ClientBasedService, type ContextualArgs, type MaybeContextualArg } from "@decaf-ts/core";
+export type SftpProvider = "ssh2" | "aws-transfer";
+export interface SftpSourceConfig {
+    provider: SftpProvider;
+    sourceId: string;
+    host: string;
+    port?: number;
+    username: string;
+    password?: string;
+    privateKey?: string;
+    passphrase?: string;
+    remotePath?: string;
+}
+export interface SftpFileEntry {
+    path: string;
+    name: string;
+    size: number;
+    modifyTime: number;
+    isDirectory: boolean;
+}
+export interface SftpFileResult {
+    path: string;
+    name: string;
+    content: Buffer;
+    size: number;
+}
+export declare abstract class SftpSource<TClient = unknown, TConfig extends SftpSourceConfig = SftpSourceConfig> extends ClientBasedService<TClient, TConfig> {
+    constructor();
+    get provider(): SftpProvider;
+    get sourceId(): string;
+    abstract initialize(...args: ContextualArgs<any>): Promise<{
+        config: TConfig;
+        client: TClient;
+    }>;
+    abstract list(remoteDir?: string, ...args: MaybeContextualArg<any>): Promise<SftpFileEntry[]>;
+    abstract fetch(remotePath: string, ...args: MaybeContextualArg<any>): Promise<SftpFileResult>;
+    abstract delete(remotePath: string, ...args: MaybeContextualArg<any>): Promise<void>;
+    abstract close(...args: MaybeContextualArg<any>): Promise<void>;
+    protected getConfigFromArgs<TExpected extends TConfig>(...args: MaybeContextualArg<any>): TExpected;
+    /**
+     * @description Builds a config from the provider's environment as a fallback.
+     * @summary Providers must override this to read from their own `sftp.<provider>`
+     * environment slice.
+     */
+    protected abstract configFromEnvironment(): TConfig | undefined;
+}
+export declare function assertSftpConfig(config: SftpSourceConfig): void;

package/lib/types/sftp/core/SftpSource.d.mts

@@ -0,0 +1,47 @@
+import { ClientBasedService, type ContextualArgs, type MaybeContextualArg } from "@decaf-ts/core";
+export type SftpProvider = "ssh2" | "aws-transfer";
+export interface SftpSourceConfig {
+    provider: SftpProvider;
+    sourceId: string;
+    host: string;
+    port?: number;
+    username: string;
+    password?: string;
+    privateKey?: string;
+    passphrase?: string;
+    remotePath?: string;
+}
+export interface SftpFileEntry {
+    path: string;
+    name: string;
+    size: number;
+    modifyTime: number;
+    isDirectory: boolean;
+}
+export interface SftpFileResult {
+    path: string;
+    name: string;
+    content: Buffer;
+    size: number;
+}
+export declare abstract class SftpSource<TClient = unknown, TConfig extends SftpSourceConfig = SftpSourceConfig> extends ClientBasedService<TClient, TConfig> {
+    constructor();
+    get provider(): SftpProvider;
+    get sourceId(): string;
+    abstract initialize(...args: ContextualArgs<any>): Promise<{
+        config: TConfig;
+        client: TClient;
+    }>;
+    abstract list(remoteDir?: string, ...args: MaybeContextualArg<any>): Promise<SftpFileEntry[]>;
+    abstract fetch(remotePath: string, ...args: MaybeContextualArg<any>): Promise<SftpFileResult>;
+    abstract delete(remotePath: string, ...args: MaybeContextualArg<any>): Promise<void>;
+    abstract close(...args: MaybeContextualArg<any>): Promise<void>;
+    protected getConfigFromArgs<TExpected extends TConfig>(...args: MaybeContextualArg<any>): TExpected;
+    /**
+     * @description Builds a config from the provider's environment as a fallback.
+     * @summary Providers must override this to read from their own `sftp.<provider>`
+     * environment slice.
+     */
+    protected abstract configFromEnvironment(): TConfig | undefined;
+}
+export declare function assertSftpConfig(config: SftpSourceConfig): void;

package/lib/types/sftp/core/index.d.cts

@@ -0,0 +1,2 @@
+export * from "./SftpSource.d.cts";
+export * from "./SftpEnvironment.d.cts";

package/lib/types/sftp/core/index.d.mts

@@ -0,0 +1,2 @@
+export * from "./SftpSource.d.mts";
+export * from "./SftpEnvironment.d.mts";

package/lib/types/sftp/index.d.cts

@@ -0,0 +1,6 @@
+export * from "./ssh2/Ssh2SftpService.d.cts";
+export * from "./ssh2/Ssh2SftpEnvironment.d.cts";
+export * from "./aws/AwsSftpService.d.cts";
+export * from "./aws/AwsSftpEnvironment.d.cts";
+export * from "./core/SftpSource.d.cts";
+export * from "./core/SftpEnvironment.d.cts";

package/lib/types/sftp/index.d.mts

@@ -0,0 +1,6 @@
+export * from "./ssh2/Ssh2SftpService.d.mts";
+export * from "./ssh2/Ssh2SftpEnvironment.d.mts";
+export * from "./aws/AwsSftpService.d.mts";
+export * from "./aws/AwsSftpEnvironment.d.mts";
+export * from "./core/SftpSource.d.mts";
+export * from "./core/SftpEnvironment.d.mts";

package/lib/types/sftp/ssh2/Ssh2SftpEnvironment.d.cts

@@ -0,0 +1,21 @@
+export interface Ssh2SftpEnvironmentConfig {
+    sourceId: string;
+    host: string;
+    port?: number;
+    username: string;
+    password?: string;
+    privateKey?: string;
+    passphrase?: string;
+    remotePath?: string;
+    readyTimeout?: number;
+}
+export interface Ssh2SftpEnvironmentShape {
+    sftp: {
+        ssh2: Ssh2SftpEnvironmentConfig;
+    };
+}
+export declare const Ssh2SftpEnvironment: import("@decaf-ts/logging").AccumulatedEnvironment<{
+    app: string | undefined;
+} & import("@decaf-ts/logging").LoggingConfig<object> & {
+    env: any;
+} & import("..").SftpCommonEnvironmentShape & Ssh2SftpEnvironmentShape>;

package/lib/types/sftp/ssh2/Ssh2SftpEnvironment.d.mts

@@ -0,0 +1,21 @@
+export interface Ssh2SftpEnvironmentConfig {
+    sourceId: string;
+    host: string;
+    port?: number;
+    username: string;
+    password?: string;
+    privateKey?: string;
+    passphrase?: string;
+    remotePath?: string;
+    readyTimeout?: number;
+}
+export interface Ssh2SftpEnvironmentShape {
+    sftp: {
+        ssh2: Ssh2SftpEnvironmentConfig;
+    };
+}
+export declare const Ssh2SftpEnvironment: import("@decaf-ts/logging").AccumulatedEnvironment<{
+    app: string | undefined;
+} & import("@decaf-ts/logging").LoggingConfig<object> & {
+    env: any;
+} & import("..").SftpCommonEnvironmentShape & Ssh2SftpEnvironmentShape>;

package/lib/types/sftp/ssh2/Ssh2SftpService.d.cts

@@ -0,0 +1,48 @@
+import { type ContextualArgs, type MaybeContextualArg } from "@decaf-ts/core";
+import { SftpSource, type SftpFileEntry, type SftpFileResult, type SftpSourceConfig } from "../core/SftpSource.d.cts";
+export interface Ssh2SftpConfig extends SftpSourceConfig {
+    provider: "ssh2";
+    readyTimeout?: number;
+}
+interface Ssh2Client {
+    connect(config: unknown): void;
+    on(event: "ready", cb: () => void): void;
+    on(event: "error", cb: (err: Error) => void): void;
+    sftp(cb: (err: Error | null, sftp: Ssh2SftpHandle) => void): void;
+    end(): void;
+}
+interface Ssh2SftpHandle {
+    readdir(dir: string, cb: (err: Error | null, list: Array<{
+        filename: string;
+        attrs: {
+            size: number;
+            mtime: number;
+            mode: number;
+        };
+    }>) => void): void;
+    stat(path: string, cb: (err: Error | null, stat: {
+        size: number;
+        mtime: number;
+        mode: number;
+    }) => void): void;
+    open(path: string, flags: string, cb: (err: Error | null, handle: Buffer) => void): void;
+    read(handle: Buffer, buffer: Buffer, offset: number, length: number, position: number, cb: (err: Error | null, bytesRead: number, buffer: Buffer) => void): void;
+    close(handle: Buffer, cb: (err: Error | null) => void): void;
+    unlink(path: string, cb: (err: Error | null) => void): void;
+    end(cb?: () => void): void;
+}
+export declare class Ssh2SftpService extends SftpSource<Ssh2Client, Ssh2SftpConfig> {
+    private sftp?;
+    constructor();
+    protected configFromEnvironment(): Ssh2SftpConfig | undefined;
+    initialize(...args: ContextualArgs<any>): Promise<{
+        config: Ssh2SftpConfig;
+        client: Ssh2Client;
+    }>;
+    list(remoteDir?: string, ...args: MaybeContextualArg<any>): Promise<SftpFileEntry[]>;
+    fetch(remotePath: string, ...args: MaybeContextualArg<any>): Promise<SftpFileResult>;
+    delete(remotePath: string, ...args: MaybeContextualArg<any>): Promise<void>;
+    close(...args: MaybeContextualArg<any>): Promise<void>;
+    private requireSftp;
+}
+export {};

package/lib/types/sftp/ssh2/Ssh2SftpService.d.mts

@@ -0,0 +1,48 @@
+import { type ContextualArgs, type MaybeContextualArg } from "@decaf-ts/core";
+import { SftpSource, type SftpFileEntry, type SftpFileResult, type SftpSourceConfig } from "../core/SftpSource.d.mts";
+export interface Ssh2SftpConfig extends SftpSourceConfig {
+    provider: "ssh2";
+    readyTimeout?: number;
+}
+interface Ssh2Client {
+    connect(config: unknown): void;
+    on(event: "ready", cb: () => void): void;
+    on(event: "error", cb: (err: Error) => void): void;
+    sftp(cb: (err: Error | null, sftp: Ssh2SftpHandle) => void): void;
+    end(): void;
+}
+interface Ssh2SftpHandle {
+    readdir(dir: string, cb: (err: Error | null, list: Array<{
+        filename: string;
+        attrs: {
+            size: number;
+            mtime: number;
+            mode: number;
+        };
+    }>) => void): void;
+    stat(path: string, cb: (err: Error | null, stat: {
+        size: number;
+        mtime: number;
+        mode: number;
+    }) => void): void;
+    open(path: string, flags: string, cb: (err: Error | null, handle: Buffer) => void): void;
+    read(handle: Buffer, buffer: Buffer, offset: number, length: number, position: number, cb: (err: Error | null, bytesRead: number, buffer: Buffer) => void): void;
+    close(handle: Buffer, cb: (err: Error | null) => void): void;
+    unlink(path: string, cb: (err: Error | null) => void): void;
+    end(cb?: () => void): void;
+}
+export declare class Ssh2SftpService extends SftpSource<Ssh2Client, Ssh2SftpConfig> {
+    private sftp?;
+    constructor();
+    protected configFromEnvironment(): Ssh2SftpConfig | undefined;
+    initialize(...args: ContextualArgs<any>): Promise<{
+        config: Ssh2SftpConfig;
+        client: Ssh2Client;
+    }>;
+    list(remoteDir?: string, ...args: MaybeContextualArg<any>): Promise<SftpFileEntry[]>;
+    fetch(remotePath: string, ...args: MaybeContextualArg<any>): Promise<SftpFileResult>;
+    delete(remotePath: string, ...args: MaybeContextualArg<any>): Promise<void>;
+    close(...args: MaybeContextualArg<any>): Promise<void>;
+    private requireSftp;
+}
+export {};

package/lib/types/shared/environmentValue.d.cts

@@ -0,0 +1,16 @@
+/**
+ * @module integrations/shared/environment-value
+ * @summary Helpers for reading primitive values out of decaf-ts Environment instances.
+ * @description `@decaf-ts/logging`'s `Environment` resolves an unset leaf property to a
+ * Proxy object rather than `undefined` when it is reached through a path that was not
+ * part of the model captured by the last `.accumulate()` call for that root key (the
+ * proxy exists so callers can still compose the fully-qualified env-var key name via
+ * `String(...)`). Such proxies are objects, so they are truthy and pass straight through
+ * a bare `if (!value)` check, and they do not have the shape callers expect (e.g. no
+ * `.replace` on what looks like a string). Every `configFromEnvironment()` implementation
+ * must use these helpers instead of a raw truthiness check, both to decide whether a
+ * field was really configured and to build the config object it returns.
+ */
+export declare function envString(value: unknown): string | undefined;
+export declare function envNumber(value: unknown): number | undefined;
+export declare function envBoolean(value: unknown): boolean | undefined;

package/lib/types/shared/environmentValue.d.mts

@@ -0,0 +1,16 @@
+/**
+ * @module integrations/shared/environment-value
+ * @summary Helpers for reading primitive values out of decaf-ts Environment instances.
+ * @description `@decaf-ts/logging`'s `Environment` resolves an unset leaf property to a
+ * Proxy object rather than `undefined` when it is reached through a path that was not
+ * part of the model captured by the last `.accumulate()` call for that root key (the
+ * proxy exists so callers can still compose the fully-qualified env-var key name via
+ * `String(...)`). Such proxies are objects, so they are truthy and pass straight through
+ * a bare `if (!value)` check, and they do not have the shape callers expect (e.g. no
+ * `.replace` on what looks like a string). Every `configFromEnvironment()` implementation
+ * must use these helpers instead of a raw truthiness check, both to decide whether a
+ * field was really configured and to build the config object it returns.
+ */
+export declare function envString(value: unknown): string | undefined;
+export declare function envNumber(value: unknown): number | undefined;
+export declare function envBoolean(value: unknown): boolean | undefined;