@pinata/sdk 1.2.0 → 2.0.0-beta.0

package/test/commands/pinning/pinByHash.test.ts

@@ -0,0 +1,46 @@
+import axios from 'axios';
+import pinByHash from '../../../src/commands/pinning/pinByHash';
+
+jest.mock('axios');
+
+//common values
+const badHashToPin = 'test';
+const goodHashToPin = 'Qma6e8dovfLyiG2UUfdkSHNPAySzrWLX9qVXb44v1muqcp';
+
+test('No hashToPin value is provided should error', () => {
+    expect(() => {
+        pinByHash('test', 'test');
+    }).toThrow();
+});
+
+test('Invalid HashToPin value is provided', () => {
+    expect(() => {
+        pinByHash({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, badHashToPin);
+    }).toThrow();
+});
+
+test('200 status is returned', () => {
+    const goodStatus = {
+        status: 200,
+        data: 'testData'
+    };
+    (axios.post as jest.Mock).mockResolvedValue(goodStatus);
+    expect.assertions(1);
+    expect(pinByHash({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHashToPin)).resolves.toEqual(goodStatus.data);
+});
+
+test('Result other than 200 status is returned', () => {
+    const badStatus = {
+        status: 700
+    };
+    (axios.post as jest.Mock).mockResolvedValue(badStatus);
+    expect.assertions(1);
+    expect(pinByHash({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHashToPin)).rejects.toEqual(Error(`unknown server response while adding to pin queue: ${badStatus}`));
+});
+
+test('Rejection handled', () => {
+    (axios.post as jest.Mock).mockRejectedValue('test error');
+    expect.assertions(1);
+    expect(pinByHash({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHashToPin)).rejects.toEqual('test error');
+});
+

package/test/commands/pinning/pinFileToIPFS.test.ts

@@ -0,0 +1,53 @@
+import axios from 'axios';
+import pinFileToIPFS from '../../../src/commands/pinning/pinFileToIPFS';
+import fs from 'fs';
+import NodeFormData from 'form-data';
+jest.mock('axios');
+
+//common values
+const nonStream = 'test';
+const validStream = fs.createReadStream('./pinata.png');
+const validFormData = new NodeFormData();
+validFormData.append('file', validStream, {filepath: 'test/filepath'});
+
+test('non-readableStream and non-formData is passed in', () => {
+    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, nonStream)).rejects.toEqual(Error('readStream is not a readable stream or form data'));
+
+    return undefined;
+});
+
+test('200 status is returned with valid stream', () => {
+    const goodStatus = {
+        status: 200,
+        data: 'testData'
+    };
+    (axios.post as jest.Mock).mockResolvedValue(goodStatus);
+    expect.assertions(1);
+    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, validStream)).resolves.toEqual(goodStatus.data);
+});
+
+test('200 status is returned with valid form data', () => {
+    const goodStatus = {
+        status: 200,
+        data: 'testData'
+    };
+    (axios.post as jest.Mock).mockResolvedValue(goodStatus);
+    expect.assertions(1);
+    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, validFormData)).resolves.toEqual(goodStatus.data);
+});
+
+test('Result other than 200 status is returned', () => {
+    const badStatus = {
+        status: 700
+    };
+    (axios.post as jest.Mock).mockResolvedValue(badStatus);
+    expect.assertions(1);
+    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, validStream)).rejects.toEqual(Error(`unknown server response while pinning File to IPFS: ${badStatus}`));
+});
+
+test('Rejection handled', () => {
+    (axios.post as jest.Mock).mockRejectedValue('test error');
+    expect.assertions(1);
+    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, validStream)).rejects.toEqual('test error');
+});
+

package/test/commands/pinning/pinFromFS.ts

@@ -0,0 +1,32 @@
+import axios from 'axios';
+import pinFromFS from '../../../src/commands/pinning/pinFromFS';
+jest.mock('axios');
+
+//common values
+const testSource = './testing/testing';
+
+test('200 status is returned', () => {
+    const goodStatus = {
+        status: 200,
+        data: 'testData'
+    };
+    (axios.post as jest.Mock).mockResolvedValue(goodStatus);
+    expect.assertions(1);
+    expect(pinFromFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, testSource)).resolves.toEqual(goodStatus.data);
+});
+
+test('Result other than 200 status is returned', () => {
+    const badStatus = {
+        status: 700
+    };
+    (axios.post as jest.Mock).mockResolvedValue(badStatus);
+    expect.assertions(1);
+    expect(pinFromFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, testSource)).rejects.toEqual(Error(`unknown server response while pinning to IPFS: ${badStatus}`));
+});
+
+test('Rejection handled', () => {
+    (axios.post as jest.Mock).mockRejectedValue('test error');
+    expect.assertions(1);
+    expect(pinFromFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, testSource)).rejects.toEqual('test error');
+});
+

