nodelistparser/dist/cjs/index.d.ts

Surge / Mihomo (Clash.Meta) nodelist / proxy provider parser and generator.

interface SharedConfigBase {
    raw?: string | undefined | null;
    name: string;
    server: string;
    port: number;
    /** tfo */
    tfo?: boolean;
    /** block-quic */
    blockQuic?: string;
    /** underlying-proxy */
    underlyingProxy?: string;
}
interface TlsSharedConfig {
    /** sni */
    sni: string | undefined;
    /** skip-cert-verify */
    skipCertVerify: boolean;
}
interface HttpProxyConfig extends SharedConfigBase {
    type: 'http';
    username: string;
    password: string;
}
interface ShadowSocksConfig extends SharedConfigBase {
    type: 'ss';
    /** encrypt-method */
    cipher: string;
    password: string;
    /** udp-relay */
    udp: boolean;
    obfs?: undefined | 'http' | 'tls';
    /** obfs-host */
    obfsHost?: string;
    /** obfs-uri */
    obfsUri?: string;
    /** udp-port */
    udpPort?: number;
    /** Shadow TLS Version */
    shadowTlsVersion?: 1 | 2 | 3;
    /** Shadow TLS Password */
    shadowTlsPassword?: string;
    /** Shadow TLS SNI */
    shadowTlsSni?: string | undefined;
}
interface TrojanConfig extends SharedConfigBase, TlsSharedConfig {
    type: 'trojan';
    password: string;
    /** udp-relay */
    udp: boolean;
}
interface SnellConfig extends SharedConfigBase {
    type: 'snell';
    psk: string;
    version: number;
    reuse: boolean;
}
interface TrojanBasicConfig extends SharedConfigBase, TlsSharedConfig {
    type: 'trojan';
    password: string;
    /** udp-relay */
    udp: boolean;
}
interface TuicConfig extends SharedConfigBase, TlsSharedConfig {
    type: 'tuic';
    uuid: string;
    alpn: string;
    token: string;
}
interface TuicV5Config extends SharedConfigBase, TlsSharedConfig {
    type: 'tuic-v5';
    uuid: string;
    alpn: string;
    password: string;
}
interface Socks5Config extends SharedConfigBase {
    type: 'socks5';
    udp: boolean;
    username: string;
    password: string;
}
interface VmessConfig extends SharedConfigBase, TlsSharedConfig {
    type: 'vmess';
    /** uuid */
    username: string;
    tls: boolean;
    vmessAead: boolean | undefined;
    ws: boolean | undefined;
    wsPath: string | undefined;
    wsHeaders: string | undefined;
    udp: boolean;
}
interface Hysteria2Config extends SharedConfigBase, Omit<TlsSharedConfig, 'sni'> {
    type: 'hysteria2';
    password: string;
    /** download-bandwidth in mbps */
    downloadBandwidth: number;
    /** port hopping */
    portHopping?: string;
    /** port hopping interval */
    portHoppingInterval?: number;
}
type SupportedConfig = HttpProxyConfig | SnellConfig | TrojanConfig | ShadowSocksConfig | TuicConfig | TuicV5Config | Socks5Config | VmessConfig | Hysteria2Config;

declare function decode$1(raw: string): SupportedConfig;
declare function encode$1(config: SupportedConfig): string;

declare namespace index$4 {
  export {
    decode$1 as decode,
    encode$1 as encode,
  };
}

