oh-my-opencode 0.1.0

package/dist/tools/ast-grep/cli.d.ts

@@ -0,0 +1,11 @@
+import type { CliMatch, CliLanguage } from "./types";
+export interface RunOptions {
+    pattern: string;
+    lang: CliLanguage;
+    paths?: string[];
+    globs?: string[];
+    rewrite?: string;
+    context?: number;
+    updateAll?: boolean;
+}
+export declare function runSg(options: RunOptions): Promise<CliMatch[]>;

package/dist/tools/ast-grep/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const SG_CLI_PATH = "sg";
+export declare const CLI_LANGUAGES: readonly ["bash", "c", "cpp", "csharp", "css", "elixir", "go", "haskell", "html", "java", "javascript", "json", "kotlin", "lua", "nix", "php", "python", "ruby", "rust", "scala", "solidity", "swift", "typescript", "tsx", "yaml"];
+export declare const NAPI_LANGUAGES: readonly ["html", "javascript", "tsx", "css", "typescript"];
+export declare const LANG_EXTENSIONS: Record<string, string[]>;

package/dist/tools/ast-grep/index.d.ts

@@ -0,0 +1,92 @@
+import { ast_grep_search, ast_grep_replace } from "./tools";
+export declare const builtinTools: {
+    ast_grep_search: {
+        description: string;
+        args: {
+            pattern: import("zod").ZodString;
+            lang: import("zod").ZodEnum<{
+                typescript: "typescript";
+                csharp: "csharp";
+                rust: "rust";
+                php: "php";
+                python: "python";
+                javascript: "javascript";
+                go: "go";
+                c: "c";
+                cpp: "cpp";
+                java: "java";
+                ruby: "ruby";
+                lua: "lua";
+                swift: "swift";
+                elixir: "elixir";
+                yaml: "yaml";
+                bash: "bash";
+                css: "css";
+                haskell: "haskell";
+                html: "html";
+                json: "json";
+                kotlin: "kotlin";
+                nix: "nix";
+                scala: "scala";
+                solidity: "solidity";
+                tsx: "tsx";
+            }>;
+            paths: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            globs: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            context: import("zod").ZodOptional<import("zod").ZodNumber>;
+        };
+        execute(args: {
+            pattern: string;
+            lang: "typescript" | "csharp" | "rust" | "php" | "python" | "javascript" | "go" | "c" | "cpp" | "java" | "ruby" | "lua" | "swift" | "elixir" | "yaml" | "bash" | "css" | "haskell" | "html" | "json" | "kotlin" | "nix" | "scala" | "solidity" | "tsx";
+            paths?: string[] | undefined;
+            globs?: string[] | undefined;
+            context?: number | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    ast_grep_replace: {
+        description: string;
+        args: {
+            pattern: import("zod").ZodString;
+            rewrite: import("zod").ZodString;
+            lang: import("zod").ZodEnum<{
+                typescript: "typescript";
+                csharp: "csharp";
+                rust: "rust";
+                php: "php";
+                python: "python";
+                javascript: "javascript";
+                go: "go";
+                c: "c";
+                cpp: "cpp";
+                java: "java";
+                ruby: "ruby";
+                lua: "lua";
+                swift: "swift";
+                elixir: "elixir";
+                yaml: "yaml";
+                bash: "bash";
+                css: "css";
+                haskell: "haskell";
+                html: "html";
+                json: "json";
+                kotlin: "kotlin";
+                nix: "nix";
+                scala: "scala";
+                solidity: "solidity";
+                tsx: "tsx";
+            }>;
+            paths: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            globs: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            dryRun: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            pattern: string;
+            rewrite: string;
+            lang: "typescript" | "csharp" | "rust" | "php" | "python" | "javascript" | "go" | "c" | "cpp" | "java" | "ruby" | "lua" | "swift" | "elixir" | "yaml" | "bash" | "css" | "haskell" | "html" | "json" | "kotlin" | "nix" | "scala" | "solidity" | "tsx";
+            paths?: string[] | undefined;
+            globs?: string[] | undefined;
+            dryRun?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+};
+export { ast_grep_search, ast_grep_replace, };

package/dist/tools/ast-grep/napi.d.ts

@@ -0,0 +1,13 @@
+import type { NapiLanguage, AnalyzeResult, MetaVariable } from "./types";
+export declare function parseCode(code: string, lang: NapiLanguage): import("@ast-grep/napi").SgRoot<import("@ast-grep/napi/types/staticTypes").TypesMap>;
+export declare function findPattern(root: ReturnType<typeof parseCode>, pattern: string): import("@ast-grep/napi").SgNode<import("@ast-grep/napi/types/staticTypes").TypesMap, import("@ast-grep/napi/types/staticTypes").Kinds<import("@ast-grep/napi/types/staticTypes").TypesMap>>[];
+export declare function extractMetaVariables(node: ReturnType<ReturnType<typeof parseCode>["root"]>, pattern: string): MetaVariable[];
+export declare function analyzeCode(code: string, lang: NapiLanguage, pattern: string, shouldExtractMetaVars: boolean): AnalyzeResult[];
+export declare function transformCode(code: string, lang: NapiLanguage, pattern: string, rewrite: string): {
+    transformed: string;
+    editCount: number;
+};
+export declare function getRootInfo(code: string, lang: NapiLanguage): {
+    kind: string;
+    childCount: number;
+};

package/dist/tools/ast-grep/tools.d.ts

@@ -0,0 +1,135 @@
+export declare const ast_grep_search: {
+    description: string;
+    args: {
+        pattern: import("zod").ZodString;
+        lang: import("zod").ZodEnum<{
+            typescript: "typescript";
+            csharp: "csharp";
+            rust: "rust";
+            php: "php";
+            python: "python";
+            javascript: "javascript";
+            go: "go";
+            c: "c";
+            cpp: "cpp";
+            java: "java";
+            ruby: "ruby";
+            lua: "lua";
+            swift: "swift";
+            elixir: "elixir";
+            yaml: "yaml";
+            bash: "bash";
+            css: "css";
+            haskell: "haskell";
+            html: "html";
+            json: "json";
+            kotlin: "kotlin";
+            nix: "nix";
+            scala: "scala";
+            solidity: "solidity";
+            tsx: "tsx";
+        }>;
+        paths: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        globs: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        context: import("zod").ZodOptional<import("zod").ZodNumber>;
+    };
+    execute(args: {
+        pattern: string;
+        lang: "typescript" | "csharp" | "rust" | "php" | "python" | "javascript" | "go" | "c" | "cpp" | "java" | "ruby" | "lua" | "swift" | "elixir" | "yaml" | "bash" | "css" | "haskell" | "html" | "json" | "kotlin" | "nix" | "scala" | "solidity" | "tsx";
+        paths?: string[] | undefined;
+        globs?: string[] | undefined;
+        context?: number | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+export declare const ast_grep_replace: {
+    description: string;
+    args: {
+        pattern: import("zod").ZodString;
+        rewrite: import("zod").ZodString;
+        lang: import("zod").ZodEnum<{
+            typescript: "typescript";
+            csharp: "csharp";
+            rust: "rust";
+            php: "php";
+            python: "python";
+            javascript: "javascript";
+            go: "go";
+            c: "c";
+            cpp: "cpp";
+            java: "java";
+            ruby: "ruby";
+            lua: "lua";
+            swift: "swift";
+            elixir: "elixir";
+            yaml: "yaml";
+            bash: "bash";
+            css: "css";
+            haskell: "haskell";
+            html: "html";
+            json: "json";
+            kotlin: "kotlin";
+            nix: "nix";
+            scala: "scala";
+            solidity: "solidity";
+            tsx: "tsx";
+        }>;
+        paths: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        globs: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        dryRun: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    };
+    execute(args: {
+        pattern: string;
+        rewrite: string;
+        lang: "typescript" | "csharp" | "rust" | "php" | "python" | "javascript" | "go" | "c" | "cpp" | "java" | "ruby" | "lua" | "swift" | "elixir" | "yaml" | "bash" | "css" | "haskell" | "html" | "json" | "kotlin" | "nix" | "scala" | "solidity" | "tsx";
+        paths?: string[] | undefined;
+        globs?: string[] | undefined;
+        dryRun?: boolean | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+export declare const ast_grep_languages: {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+export declare const ast_grep_analyze: {
+    description: string;
+    args: {
+        code: import("zod").ZodString;
+        lang: import("zod").ZodEnum<{
+            typescript: "typescript";
+            javascript: "javascript";
+            css: "css";
+            html: "html";
+            tsx: "tsx";
+        }>;
+        pattern: import("zod").ZodOptional<import("zod").ZodString>;
+        extractMetaVars: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    };
+    execute(args: {
+        code: string;
+        lang: "typescript" | "javascript" | "css" | "html" | "tsx";
+        pattern?: string | undefined;
+        extractMetaVars?: boolean | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};
+export declare const ast_grep_transform: {
+    description: string;
+    args: {
+        code: import("zod").ZodString;
+        lang: import("zod").ZodEnum<{
+            typescript: "typescript";
+            javascript: "javascript";
+            css: "css";
+            html: "html";
+            tsx: "tsx";
+        }>;
+        pattern: import("zod").ZodString;
+        rewrite: import("zod").ZodString;
+    };
+    execute(args: {
+        code: string;
+        lang: "typescript" | "javascript" | "css" | "html" | "tsx";
+        pattern: string;
+        rewrite: string;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+};

package/dist/tools/ast-grep/types.d.ts

@@ -0,0 +1,51 @@
+import type { CLI_LANGUAGES, NAPI_LANGUAGES } from "./constants";
+export type CliLanguage = (typeof CLI_LANGUAGES)[number];
+export type NapiLanguage = (typeof NAPI_LANGUAGES)[number];
+export interface Position {
+    line: number;
+    column: number;
+}
+export interface Range {
+    start: Position;
+    end: Position;
+}
+export interface CliMatch {
+    text: string;
+    range: {
+        byteOffset: {
+            start: number;
+            end: number;
+        };
+        start: Position;
+        end: Position;
+    };
+    file: string;
+    lines: string;
+    charCount: {
+        leading: number;
+        trailing: number;
+    };
+    language: string;
+}
+export interface SearchMatch {
+    file: string;
+    text: string;
+    range: Range;
+    lines: string;
+}
+export interface MetaVariable {
+    name: string;
+    text: string;
+    kind: string;
+}
+export interface AnalyzeResult {
+    text: string;
+    range: Range;
+    kind: string;
+    metaVariables: MetaVariable[];
+}
+export interface TransformResult {
+    original: string;
+    transformed: string;
+    editCount: number;
+}

package/dist/tools/ast-grep/utils.d.ts

@@ -0,0 +1,5 @@
+import type { CliMatch, AnalyzeResult } from "./types";
+export declare function formatSearchResult(matches: CliMatch[]): string;
+export declare function formatReplaceResult(matches: CliMatch[], isDryRun: boolean): string;
+export declare function formatAnalyzeResult(results: AnalyzeResult[], extractedMetaVars: boolean): string;
+export declare function formatTransformResult(original: string, transformed: string, editCount: number): string;

package/dist/tools/index.d.ts

@@ -0,0 +1,255 @@
+export declare const builtinTools: {
+    lsp_hover: {
+        description: string;
+        args: {
+            filePath: import("zod").ZodString;
+            line: import("zod").ZodNumber;
+            character: import("zod").ZodNumber;
+        };
+        execute(args: {
+            filePath: string;
+            line: number;
+            character: number;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    lsp_goto_definition: {
+        description: string;
+        args: {
+            filePath: import("zod").ZodString;
+            line: import("zod").ZodNumber;
+            character: import("zod").ZodNumber;
+        };
+        execute(args: {
+            filePath: string;
+            line: number;
+            character: number;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    lsp_find_references: {
+        description: string;
+        args: {
+            filePath: import("zod").ZodString;
+            line: import("zod").ZodNumber;
+            character: import("zod").ZodNumber;
+            includeDeclaration: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            filePath: string;
+            line: number;
+            character: number;
+            includeDeclaration?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    lsp_document_symbols: {
+        description: string;
+        args: {
+            filePath: import("zod").ZodString;
+        };
+        execute(args: {
+            filePath: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    lsp_workspace_symbols: {
+        description: string;
+        args: {
+            filePath: import("zod").ZodString;
+            query: import("zod").ZodString;
+            limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+        };
+        execute(args: {
+            filePath: string;
+            query: string;
+            limit?: number | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    lsp_diagnostics: {
+        description: string;
+        args: {
+            filePath: import("zod").ZodString;
+            severity: import("zod").ZodOptional<import("zod").ZodEnum<{
+                all: "all";
+                error: "error";
+                warning: "warning";
+                information: "information";
+                hint: "hint";
+            }>>;
+        };
+        execute(args: {
+            filePath: string;
+            severity?: "all" | "error" | "warning" | "information" | "hint" | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    lsp_servers: {
+        description: string;
+        args: {};
+        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    lsp_prepare_rename: {
+        description: string;
+        args: {
+            filePath: import("zod").ZodString;
+            line: import("zod").ZodNumber;
+            character: import("zod").ZodNumber;
+        };
+        execute(args: {
+            filePath: string;
+            line: number;
+            character: number;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    lsp_rename: {
+        description: string;
+        args: {
+            filePath: import("zod").ZodString;
+            line: import("zod").ZodNumber;
+            character: import("zod").ZodNumber;
+            newName: import("zod").ZodString;
+        };
+        execute(args: {
+            filePath: string;
+            line: number;
+            character: number;
+            newName: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    lsp_code_actions: {
+        description: string;
+        args: {
+            filePath: import("zod").ZodString;
+            startLine: import("zod").ZodNumber;
+            startCharacter: import("zod").ZodNumber;
+            endLine: import("zod").ZodNumber;
+            endCharacter: import("zod").ZodNumber;
+            kind: import("zod").ZodOptional<import("zod").ZodEnum<{
+                quickfix: "quickfix";
+                refactor: "refactor";
+                "refactor.extract": "refactor.extract";
+                "refactor.inline": "refactor.inline";
+                "refactor.rewrite": "refactor.rewrite";
+                source: "source";
+                "source.organizeImports": "source.organizeImports";
+                "source.fixAll": "source.fixAll";
+            }>>;
+        };
+        execute(args: {
+            filePath: string;
+            startLine: number;
+            startCharacter: number;
+            endLine: number;
+            endCharacter: number;
+            kind?: "quickfix" | "refactor" | "refactor.extract" | "refactor.inline" | "refactor.rewrite" | "source" | "source.organizeImports" | "source.fixAll" | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    lsp_code_action_resolve: {
+        description: string;
+        args: {
+            filePath: import("zod").ZodString;
+            codeAction: import("zod").ZodString;
+        };
+        execute(args: {
+            filePath: string;
+            codeAction: string;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    ast_grep_search: {
+        description: string;
+        args: {
+            pattern: import("zod").ZodString;
+            lang: import("zod").ZodEnum<{
+                typescript: "typescript";
+                csharp: "csharp";
+                rust: "rust";
+                php: "php";
+                python: "python";
+                javascript: "javascript";
+                go: "go";
+                c: "c";
+                cpp: "cpp";
+                java: "java";
+                ruby: "ruby";
+                lua: "lua";
+                swift: "swift";
+                elixir: "elixir";
+                yaml: "yaml";
+                bash: "bash";
+                css: "css";
+                haskell: "haskell";
+                html: "html";
+                json: "json";
+                kotlin: "kotlin";
+                nix: "nix";
+                scala: "scala";
+                solidity: "solidity";
+                tsx: "tsx";
+            }>;
+            paths: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            globs: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            context: import("zod").ZodOptional<import("zod").ZodNumber>;
+        };
+        execute(args: {
+            pattern: string;
+            lang: "typescript" | "csharp" | "rust" | "php" | "python" | "javascript" | "go" | "c" | "cpp" | "java" | "ruby" | "lua" | "swift" | "elixir" | "yaml" | "bash" | "css" | "haskell" | "html" | "json" | "kotlin" | "nix" | "scala" | "solidity" | "tsx";
+            paths?: string[] | undefined;
+            globs?: string[] | undefined;
+            context?: number | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    ast_grep_replace: {
+        description: string;
+        args: {
+            pattern: import("zod").ZodString;
+            rewrite: import("zod").ZodString;
+            lang: import("zod").ZodEnum<{
+                typescript: "typescript";
+                csharp: "csharp";
+                rust: "rust";
+                php: "php";
+                python: "python";
+                javascript: "javascript";
+                go: "go";
+                c: "c";
+                cpp: "cpp";
+                java: "java";
+                ruby: "ruby";
+                lua: "lua";
+                swift: "swift";
+                elixir: "elixir";
+                yaml: "yaml";
+                bash: "bash";
+                css: "css";
+                haskell: "haskell";
+                html: "html";
+                json: "json";
+                kotlin: "kotlin";
+                nix: "nix";
+                scala: "scala";
+                solidity: "solidity";
+                tsx: "tsx";
+            }>;
+            paths: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            globs: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            dryRun: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            pattern: string;
+            rewrite: string;
+            lang: "typescript" | "csharp" | "rust" | "php" | "python" | "javascript" | "go" | "c" | "cpp" | "java" | "ruby" | "lua" | "swift" | "elixir" | "yaml" | "bash" | "css" | "haskell" | "html" | "json" | "kotlin" | "nix" | "scala" | "solidity" | "tsx";
+            paths?: string[] | undefined;
+            globs?: string[] | undefined;
+            dryRun?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    safe_grep: {
+        description: string;
+        args: {
+            pattern: import("zod").ZodString;
+            include: import("zod").ZodOptional<import("zod").ZodString>;
+            path: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            pattern: string;
+            include?: string | undefined;
+            path?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+};

package/dist/tools/lsp/client.d.ts

@@ -0,0 +1,55 @@
+import type { ResolvedServer } from "./config";
+declare class LSPServerManager {
+    private static instance;
+    private clients;
+    private cleanupInterval;
+    private readonly IDLE_TIMEOUT;
+    private constructor();
+    static getInstance(): LSPServerManager;
+    private getKey;
+    private startCleanupTimer;
+    private cleanupIdleClients;
+    getClient(root: string, server: ResolvedServer): Promise<LSPClient>;
+    warmupClient(root: string, server: ResolvedServer): void;
+    releaseClient(root: string, serverId: string): void;
+    isServerInitializing(root: string, serverId: string): boolean;
+    stopAll(): Promise<void>;
+}
+export declare const lspManager: LSPServerManager;
+export declare class LSPClient {
+    private root;
+    private server;
+    private proc;
+    private buffer;
+    private pending;
+    private requestIdCounter;
+    private openedFiles;
+    private stderrBuffer;
+    private processExited;
+    constructor(root: string, server: ResolvedServer);
+    start(): Promise<void>;
+    private startReading;
+    private startStderrReading;
+    private rejectAllPending;
+    private findSequence;
+    private processBuffer;
+    private send;
+    private notify;
+    private respond;
+    private handleServerRequest;
+    initialize(): Promise<void>;
+    openFile(filePath: string): Promise<void>;
+    hover(filePath: string, line: number, character: number): Promise<unknown>;
+    definition(filePath: string, line: number, character: number): Promise<unknown>;
+    references(filePath: string, line: number, character: number, includeDeclaration?: boolean): Promise<unknown>;
+    documentSymbols(filePath: string): Promise<unknown>;
+    workspaceSymbols(query: string): Promise<unknown>;
+    diagnostics(filePath: string): Promise<unknown>;
+    prepareRename(filePath: string, line: number, character: number): Promise<unknown>;
+    rename(filePath: string, line: number, character: number, newName: string): Promise<unknown>;
+    codeAction(filePath: string, startLine: number, startChar: number, endLine: number, endChar: number, only?: string[]): Promise<unknown>;
+    codeActionResolve(codeAction: unknown): Promise<unknown>;
+    isAlive(): boolean;
+    stop(): Promise<void>;
+}
+export {};

package/dist/tools/lsp/config.d.ts

@@ -0,0 +1,24 @@
+export interface ResolvedServer {
+    id: string;
+    command: string[];
+    extensions: string[];
+    priority: number;
+    env?: Record<string, string>;
+    initialization?: Record<string, unknown>;
+}
+export declare function findServerForExtension(ext: string): ResolvedServer | null;
+export declare function getLanguageId(ext: string): string;
+export declare function isServerInstalled(command: string[]): boolean;
+export declare function getAllServers(): Array<{
+    id: string;
+    installed: boolean;
+    extensions: string[];
+    disabled: boolean;
+    source: string;
+    priority: number;
+}>;
+export declare function getConfigPaths_(): {
+    project: string;
+    user: string;
+    opencode: string;
+};

package/dist/tools/lsp/constants.d.ts

@@ -0,0 +1,5 @@
+import type { LSPServerConfig } from "./types";
+export declare const SYMBOL_KIND_MAP: Record<number, string>;
+export declare const SEVERITY_MAP: Record<number, string>;
+export declare const BUILTIN_SERVERS: Record<string, Omit<LSPServerConfig, "id">>;
+export declare const EXT_TO_LANG: Record<string, string>;

package/dist/tools/lsp/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./types";
+export * from "./constants";
+export * from "./config";
+export * from "./client";
+export * from "./utils";
+export * from "./tools";