Types

type AuthTestResponse = {
  message: string;
};

type ContainsCIDResponse = {
  containsCid: boolean;
  cid: string | null;
};

type ContentType =
  | "application/json"
  | "application/xml"
  | "text/plain"
  | "text/html"
  | "text/css"
  | "text/javascript"
  | "application/javascript"
  | "image/jpeg"
  | "image/png"
  | "image/gif"
  | "image/svg+xml"
  | "audio/mpeg"
  | "audio/ogg"
  | "video/mp4"
  | "application/pdf"
  | "application/octet-stream"
  | string
  | null;

type DataEndponts = {
  pinList?: boolean;
  userPinnedDataTotal?: boolean;
};

type Endpoints = {
  data?: DataEndponts;
  pinning?: PinningEndpoints;
};

type FileObject = {
  name: string;
  size: number;
  type: string;
  lastModified: number;
  arrayBuffer: () => Promise<ArrayBuffer>;
};

type GatewayAnalyticsQuery = {
  gateway_domain: string;
  start_date: string;
  end_date: string;
  cid?: string;
  file_name?: string;
  user_agent?: string;
  country?: string;
  region?: string;
  referer?: string;
  limit?: number;
  sort_order?: "asc" | "desc";
};

type GetCIDResponse = {
  data?: JSON | string | Blob | null;
  contentType: ContentType;
};

type GetGroupOptions = {
  groupId: string;
};

type GroupCIDOptions = {
  groupId: string;
  cids: string[];
};

type GroupOptions = {
  name: string;
};

type GroupQueryOptions = {
  nameContains?: string;
  offset?: number;
  limit?: number;
};

type GroupResponseItem = {
  id: string;
  user_id: string;
  name: string;
  updatedAt: string;
  createdAt: string;
};

type JsonBody = Record<string, unknown>;

type KeyListItem = {
  id: string;
  name: string;
  key: string;
  secret: string;
  max_uses: number;
  uses: number;
  user_id: string;
  scopes: KeyScopes;
  revoked: boolean;
  createdAt: string;
  updatedAt: string;
};

type KeyListQuery = {
  revoked?: boolean;
  limitedUse?: boolean;
  exhausted?: boolean;
  name?: string;
  offset?: number;
};

type KeyListResponse = {
  keys: KeyListItem[];
  count: number;
};

type KeyOptions = {
  keyName: string;
  permissions: KeyPermissions;
  maxUses?: number;
};

type KeyPermissions = {
  admin?: boolean;
  endpoints?: Endpoints;
};

type KeyResponse = {
  JWT: string;
  pinata_api_key: string;
  pinata_api_secret: string;
};

type KeyScopes = {
  endpoints: {
    pinning: {
      pinFileToIPFS: boolean;
      pinJSONToIPFS: boolean;
    };
  };
  admin: boolean;
};

type OptimizeImageOptions = {
  width?: number;
  height?: number;
  dpr?: number;
  fit?: "scaleDown" | "contain" | "cover" | "crop" | "pad";
  gravity?: "auto" | "side" | string;
  quality?: number;
  format?: "auto" | "webp";
  animation?: boolean;
  sharpen?: number;
  onError?: boolean;
  metadata?: "keep" | "copyright" | "none";
};

type PinByCIDResponse = {
  id: string;
  ipfsHash: string;
  status: "prechecking" | "retrieving";
  name: string;
  updated?: boolean;
};

type PinataConfig = {
  pinataJwt: string | undefined;
  pinataGateway?: string;
  pinataGatewayKey?: string;
  customHeaders?: Record<string, string>;
  endpointUrl?: string;
};

type PinataMetadata = {
  name?: string;
  keyValues?: Record<string, string | number>;
};

type PinataMetadataUpdate = {
  cid: string;
  name?: string;
  keyValues?: Record<string, string | number>;
};

type PinJobItem = {
  id: string;
  ipfs_pin_hash: string;
  date_queued: string;
  name: string;
  status: string;
  keyvalues: any;
  host_nodes: string[];
  pin_policy: {
    regions: {
      id: string;
      desiredReplicationCount: number;
    }[];
    version: number;
  };
};

