@pinata/sdk 1.2.1 → 2.0.0-beta.2

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

@@ -1,5 +1,5 @@
 import axios from 'axios';
-import pinByHash from'../../../src/commands/pinning/pinByHash';
+import pinByHash from '../../../src/commands/pinning/pinByHash';
 
 jest.mock('axios');
 
@@ -24,7 +24,7 @@ test('200 status is returned', () => {
         status: 200,
         data: 'testData'
     };
-    axios.post.mockResolvedValue(goodStatus);
+    (axios.post as jest.Mock).mockResolvedValue(goodStatus);
     expect.assertions(1);
     expect(pinByHash({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHashToPin)).resolves.toEqual(goodStatus.data);
 });
@@ -33,15 +33,14 @@ test('Result other than 200 status is returned', () => {
     const badStatus = {
         status: 700
     };
-    axios.post.mockResolvedValue(badStatus);
+    (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.mockRejectedValue('test error');
+    (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.js → pinFileToIPFS.test.ts}

@@ -1,5 +1,5 @@
 import axios from 'axios';
-import pinFileToIPFS from'../../../src/commands/pinning/pinFileToIPFS';
+import pinFileToIPFS from '../../../src/commands/pinning/pinFileToIPFS';
 import fs from 'fs';
 import NodeFormData from 'form-data';
 jest.mock('axios');
@@ -10,7 +10,6 @@ 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'));
 
@@ -22,9 +21,9 @@ test('200 status is returned with valid stream', () => {
         status: 200,
         data: 'testData'
     };
-    axios.post.mockResolvedValue(goodStatus);
+    (axios.post as jest.Mock).mockResolvedValue(goodStatus);
     expect.assertions(1);
-    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, validStream)).resolves.toEqual(goodStatus.data);
+    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, validStream, {pinataMetadata: { name: 'text.txt'}})).resolves.toEqual(goodStatus.data);
 });
 
 test('200 status is returned with valid form data', () => {
@@ -32,24 +31,23 @@ test('200 status is returned with valid form data', () => {
         status: 200,
         data: 'testData'
     };
-    axios.post.mockResolvedValue(goodStatus);
+    (axios.post as jest.Mock).mockResolvedValue(goodStatus);
     expect.assertions(1);
-    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, validFormData)).resolves.toEqual(goodStatus.data);
+    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, validFormData, {pinataMetadata: { name: 'text.txt'}})).resolves.toEqual(goodStatus.data);
 });
 
 test('Result other than 200 status is returned', () => {
     const badStatus = {
         status: 700
     };
-    axios.post.mockResolvedValue(badStatus);
+    (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}`));
+    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, validStream, {pinataMetadata: { name: 'text.txt'}})).rejects.toEqual(Error(`unknown server response while pinning File to IPFS: ${badStatus}`));
 });
 
 test('Rejection handled', () => {
-    axios.post.mockRejectedValue('test error');
+    (axios.post as jest.Mock).mockRejectedValue('test error');
     expect.assertions(1);
-    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, validStream)).rejects.toEqual('test error');
+    expect(pinFileToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, validStream, {pinataMetadata: { name: 'text.txt'}})).rejects.toEqual('test error');
 });
 
-

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

@@ -1,16 +1,16 @@
 import axios from 'axios';
-import pinFromFS from'../../../src/commands/pinning/pinFromFS';
+import pinFromFS from '../../../src/commands/pinning/pinFromFS';
 jest.mock('axios');
 
 //common values
-const testSource = './testing/testing'
+const testSource = './testing/testing';
 
 test('200 status is returned', () => {
     const goodStatus = {
         status: 200,
         data: 'testData'
     };
-    axios.post.mockResolvedValue(goodStatus);
+    (axios.post as jest.Mock).mockResolvedValue(goodStatus);
     expect.assertions(1);
     expect(pinFromFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, testSource)).resolves.toEqual(goodStatus.data);
 });
@@ -19,15 +19,14 @@ test('Result other than 200 status is returned', () => {
     const badStatus = {
         status: 700
     };
-    axios.post.mockResolvedValue(badStatus);
+    (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.mockRejectedValue('test error');
+    (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.js → pinJSONToIPFS.test.ts}

@@ -1,5 +1,5 @@
 import axios from 'axios';
-import pinJSONToIPFS from'../../../src/commands/pinning/pinJSONToIPFS';
+import pinJSONToIPFS from '../../../src/commands/pinning/pinJSONToIPFS';
 
 jest.mock('axios');
 
@@ -20,7 +20,7 @@ test('200 status is returned', () => {
         status: 200,
         data: 'testData'
     };
-    axios.post.mockResolvedValue(goodStatus);
+    (axios.post as jest.Mock).mockResolvedValue(goodStatus);
     expect.assertions(1);
     expect(pinJSONToIPFS({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodJSON)).resolves.toEqual(goodStatus.data);
 });
@@ -29,15 +29,14 @@ test('Result other than 200 status is returned', () => {
     const badStatus = {
         status: 700
     };
-    axios.post.mockResolvedValue(badStatus);
+    (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.mockRejectedValue('test error');
+    (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.js → pinJobs.test.ts}

@@ -1,5 +1,5 @@
 import axios from 'axios';
-import pinJobs from './../../../../src/commands/pinning/pinJobs/pinJobs';
+import pinJobs from '../../../../src/commands/pinning/pinJobs/pinJobs';
 
 jest.mock('axios');
 
@@ -7,7 +7,7 @@ test('Result other than 200 status is returned', () => {
     const badStatus = {
         status: 700
     };
-    axios.get.mockResolvedValue(badStatus);
+    (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}`));
 });