package/test/commands/pinning/pinJSONToIPFS.test.ts

@@ -0,0 +1,42 @@
+import axios from 'axios';
+import pinJSONToIPFS from '../../../src/commands/pinning/pinJSONToIPFS';
+
+jest.mock('axios');
+
+//common values
+const badJSON = 'test';
+const goodJSON = {
+    test: 'test'
+};
+
+test('non-object is passed in', () => {
+    expect(() => {
+        pinJSONToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, badJSON);
+    }).toThrow('body must be a valid JSON object');
+});
+
+test('200 status is returned', () => {
+    const goodStatus = {
+        status: 200,
+        data: 'testData'
+    };
+    (axios.post as jest.Mock).mockResolvedValue(goodStatus);
+    expect.assertions(1);
+    expect(pinJSONToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodJSON)).resolves.toEqual(goodStatus.data);
+});
+
+test('Result other than 200 status is returned', () => {
+    const badStatus = {
+        status: 700
+    };
+    (axios.post as jest.Mock).mockResolvedValue(badStatus);
+    expect.assertions(1);
+    expect(pinJSONToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodJSON)).rejects.toEqual(Error(`unknown server response while pinning JSON to IPFS: ${badStatus}`));
+});
+
+test('Rejection handled', () => {
+    (axios.post as jest.Mock).mockRejectedValue('test error');
+    expect.assertions(1);
+    expect(pinJSONToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodJSON)).rejects.toEqual('test error');
+});
+

package/test/commands/pinning/pinJobs/pinJobs.test.ts

@@ -0,0 +1,29 @@
+import axios from 'axios';
+import pinJobs from '../../../../src/commands/pinning/pinJobs/pinJobs';
+
+jest.mock('axios');
+
+test('Result other than 200 status is returned', () => {
+    const badStatus = {
+        status: 700
+    };
+    (axios.get as jest.Mock).mockResolvedValue(badStatus);
+    expect.assertions(1);
+    expect(pinJobs({ pinataApiKey: 'test', pinataSecretApiKey: 'test' })).rejects.toEqual(Error(`unknown server response while attempting to retrieve pin jobs: ${badStatus}`));
+});
+
+test('200 status is returned', () => {
+    const goodStatus = {
+        status: 200,
+        data: 'testData'
+    };
+    (axios.get as jest.Mock).mockResolvedValue(goodStatus);
+    expect.assertions(1);
+    expect(pinJobs({ pinataApiKey: 'test', pinataSecretApiKey: 'test' })).resolves.toEqual(goodStatus.data);
+});
+
+test('Rejection handled', () => {
+    (axios.get as jest.Mock).mockRejectedValue('test error');
+    expect.assertions(1);
+    expect(pinJobs({ pinataApiKey: 'test', pinataSecretApiKey: 'test' })).rejects.toEqual('test error');
+});

package/test/commands/pinning/pinJobs/{queryBuilder.test.js → queryBuilder.test.ts}

@@ -1,4 +1,4 @@
-import queryBuilder from './../../../../src/commands/pinning/pinJobs/queryBuilder';
+import queryBuilder from '../../../../src/commands/pinning/pinJobs/queryBuilder';
 
 const baseUrl = 'testing.com/test';
 const badFilterValue = 'badFilterValue';