type PinJobQuery = {
  sort?: "ASC" | "DSC";
  status?:
    | "prechecking"
    | "retrieving"
    | "expired"
    | "over_free_limit"
    | "over_max_size"
    | "invalid_object"
    | "bad_host_node";
  ipfs_pin_hash?: string;
  limit?: number;
  offset?: number;
};

type PinJobResponse = {
  rows: PinJobItem[];
};

type PinListItem = {
  id: string;
  ipfs_pin_hash: string;
  size: number;
  user_id: string;
  date_pinned: string;
  date_unpinned: string | null;
  metadata: {
    name: string | null;
    keyvalues: {
      [key: string]: any;
    } | null;
  };
  regions: {
    regionId: string;
    currentReplicationCount: number;
    desiredReplicationCount: number;
  }[];
  mime_type: string;
  number_of_files: number;
};

type PinListQuery = {
  cid?: string;
  pinStart?: string;
  pinEnd?: string;
  pinSizeMin?: number;
  pinSizeMax?: number;
  pageLimit?: number;
  pageOffset?: number;
  name?: string;
  groupId?: string;
  key?: string;
  value?: string | number;
  operator?:
    | "gt"
    | "gte"
    | "lt"
    | "lte"
    | "ne"
    | "eq"
    | "between"
    | "notBetween"
    | "like"
    | "notLike"
    | "iLike"
    | "notILike"
    | "regexp"
    | "iRegexp";
};

type PinListResponse = {
  rows: PinListItem[];
};

type PinningEndpoints = {
  hashMetadata?: boolean;
  hashPinPolicy?: boolean;
  pinByHash?: boolean;
  pinFileToIPFS?: boolean;
  pinJSONToIPFS?: boolean;
  pinJobs?: boolean;
  unpin?: boolean;
  userPinPolicy?: boolean;
};

type PinResponse = {
  IpfsHash: string;
  PinSize: number;
  Timestamp: string;
  isDuplicate?: boolean;
};

type RevokeKeyResponse = {
  key: string;
  status: string;
};

type SignatureOptions = {
  cid: string;
  signature: string;
};

type SignatureResponse = {
  cid: string;
  signature: string;
};

type SwapCidOptions = {
  cid: string;
  swapCid: string;
};

type SwapCidResponse = {
  mappedCid: string;
  createdAt: string;
};

type SwapHistoryOptions = {
  cid: string;
  domain: string;
};

type TimeIntervalGatewayAnalyticsQuery = GatewayAnalyticsQuery & {
  sort_by?: "requests" | "bandwidth";
  date_interval: "day" | "week";
};

type TimeIntervalGatewayAnalyticsResponse = {
  total_requests: number;
  total_bandwidth: number;
  time_periods: TimePeriodItem[];
};

type TimePeriodItem = {
  period_start_time: string;
  requests: number;
  bandwidth: number;
};

type TopGatewayAnalyticsItem = {
  value: string;
  requests: number;
  bandwidth: number;
};

type TopGatewayAnalyticsQuery = GatewayAnalyticsQuery & {
  sort_by: "requests" | "bandwidth";
  attribute:
    | "cid"
    | "country"
    | "region"
    | "user_agent"
    | "referer"
    | "file_name";
};

type UnpinResponse = {
  hash: string;
  status: string;
};

type UpdateGroupOptions = {
  name: string;
  groupId: string;
};

type UploadCIDOptions = {
  metadata?: PinataMetadata;
  peerAddresses?: string[];
  keys?: string;
  groupId?: string;
};

type UploadOptions = {
  metadata?: PinataMetadata;
  pinType?: "async" | "sync" | "cidOnly";
  keys?: string;
  groupId?: string;
  cidVersion?: 0 | 1;
};

type UserPinnedDataResponse = {
  pin_count: number;
  pin_size_total: number;
  pin_size_with_replications_total: number;
};