@@ -17,13 +17,13 @@ test('200 status is returned', () => {
         status: 200,
         data: 'testData'
     };
-    axios.get.mockResolvedValue(goodStatus);
+    (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.mockRejectedValue('test error');
+    (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');
 
@@ -24,7 +24,7 @@ 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({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHashToUnpin)).resolves.toEqual(goodStatus.data);
 });
@@ -33,15 +33,14 @@ 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({ 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({ pinataApiKey: 'test', pinataSecretApiKey: 'test' }, goodHashToUnpin)).rejects.toEqual('test error');
 });
 
-

package/test/util/validators.test.ts

@@ -0,0 +1,234 @@
+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'
+        );
+        expect(() => {
+            validateApiKeys('test', '');
+        }).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 = {
+            test: 'test'
+        };
+        expect(() => {
+            validateHostNodes(hostNodes);
+        }).toThrow('host_nodes value must be an array');
+    });
+
+    test('invalid host_node entry', () => {
+        const validHost =
+            '/ip4/127.0.0.1/tcp/1234/ws/ipfs/QmUjNmr8TgJCn1Ao7DvMy4cjoZU15b9bwSCBLE3vwXiwgj';
+        const invalidHost = 'invalid host';
+        const hostNodes = [validHost, invalidHost];
+        expect(() => {
+            validateHostNodes(hostNodes);
+        }).toThrow(
+            `host_node array entry: ${invalidHost} is not a valid peer multiaddr`
+        );
+    });
+});
+
+describe('validateMetadata function testing', () => {
+    test('name is not a string', () => {
+        const badName = {
+            test: 'testing'
+        };
+        expect(() => {
+            validateMetadata({
+                name: badName
+            });
+        }).toThrow('metadata name must be of type string');
+    });
+    test('keyvalues is not an object', () => {
+        const badKeyValues = 'testing';
+        expect(() => {
+            validateMetadata({
+                keyvalues: badKeyValues
+            });
+        }).toThrow('metatadata keyvalues must be an object');
+    });
+
+    test('more than 10 keyvalues was provided', () => {
+        const tooManyKeyValues = {
+            one: 1,
+            two: 2,
+            three: 3,
+            four: 4,
+            five: 5,
+            six: 6,
+            seven: 7,
+            eight: 8,
+            nine: 9,
+            ten: 10,
+            eleven: 11
+        };
+        expect(() => {
+            validateMetadata({
+                keyvalues: tooManyKeyValues
+            });
+        }).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 = {
+            one: 1,
+            two: {
+                test: 'test'
+            },
+            three: 3,
+            four: 4,
+            five: 5,
+            six: 6,
+            seven: 7,
+            eight: 8,
+            nine: 9,
+            ten: 10,
+            eleven: 11
+        };
+        expect(() => {
+            validateMetadata({
+                keyvalues: invalidValue
+            });
+        }).toThrow(
+            'Metadata keyvalue values must be strings, booleans, or numbers'
+        );
+    });
+    test('Does not throw an error if metadata is valid', () => {
+        const invalidValue = {
+            one: 1,
+            two: 2,
+            three: 3,
+            four: 4,
+            five: 5,
+            six: 6,
+            seven: 7,
+            eight: 8,
+            nine: 9,
+            ten: 10
+        };
+        expect(() => {
+            validateMetadata({
+                keyvalues: invalidValue
+            });
+        }).not.toThrow();
+    });
+});
+
+describe('validatePinPolicyStructure function testing', () => {
+    test('No Policy Provided', () => {
+        expect(() => {
+            validatePinPolicyStructure();
+        }).toThrow('No pin policy provided');
+    });
+    test('No Regions Provided', () => {
+        expect(() => {
+            validatePinPolicyStructure({
+                test: 'test'
+            });
+        }).toThrow('No regions provided in pin policy');
+    });
+    test('region id is not a string', () => {
+        expect(() => {
+            validatePinPolicyStructure({
+                regions: [
+                    {
+                        id: 'goodRegionId',
+                        desiredReplicationCount: 1
+                    },
+                    {
+                        id: 0,
+                        desiredReplicationCount: 1
+                    }
+                ]
+            });
+        }).toThrow('region id must be a string');
+    });
+    test('desiredReplicationCount is not an integer', () => {
+        expect(() => {
+            validatePinPolicyStructure({
+                regions: [
+                    {
+                        id: 'goodRegionId',
+                        desiredReplicationCount: 1
+                    },
+                    {
+                        id: 'goodRegionId2',
+                        desiredReplicationCount: 'string that should fail'
+                    }
+                ]
+            });
+        }).toThrow('desiredReplicationCount must be an integer');
+    });
+});
+
+describe('validatePinataOptions function testing', () => {
+    test('options is not an object', () => {
+        expect(() => {
+            validatePinataOptions('test');
+        }).toThrow('options must be an object');
+    });
+    test('cidVersion is not a 0 or 1', () => {
+        const badVersion = {
+            test: 'testing'
+        };
+        expect(() => {
+            validatePinataOptions({
+                cidVersion: badVersion
+            });
+        }).toThrow('unsupported or invalid cidVersion');
+    });
+    test('wrapWithDirectory is not true or false', () => {
+        expect(() => {
+            validatePinataOptions({
+                wrapWithDirectory: 'test'
+            });
+        }).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(config: 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(config: any, 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 | number | null;
+            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(config: any): 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(config: any): 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(config: any, 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/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(config: any, 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>;