@@ -6,11 +6,11 @@ const goodHashToPin = 'Qma6e8dovfLyiG2UUfdkSHNPAySzrWLX9qVXb44v1muqcp';
 
 describe('queryBuilder no params provided', () => {
     test('if no baseUrl is provided', () => {
-        expect(() => {
-            queryBuilder();
-        }).toThrow('no baseUrl provided');
+        // expect(() => {
+        //     queryBuilder();
+        // }).toThrow('no baseUrl provided');
     });
-    test('if no filters are provided, return base url', () => {
+    test('if no filters are provided, return a non filtered url', () => {
         expect(queryBuilder(baseUrl)).toEqual(baseUrl);
     });
 });

package/test/commands/pinning/{unpin.test.js → unpin.test.ts}

@@ -1,5 +1,5 @@
 import axios from 'axios';
-import unpin from'../../../src/commands/pinning/unpin';
+import unpin from '../../../src/commands/pinning/unpin';
 
 jest.mock('axios');
 
@@ -9,13 +9,13 @@ const goodHashToUnpin = 'Qma6e8dovfLyiG2UUfdkSHNPAySzrWLX9qVXb44v1muqcp';
 
 test('No hashToUnpin value is provided should error', () => {
     expect(() => {
-        unpin('test', 'test');
+        unpin({ pinataApiKey: 'test', pinataSecretApiKey: 'test' });
     }).toThrow('hashToUnpin value is required for removing a pin from Pinata');
 });
 
 test('Invalid hashToUnpin value is provided', () => {
     expect(() => {
-        unpin('test', 'test', badHashToUnpin);
+        unpin({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, badHashToUnpin);
     }).toThrow(`${badHashToUnpin} is an invalid IPFS CID`);
 });
 
@@ -24,24 +24,23 @@ test('200 status is returned', () => {
         status: 200,
         data: 'testData'
     };
-    axios.delete.mockResolvedValue(goodStatus);
+    (axios.delete as jest.Mock).mockResolvedValue(goodStatus);
     expect.assertions(1);
-    expect(unpin('test', 'test', goodHashToUnpin)).resolves.toEqual(goodStatus.data);
+    expect(unpin({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHashToUnpin)).resolves.toEqual(goodStatus.data);
 });
 
 test('Result other than 200 status is returned', () => {
     const badStatus = {
         status: 700
     };
-    axios.delete.mockResolvedValue(badStatus);
+    (axios.delete as jest.Mock).mockResolvedValue(badStatus);
     expect.assertions(1);
-    expect(unpin('test', 'test', goodHashToUnpin)).rejects.toEqual(Error(`unknown server response while removing pin from IPFS: ${badStatus}`));
+    expect(unpin({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHashToUnpin)).rejects.toEqual(Error(`unknown server response while removing pin from IPFS: ${badStatus}`));
 });
 
 test('Rejection handled', () => {
-    axios.delete.mockRejectedValue('test error');
+    (axios.delete as jest.Mock).mockRejectedValue('test error');
     expect.assertions(1);
-    expect(unpin('test', 'test', goodHashToUnpin)).rejects.toEqual('test error');
+    expect(unpin({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHashToUnpin)).rejects.toEqual('test error');
 });
 
-

package/test/util/{validators.test.js → validators.test.ts}

@@ -1,16 +1,54 @@
-import { validateApiKeys, validateHostNodes, validateMetadata, validatePinPolicyStructure, validatePinataOptions } from "../../src/util/validators";
+import {
+    validateApiKeys,
+    createConfigForAxiosHeaders,
+    validateHostNodes,
+    validateMetadata,
+    validatePinPolicyStructure,
+    validatePinataOptions
+} from '../../src/util/validators';
+import { ERROR_NO_CREDENTIALS_PROVIDED } from '../../src/constants';
 
 describe('validateApiKeys function testing', () => {
     test('check to throw if either pinataApiKey or pinataSecretApiKey are not provided', () => {
         expect(() => {
             validateApiKeys('', 'test');
-        }).toThrow('No pinataApiKey provided! Please provide your pinata api key as an argument when you start this script');
+        }).toThrow(
+            'No pinataApiKey provided! Please provide your pinata api key as an argument when you start this script'
+        );
         expect(() => {
             validateApiKeys('test', '');
-        }).toThrow('No pinataSecretApiKey provided! Please provide your pinata secret api key as an argument when you start this script');
+        }).toThrow(
+            'No pinataSecretApiKey provided! Please provide your pinata secret api key as an argument when you start this script'
+        );
     });
 });
 
+describe('createConfigForAxiosHeaders function testing', () => {
+    expect(() => {
+        createConfigForAxiosHeaders({});
+    }).toThrow(ERROR_NO_CREDENTIALS_PROVIDED);
+
+    expect(() => {
+        createConfigForAxiosHeaders({ pinataApiKey: 'some api key' });
+    }).toThrow(ERROR_NO_CREDENTIALS_PROVIDED);
+
+    expect(() => {
+        createConfigForAxiosHeaders({ pinataSecretApiKey: 'some api secret' });
+    }).toThrow(ERROR_NO_CREDENTIALS_PROVIDED);
+
+    expect(
+        createConfigForAxiosHeaders({
+            pinataApiKey: 'some api key',
+            pinataSecretApiKey: 'some api secret'
+        })
+    ).toEqual({
+        withCredentials: true,
+        headers: {
+            pinata_api_key: 'some api key',
+            pinata_secret_api_key: 'some api secret'
+        }
+    });
+});
 describe('validateHostNodes function testing', () => {
     test('host_nodes is not an array', () => {
         const hostNodes = {
@@ -22,19 +60,18 @@ describe('validateHostNodes function testing', () => {
     });
 
     test('invalid host_node entry', () => {
-        const validHost = '/ip4/127.0.0.1/tcp/1234/ws/ipfs/QmUjNmr8TgJCn1Ao7DvMy4cjoZU15b9bwSCBLE3vwXiwgj';
+        const validHost =
+            '/ip4/127.0.0.1/tcp/1234/ws/ipfs/QmUjNmr8TgJCn1Ao7DvMy4cjoZU15b9bwSCBLE3vwXiwgj';
         const invalidHost = 'invalid host';
-        const hostNodes = [
-            validHost,
-            invalidHost
-        ];
+        const hostNodes = [validHost, invalidHost];
         expect(() => {
             validateHostNodes(hostNodes);
-        }).toThrow(`host_node array entry: ${invalidHost} is not a valid peer multiaddr`);
+        }).toThrow(
+            `host_node array entry: ${invalidHost} is not a valid peer multiaddr`
+        );
     });
 });
 
-
 describe('validateMetadata function testing', () => {
     test('name is not a string', () => {
         const badName = {
@@ -73,7 +110,9 @@ describe('validateMetadata function testing', () => {
             validateMetadata({
                 keyvalues: tooManyKeyValues
             });
-        }).toThrow('No more than 10 keyvalues can be provided for metadata entries');
+        }).toThrow(
+            'No more than 10 keyvalues can be provided for metadata entries'
+        );
     });
     test('Throws error on an object being passed in as a value for a keyvalue', () => {
         const invalidValue = {
@@ -95,7 +134,9 @@ describe('validateMetadata function testing', () => {
             validateMetadata({
                 keyvalues: invalidValue
             });
-        }).toThrow('Metadata keyvalue values must be strings, booleans, or numbers');
+        }).toThrow(
+            'Metadata keyvalue values must be strings, booleans, or numbers'
+        );
     });
     test('Does not throw an error if metadata is valid', () => {
         const invalidValue = {
@@ -122,14 +163,14 @@ describe('validatePinPolicyStructure function testing', () => {
     test('No Policy Provided', () => {
         expect(() => {
             validatePinPolicyStructure();
-        }).toThrow("No pin policy provided");
+        }).toThrow('No pin policy provided');
     });
     test('No Regions Provided', () => {
         expect(() => {
             validatePinPolicyStructure({
                 test: 'test'
             });
-        }).toThrow("No regions provided in pin policy");
+        }).toThrow('No regions provided in pin policy');
     });
     test('region id is not a string', () => {
         expect(() => {
@@ -145,7 +186,7 @@ describe('validatePinPolicyStructure function testing', () => {
                     }
                 ]
             });
-        }).toThrow("region id must be a string");
+        }).toThrow('region id must be a string');
     });
     test('desiredReplicationCount is not an integer', () => {
         expect(() => {
@@ -161,11 +202,10 @@ describe('validatePinPolicyStructure function testing', () => {
                     }
                 ]
             });
-        }).toThrow("desiredReplicationCount must be an integer");
+        }).toThrow('desiredReplicationCount must be an integer');
     });
 });
 
