@utilix-tech/sdk 0.1.0

package/dist/api-8aZtWhSj.d.ts

@@ -0,0 +1,308 @@
+/**
+ * @module api
+ * Tools covered:
+ *  - curl-builder    : buildCurl, buildCurlMultiline, parseCurl
+ *  - curl-to-code    : parseCurlCommand, convertToCode
+ *  - jwt-decoder     : decodeJwt, formatJwtJson
+ *  - jwt-signer      : base64urlEncode, base64urlDecode, signJwt
+ *  - cors-builder    : validateCorsConfig, generateCors
+ *  - csp-builder     : generateCspHeader, generateFullHeader, parseCspHeader, validateCspConfig
+ *  - api-response    : detectFormat, formatResponse, getStats, extractJsonPaths
+ *  - url-parser      : parseUrl, buildUrl, addParam, removeParam, getParam,
+ *                      encodeUrlComponent, decodeUrlComponent, isValidUrl, normalizeUrl
+ *  - og-meta         : parseMetaTags, validateOgTags, generateMetaHtml
+ *
+ * Node 18+ only. All crypto uses node:crypto; no browser-only APIs.
+ */
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+interface Header {
+    key: string;
+    value: string;
+}
+interface CurlConfig {
+    method: HttpMethod;
+    url: string;
+    headers: Header[];
+    body?: string;
+    followRedirects?: boolean;
+    verbose?: boolean;
+    silent?: boolean;
+    timeout?: number;
+}
+declare function buildCurl(config: CurlConfig): string;
+declare function buildCurlMultiline(config: CurlConfig): string;
+declare function parseCurl(command: string): CurlConfig | {
+    error: string;
+};
+declare const HTTP_METHODS: HttpMethod[];
+declare const COMMON_HEADERS: Array<{
+    label: string;
+    key: string;
+    value: string;
+}>;
+type TargetLanguage = 'fetch' | 'axios' | 'python-requests' | 'go-http' | 'php-curl' | 'ruby-net-http';
+interface CurlCommand {
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    body?: string;
+    followRedirects?: boolean;
+}
+declare const SUPPORTED_LANGUAGES: Array<{
+    value: TargetLanguage;
+    label: string;
+}>;
+declare function parseCurlCommand(curl: string): CurlCommand | {
+    error: string;
+};
+declare function convertToCode(cmd: CurlCommand, target: TargetLanguage): string;
+type JwtExpiry = 'valid' | 'expired' | 'no-exp';
+interface JwtPart {
+    raw: string;
+    decoded: Record<string, unknown>;
+}
+interface JwtDecodeResult {
+    ok: true;
+    header: JwtPart;
+    payload: JwtPart;
+    signature: string;
+    algorithm: string;
+    expiry: JwtExpiry;
+    expiresAt: Date | null;
+    issuedAt: Date | null;
+}
+interface JwtDecodeError {
+    ok: false;
+    error: string;
+}
+type JwtResult = JwtDecodeResult | JwtDecodeError;
+declare function decodeJwt(token: string): JwtResult;
+declare function formatJwtJson(obj: Record<string, unknown>): string;
+type JwtAlgorithm = 'HS256' | 'HS384' | 'HS512';
+interface JwtSignOptions {
+    algorithm?: JwtAlgorithm;
+    secret: string;
+    payload: Record<string, unknown>;
+    expiresInSeconds?: number;
+}
+/**
+ * Encodes a UTF-8 string to base64url format.
+ * Node version: uses Buffer instead of btoa/TextEncoder.
+ */
+declare function base64urlEncode(str: string): string;
+/**
+ * Decodes a base64url string back to a UTF-8 string.
+ * Node version: uses Buffer instead of atob/TextDecoder.
+ */
+declare function base64urlDecode(str: string): string;
+/**
+ * Signs a JWT using HMAC-SHA (HS256/HS384/HS512) via node:crypto.
+ * Sync implementation — no SubtleCrypto needed.
+ *
+ * For `iat`: if not provided in payload, defaults to 0 for determinism.
+ */
+declare function signJwt(options: JwtSignOptions): Promise<string>;
+interface CorsConfig {
+    allowedOrigins: string[];
+    allowedMethods: HttpMethod[];
+    allowedHeaders: string[];
+    exposedHeaders: string[];
+    allowCredentials: boolean;
+    maxAge: number;
+}
+interface CorsOutput {
+    headers: Record<string, string>;
+    nginxConfig: string;
+    expressCode: string;
+    apacheConfig: string;
+}
+declare const CORS_COMMON_HEADERS: string[];
+declare const DEFAULT_CORS_CONFIG: CorsConfig;
+declare function validateCorsConfig(config: CorsConfig): {
+    valid: boolean;
+    warnings: string[];
+};
+declare function generateCors(config: CorsConfig): CorsOutput;
+type CspDirective = 'default-src' | 'script-src' | 'style-src' | 'img-src' | 'font-src' | 'connect-src' | 'media-src' | 'object-src' | 'frame-src' | 'worker-src' | 'manifest-src' | 'prefetch-src' | 'form-action' | 'frame-ancestors' | 'base-uri' | 'upgrade-insecure-requests' | 'block-all-mixed-content' | 'report-uri' | 'report-to';
+type CspSource = "'none'" | "'self'" | "'unsafe-inline'" | "'unsafe-eval'" | "'strict-dynamic'" | "'unsafe-hashes'" | 'https:' | 'data:' | 'blob:';
+interface DirectiveConfig {
+    directive: CspDirective;
+    sources: string[];
+}
+interface CspConfig {
+    directives: DirectiveConfig[];
+    reportUri?: string;
+    reportOnly?: boolean;
+}
+declare function generateCspHeader(config: CspConfig): string;
+declare function generateFullHeader(config: CspConfig): {
+    name: string;
+    value: string;
+};
+declare function parseCspHeader(headerValue: string): CspConfig | {
+    error: string;
+};
+declare function validateCspConfig(config: CspConfig): {
+    warnings: string[];
+};
+declare const DIRECTIVE_DESCRIPTIONS: Record<CspDirective, string>;
+declare const COMMON_PRESETS: Array<{
+    name: string;
+    config: CspConfig;
+    description: string;
+}>;
+type ResponseFormat = 'json' | 'xml' | 'html' | 'csv' | 'text' | 'unknown';
+interface FormatResult {
+    format: ResponseFormat;
+    formatted: string;
+    minified?: string;
+    size: number;
+    lines: number;
+    valid: boolean;
+    error?: string;
+}
+declare function detectFormat(content: string): ResponseFormat;
+declare function formatResponse(content: string, hint?: ResponseFormat): FormatResult;
+declare function getStats(content: string): {
+    size: number;
+    lines: number;
+    format: ResponseFormat;
+    jsonKeys?: number;
+    xmlElements?: number;
+};
+declare function extractJsonPaths(content: string): string[];
+interface ParsedUrl {
+    protocol: string;
+    username?: string;
+    password?: string;
+    hostname: string;
+    port?: string;
+    pathname: string;
+    search: string;
+    hash: string;
+    params: Array<{
+        key: string;
+        value: string;
+    }>;
+    isValid: boolean;
+    isAbsolute: boolean;
+}
+declare function parseUrl(url: string): ParsedUrl;
+declare function buildUrl(parsed: Partial<ParsedUrl> & {
+    hostname: string;
+}): string;
+declare function addParam(url: string, key: string, value: string): string;
+declare function removeParam(url: string, key: string): string;
+declare function getParam(url: string, key: string): string | null;
+declare function encodeUrlComponent(value: string): string;
+declare function decodeUrlComponent(value: string): string;
+declare function isValidUrl(url: string): boolean;
+declare function normalizeUrl(url: string): string;
+interface OgTags {
+    title?: string;
+    description?: string;
+    image?: string;
+    imageAlt?: string;
+    imageWidth?: string;
+    imageHeight?: string;
+    url?: string;
+    type?: string;
+    siteName?: string;
+    locale?: string;
+}
+interface TwitterTags {
+    card?: string;
+    site?: string;
+    creator?: string;
+    title?: string;
+    description?: string;
+    image?: string;
+}
+interface MetaTags {
+    og: OgTags;
+    twitter: TwitterTags;
+    standard: {
+        title?: string;
+        description?: string;
+        keywords?: string;
+        canonical?: string;
+        robots?: string;
+        viewport?: string;
+        charset?: string;
+    };
+}
+declare function parseMetaTags(html: string): MetaTags;
+declare function validateOgTags(tags: OgTags): {
+    warnings: string[];
+    missing: string[];
+};
+declare function generateMetaHtml(tags: Partial<OgTags & TwitterTags>): string;
+
+declare const api_COMMON_HEADERS: typeof COMMON_HEADERS;
+declare const api_COMMON_PRESETS: typeof COMMON_PRESETS;
+declare const api_CORS_COMMON_HEADERS: typeof CORS_COMMON_HEADERS;
+type api_CorsConfig = CorsConfig;
+type api_CorsOutput = CorsOutput;
+type api_CspConfig = CspConfig;
+type api_CspDirective = CspDirective;
+type api_CspSource = CspSource;
+type api_CurlCommand = CurlCommand;
+type api_CurlConfig = CurlConfig;
+declare const api_DEFAULT_CORS_CONFIG: typeof DEFAULT_CORS_CONFIG;
+declare const api_DIRECTIVE_DESCRIPTIONS: typeof DIRECTIVE_DESCRIPTIONS;
+type api_DirectiveConfig = DirectiveConfig;
+type api_FormatResult = FormatResult;
+declare const api_HTTP_METHODS: typeof HTTP_METHODS;
+type api_Header = Header;
+type api_HttpMethod = HttpMethod;
+type api_JwtAlgorithm = JwtAlgorithm;
+type api_JwtDecodeError = JwtDecodeError;
+type api_JwtDecodeResult = JwtDecodeResult;
+type api_JwtExpiry = JwtExpiry;
+type api_JwtPart = JwtPart;
+type api_JwtResult = JwtResult;
+type api_JwtSignOptions = JwtSignOptions;
+type api_MetaTags = MetaTags;
+type api_OgTags = OgTags;
+type api_ParsedUrl = ParsedUrl;
+type api_ResponseFormat = ResponseFormat;
+declare const api_SUPPORTED_LANGUAGES: typeof SUPPORTED_LANGUAGES;
+type api_TargetLanguage = TargetLanguage;
+type api_TwitterTags = TwitterTags;
+declare const api_addParam: typeof addParam;
+declare const api_base64urlDecode: typeof base64urlDecode;
+declare const api_base64urlEncode: typeof base64urlEncode;
+declare const api_buildCurl: typeof buildCurl;
+declare const api_buildCurlMultiline: typeof buildCurlMultiline;
+declare const api_buildUrl: typeof buildUrl;
+declare const api_convertToCode: typeof convertToCode;
+declare const api_decodeJwt: typeof decodeJwt;
+declare const api_decodeUrlComponent: typeof decodeUrlComponent;
+declare const api_detectFormat: typeof detectFormat;
+declare const api_encodeUrlComponent: typeof encodeUrlComponent;
+declare const api_extractJsonPaths: typeof extractJsonPaths;
+declare const api_formatJwtJson: typeof formatJwtJson;
+declare const api_formatResponse: typeof formatResponse;
+declare const api_generateCors: typeof generateCors;
+declare const api_generateCspHeader: typeof generateCspHeader;
+declare const api_generateFullHeader: typeof generateFullHeader;
+declare const api_generateMetaHtml: typeof generateMetaHtml;
+declare const api_getParam: typeof getParam;
+declare const api_getStats: typeof getStats;
+declare const api_isValidUrl: typeof isValidUrl;
+declare const api_normalizeUrl: typeof normalizeUrl;
+declare const api_parseCspHeader: typeof parseCspHeader;
+declare const api_parseCurl: typeof parseCurl;
+declare const api_parseCurlCommand: typeof parseCurlCommand;
+declare const api_parseMetaTags: typeof parseMetaTags;
+declare const api_parseUrl: typeof parseUrl;
+declare const api_removeParam: typeof removeParam;
+declare const api_signJwt: typeof signJwt;
+declare const api_validateCorsConfig: typeof validateCorsConfig;
+declare const api_validateCspConfig: typeof validateCspConfig;
+declare const api_validateOgTags: typeof validateOgTags;
+declare namespace api {
+  export { api_COMMON_HEADERS as COMMON_HEADERS, api_COMMON_PRESETS as COMMON_PRESETS, api_CORS_COMMON_HEADERS as CORS_COMMON_HEADERS, type api_CorsConfig as CorsConfig, type api_CorsOutput as CorsOutput, type api_CspConfig as CspConfig, type api_CspDirective as CspDirective, type api_CspSource as CspSource, type api_CurlCommand as CurlCommand, type api_CurlConfig as CurlConfig, api_DEFAULT_CORS_CONFIG as DEFAULT_CORS_CONFIG, api_DIRECTIVE_DESCRIPTIONS as DIRECTIVE_DESCRIPTIONS, type api_DirectiveConfig as DirectiveConfig, type api_FormatResult as FormatResult, api_HTTP_METHODS as HTTP_METHODS, type api_Header as Header, type api_HttpMethod as HttpMethod, type api_JwtAlgorithm as JwtAlgorithm, type api_JwtDecodeError as JwtDecodeError, type api_JwtDecodeResult as JwtDecodeResult, type api_JwtExpiry as JwtExpiry, type api_JwtPart as JwtPart, type api_JwtResult as JwtResult, type api_JwtSignOptions as JwtSignOptions, type api_MetaTags as MetaTags, type api_OgTags as OgTags, type api_ParsedUrl as ParsedUrl, type api_ResponseFormat as ResponseFormat, api_SUPPORTED_LANGUAGES as SUPPORTED_LANGUAGES, type api_TargetLanguage as TargetLanguage, type api_TwitterTags as TwitterTags, api_addParam as addParam, api_base64urlDecode as base64urlDecode, api_base64urlEncode as base64urlEncode, api_buildCurl as buildCurl, api_buildCurlMultiline as buildCurlMultiline, api_buildUrl as buildUrl, api_convertToCode as convertToCode, api_decodeJwt as decodeJwt, api_decodeUrlComponent as decodeUrlComponent, api_detectFormat as detectFormat, api_encodeUrlComponent as encodeUrlComponent, api_extractJsonPaths as extractJsonPaths, api_formatJwtJson as formatJwtJson, api_formatResponse as formatResponse, api_generateCors as generateCors, api_generateCspHeader as generateCspHeader, api_generateFullHeader as generateFullHeader, api_generateMetaHtml as generateMetaHtml, api_getParam as getParam, api_getStats as getStats, api_isValidUrl as isValidUrl, api_normalizeUrl as normalizeUrl, api_parseCspHeader as parseCspHeader, api_parseCurl as parseCurl, api_parseCurlCommand as parseCurlCommand, api_parseMetaTags as parseMetaTags, api_parseUrl as parseUrl, api_removeParam as removeParam, api_signJwt as signJwt, api_validateCorsConfig as validateCorsConfig, api_validateCspConfig as validateCspConfig, api_validateOgTags as validateOgTags };
+}
+
+export { normalizeUrl as $, buildUrl as A, convertToCode as B, COMMON_HEADERS as C, DEFAULT_CORS_CONFIG as D, decodeJwt as E, type FormatResult as F, decodeUrlComponent as G, HTTP_METHODS as H, detectFormat as I, type JwtAlgorithm as J, encodeUrlComponent as K, extractJsonPaths as L, type MetaTags as M, formatJwtJson as N, type OgTags as O, type ParsedUrl as P, formatResponse as Q, type ResponseFormat as R, SUPPORTED_LANGUAGES as S, type TargetLanguage as T, generateCors as U, generateCspHeader as V, generateFullHeader as W, generateMetaHtml as X, getParam as Y, getStats as Z, isValidUrl as _, api as a, parseCspHeader as a0, parseCurl as a1, parseCurlCommand as a2, parseMetaTags as a3, parseUrl as a4, removeParam as a5, signJwt as a6, validateCorsConfig as a7, validateCspConfig as a8, validateOgTags as a9, COMMON_PRESETS as b, CORS_COMMON_HEADERS as c, type CorsConfig as d, type CorsOutput as e, type CspConfig as f, type CspDirective as g, type CspSource as h, type CurlCommand as i, type CurlConfig as j, DIRECTIVE_DESCRIPTIONS as k, type DirectiveConfig as l, type Header as m, type HttpMethod as n, type JwtDecodeError as o, type JwtDecodeResult as p, type JwtExpiry as q, type JwtPart as r, type JwtResult as s, type JwtSignOptions as t, type TwitterTags as u, addParam as v, base64urlDecode as w, base64urlEncode as x, buildCurl as y, buildCurlMultiline as z };