declare function decode(config: Record<string, any>): SupportedConfig;
declare function encode(config: SupportedConfig): {
    tfo: boolean | undefined;
    'dialer-proxy': string | undefined;
    plugin?: string | undefined;
    'plugin-opts'?: {
        mode: "http" | "tls";
        host: string | undefined;
        uri: string | undefined;
        password?: undefined;
        version?: undefined;
    } | {
        host: string | undefined;
        password: string;
        version: 1 | 2 | 3 | undefined;
        mode?: undefined;
        uri?: undefined;
    } | undefined;
    name: string;
    type: string;
    server: string;
    port: number;
    cipher: string;
    password: string;
    udp: boolean;
    alterId?: undefined;
    tls?: undefined;
    uuid?: undefined;
    servername?: undefined;
    'ws-path'?: undefined;
    'ws-headers'?: undefined;
    'ws-opts'?: undefined;
    network?: undefined;
    ports?: undefined;
    down?: undefined;
    'skip-cert-verify'?: undefined;
} | {
    tfo: boolean | undefined;
    'dialer-proxy': string | undefined;
    name: string;
    type: string;
    server: string;
    port: number;
    password: string;
    sni: string | undefined;
    'skip-cert-verify': boolean;
    udp: boolean;
    alterId?: undefined;
    tls?: undefined;
    uuid?: undefined;
    servername?: undefined;
    'ws-path'?: undefined;
    'ws-headers'?: undefined;
    cipher?: undefined;
    'ws-opts'?: undefined;
    network?: undefined;
    ports?: undefined;
    down?: undefined;
} | {
    tfo: boolean | undefined;
    'dialer-proxy': string | undefined;
    'skip-cert-verify': boolean;
    udp: boolean;
    version: number;
    token: string;
    name: string;
    type: string;
    server: string;
    port: number;
    sni: string | undefined;
    uuid: string;
    alpn: string[];
    alterId?: undefined;
    tls?: undefined;
    servername?: undefined;
    'ws-path'?: undefined;
    'ws-headers'?: undefined;
    cipher?: undefined;
    'ws-opts'?: undefined;
    network?: undefined;
    ports?: undefined;
    password?: undefined;
    down?: undefined;
} | {
    tfo: boolean | undefined;
    'dialer-proxy': string | undefined;
    'skip-cert-verify': boolean;
    udp: boolean;
    version: number;
    password: string;
    name: string;
    type: string;
    server: string;
    port: number;
    sni: string | undefined;
    uuid: string;
    alpn: string[];
    alterId?: undefined;
    tls?: undefined;
    servername?: undefined;
    'ws-path'?: undefined;
    'ws-headers'?: undefined;
    cipher?: undefined;
    'ws-opts'?: undefined;
    network?: undefined;
    ports?: undefined;
    down?: undefined;
} | {
    tfo: boolean | undefined;
    'dialer-proxy': string | undefined;
    name: string;
    type: string;
    server: string;
    port: number;
    username: string;
    password: string;
    udp: boolean;
    alterId?: undefined;
    tls?: undefined;
    uuid?: undefined;
    servername?: undefined;
    'ws-path'?: undefined;
    'ws-headers'?: undefined;
    cipher?: undefined;
    'ws-opts'?: undefined;
    network?: undefined;
    ports?: undefined;
    down?: undefined;
    'skip-cert-verify'?: undefined;
} | {
    tfo: boolean | undefined;
    'dialer-proxy': string | undefined;
    name: string;
    type: string;
    server: string;
    port: number;
    username: string;
    password: string;
    alterId?: undefined;
    tls?: undefined;
    udp?: undefined;
    uuid?: undefined;
    servername?: undefined;
    'ws-path'?: undefined;
    'ws-headers'?: undefined;
    cipher?: undefined;
    'ws-opts'?: undefined;
    network?: undefined;
    ports?: undefined;
    down?: undefined;
    'skip-cert-verify'?: undefined;
} | {
    alterId: number | undefined;
    tls: boolean;
    udp: boolean;
    uuid: string;
    name: string;
    servername: string | undefined;
    'ws-path': string | undefined;
    server: string;
    'ws-headers': Record<string, string> | undefined;
    cipher: string;
    'ws-opts': {
        path: string | undefined;
        headers: Record<string, string> | undefined;
    };
    type: string;
    port: number;
    network: string;
    ports?: undefined;
    password?: undefined;
    down?: undefined;
    'skip-cert-verify'?: undefined;
} | {
    name: string;
    type: string;
    server: string;
    port: number;
    ports: string | undefined;
    password: string;
    down: string;
    'skip-cert-verify': boolean;
    alterId?: undefined;
    tls?: undefined;
    udp?: undefined;
    uuid?: undefined;
    servername?: undefined;
    'ws-path'?: undefined;
    'ws-headers'?: undefined;
    cipher?: undefined;
    'ws-opts'?: undefined;
    network?: undefined;
};

declare const index$3_decode: typeof decode;
declare const index$3_encode: typeof encode;
declare namespace index$3 {
  export {
    index$3_decode as decode,
    index$3_encode as encode,
  };
}

declare function decodeOne(sip002: string): ShadowSocksConfig;
declare function decodeBase64Multiline(text: string): string[];
declare function decodeMultiline(text: string): ShadowSocksConfig[];

declare const index$2_decodeBase64Multiline: typeof decodeBase64Multiline;
declare const index$2_decodeMultiline: typeof decodeMultiline;
declare const index$2_decodeOne: typeof decodeOne;
declare namespace index$2 {
  export {
    index$2_decodeBase64Multiline as decodeBase64Multiline,
    index$2_decodeMultiline as decodeMultiline,
    index$2_decodeOne as decodeOne,
  };
}

declare function parse$1(line: string): TrojanConfig;

declare namespace index$1 {
  export {
    parse$1 as parse,
  };
}

declare function parse(line: string): VmessConfig;

declare const index_parse: typeof parse;
declare namespace index {
  export {
    index_parse as parse,
  };
}

export { index$3 as clash, index$2 as ss, index$4 as surge, index$1 as trojan, index as vmess };
export type { HttpProxyConfig, Hysteria2Config, ShadowSocksConfig, SharedConfigBase, SnellConfig, Socks5Config, SupportedConfig, TlsSharedConfig, TrojanBasicConfig, TrojanConfig, TuicConfig, TuicV5Config, VmessConfig };