-
 describe('validatePinataOptions function testing', () => {
     test('options is not an object', () => {
         expect(() => {
@@ -187,6 +227,8 @@ describe('validatePinataOptions function testing', () => {
             validatePinataOptions({
                 wrapWithDirectory: 'test'
             });
-        }).toThrow('wrapWithDirectory must be a boolean value of true or false');
+        }).toThrow(
+            'wrapWithDirectory must be a boolean value of true or false'
+        );
     });
 });

package/tsconfig.json

@@ -1,10 +1,10 @@
 {
   "include": [
-    "src/**/*.js"
-  ],
+    "src/**/*.ts",   "src/**/*.js"],
   "compilerOptions": {
     "declaration": true,
     "emitDeclarationOnly": true,
+    "sourceMap": true,
     "allowJs": true,
     "outDir": "types",
     "target": "es5",

package/types/commands/data/getFilesByCount/getFilesByCount.d.ts

@@ -1,7 +1,9 @@
-export default function getFilesByCount(pinataApiKey: any, pinataSecretApiKey: any, filters?: {}, maxCount?: number): {
+import { PinataConfig } from '../../..';
+import { PinataPin, PinataPinListFilterOptions } from '../pinList/pinList';
+export default function getFilesByCount(config: PinataConfig, filters?: PinataPinListFilterOptions, maxCount?: number): {
     [Symbol.asyncIterator]: () => {
         next(): Promise<{
-            value: any;
+            value: PinataPin;
             done: boolean;
         }>;
         return(): Promise<{

package/types/commands/data/index.d.ts

@@ -0,0 +1,4 @@
+export * from '../data/pinList/pinList';
+export * from '../data/pinList/queryBuilder';
+export * from './testAuthentication';
+export * from './userPinnedDataTotal';

package/types/commands/data/pinList/pinList.d.ts

@@ -1,8 +1,45 @@
-/**
- * Pin List
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @param {any} filters
- * @returns {Promise<unknown>}
- */
-export default function pinList(pinataApiKey: string, pinataSecretApiKey: string, filters?: any): Promise<unknown>;
+import { PinataConfig } from '../../..';
+export interface PinataPinRegion {
+    regionId: string;
+    currentReplicationCount: number;
+    desiredReplicationCount: number;
+}
+export interface PinataMetadata {
+    [key: string]: string | number | null;
+}
+export interface PinataMetadataFilter {
+    name?: string | undefined;
+    keyvalues: {
+        [key: string]: {
+            value: string;
+            op: string;
+        };
+    };
+}
+export interface PinataPin {
+    id: string | number;
+    ipfs_pin_hash: string;
+    size: number;
+    user_id: string | number;
+    date_pinned: string;
+    date_unpinned: string | null;
+    metadata: PinataMetadata;
+    regions: PinataPinRegion[];
+}
+export declare type PinataPinListFilterOptions = {
+    hashContains?: string | undefined;
+    pinStart?: string | undefined;
+    pinEnd?: string | undefined;
+    unpinStart?: string | undefined;
+    unpinEnd?: string | undefined;
+    pinSizeMin?: number | undefined;
+    pinSizeMax?: number | undefined;
+    status?: string | undefined;
+    pageLimit?: number | undefined;
+    pageOffset?: number | undefined;
+    metadata?: PinataMetadataFilter | undefined;
+};
+export interface PinataPinListResponse {
+    rows: PinataPin[];
+}
+export default function pinList(config: PinataConfig, filters?: PinataPinListFilterOptions): Promise<PinataPinListResponse>;

package/types/commands/data/pinList/queryBuilder.d.ts

@@ -1,7 +1 @@
-/**
- * Query Builder
- * @param {string} baseUrl
- * @param {*} filters
- * @returns {string}
- */
-export default function queryBuilder(baseUrl: string, filters: any): string;
+export default function queryBuilder(baseUrl: string, filters?: any): string;

package/types/commands/data/testAuthentication.d.ts

@@ -1,7 +1,5 @@
-/**
- * Test Authentication
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @returns {Promise<unknown>}
- */
-export default function testAuthentication(pinataApiKey: string, pinataSecretApiKey: string): Promise<unknown>;
+import { PinataConfig } from '../..';
+export interface PinataTestAuthenticationResponse {
+    authenticated: boolean;
+}
+export default function testAuthentication(config: PinataConfig): Promise<PinataTestAuthenticationResponse>;

package/types/commands/data/userPinnedDataTotal.d.ts

@@ -1,7 +1,2 @@
-/**
- * User Pinned Data Total
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @returns {Promise<unknown>}
- */
-export default function userPinnedDataTotal(pinataApiKey: string, pinataSecretApiKey: string): Promise<unknown>;
+import { PinataConfig } from '../..';
+export default function userPinnedDataTotal(config: PinataConfig): Promise<number>;

package/types/commands/pinning/hashMetadata.d.ts

@@ -1,9 +1,3 @@
-/**
- * Hash Meta Data
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @param {*} ipfsPinHash
- * @param {*} metadata
- * @returns {Promise<unknown>}
- */
-export default function hashMetadata(pinataApiKey: string, pinataSecretApiKey: string, ipfsPinHash: any, metadata: any): Promise<unknown>;
+import { PinataConfig } from '../..';
+import { PinataMetadata } from '../data/pinList/pinList';
+export default function hashMetadata(config: PinataConfig, ipfsPinHash: string, metadata: PinataMetadata): Promise<any>;

package/types/commands/pinning/hashPinPolicy.d.ts

@@ -6,4 +6,4 @@
  * @param {*} newPinPolicy
  * @returns {Promise<unknown>}
  */
-export default function hashPinPolicy(pinataApiKey: string, pinataSecretApiKey: string, ipfsPinHash: any, newPinPolicy: any): Promise<unknown>;
+export default function hashPinPolicy(config: any, ipfsPinHash: any, newPinPolicy: any): Promise<unknown>;

package/types/commands/pinning/index.d.ts

@@ -0,0 +1,8 @@
+export * from './pinJobs/pinJobs';
+export * from './pinJobs/queryBuilder';
+export * from './hashMetadata';
+export * from './pinByHash';
+export * from './pinFileToIPFS';
+export * from './pinFromFS';
+export * from './pinJSONToIPFS';
+export * from './unpin';

package/types/commands/pinning/pinByHash.d.ts

@@ -1,9 +1,14 @@
-/**
- * Pin By Hash
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @param {*} hashToPin
- * @param {*} options
- * @returns {Promise<unknown>}
- */
-export default function pinByHash(pinataApiKey: string, pinataSecretApiKey: string, hashToPin: any, options: any): Promise<unknown>;
+import { PinataConfig } from '../..';
+import { PinataOptions } from './pinFileToIPFS';
+import { PinataMetadata } from '../data/pinList/pinList';
+export interface PinataPinByHashPinOptions {
+    pinataMetadata?: PinataMetadata;
+    pinataOptions?: PinataOptions;
+}
+export interface PinataPinByHashResponse {
+    id: number | string;
+    ipfsHash: string;
+    status: string;
+    name: string;
+}
+export default function pinByHash(config: PinataConfig, hashToPin: string, options: any): Promise<any>;

package/types/commands/pinning/pinFileToIPFS.d.ts

@@ -1,3 +1,27 @@
+import { PinataConfig } from '../..';
+export interface PinataPinPolicyItem {
+    id: string;
+    desiredReplicationCount: number;
+}
+export interface PinataOptions {
+    hostNodes?: string[] | undefined;
+    cidVersion?: 0 | 1;
+    wrapWithDirectory?: boolean;
+    customPinPolicy?: {
+        regions: PinataPinPolicyItem[];
+    };
+}
+export interface PinataPinResponse {
+    IpfsHash: string;
+    PinSize: number;
+    Timestamp: string;
+}
+export interface PinataPinOptions {
+    pinataMetadata?: {
+        [key: string]: string | number | null;
+    };
+    pinataOptions?: PinataOptions | undefined;
+}
 /**
  * Pin File to IPFS
  * @param {string} pinataApiKey
@@ -6,4 +30,4 @@
  * @param {*} options
  * @returns {Promise<unknown>}
  */
-export default function pinFileToIPFS(pinataApiKey: string, pinataSecretApiKey: string, readStream: any, options: any): Promise<unknown>;
+export default function pinFileToIPFS(config: PinataConfig, readStream: any, options?: PinataPinOptions): Promise<PinataPinResponse>;

package/types/commands/pinning/pinFromFS.d.ts

@@ -1,9 +1,3 @@
-/**
- * PinFromFS
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
- * @param {string} sourcePath
- * @param {*} options
- * @returns {Promise<unknown>}
- */
-export default function pinFromFS(pinataApiKey: string, pinataSecretApiKey: string, sourcePath: string, options: any): Promise<unknown>;
+import { PinataConfig } from '../..';
+import { PinataPinOptions, PinataPinResponse } from './pinFileToIPFS';
+export default function pinFromFS(config: PinataConfig, sourcePath: string, options?: PinataPinOptions): Promise<PinataPinResponse>;