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 DataEndpoints = {
  pinList?: boolean;
  userPinnedDataTotal?: boolean;
};

type DeleteResponse = {
  id: string;
  status: string;
};

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

type FileListItem = {
  id: string;
  name: string | null;
  cid: "pending" | string;
  size: number;
  number_of_files: number;
  mime_type: string;
  group_id: string | null;
  created_at: string;
};

type FileListQuery = {
  limit?: number;
  pageToken?: string;
  cidPending?: boolean;
};

type FileListResponse = {
  files: FileListItem[];
  next_page_token: string;
};

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 GroupListResponse = {
  groups: GroupResponseItem[];
  next_page_token: string;
};

type GroupOptions = {
  name: string;
  isPublic?: boolean;
};

type GroupQueryOptions = {
  nameContains?: string;
  limit?: number;
  pageToken?: string;
  isPublic?: boolean;
};

type GroupResponseItem = {
  id: string;
  is_public: boolean;
  name: 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 PinataConfig = {
  pinataJwt: string | undefined;
  pinataGateway?: string;
  pinataGatewayKey?: string;
  customHeaders?: Record<string, string>;
  endpointUrl?: string;
  uploadUrl?: string;
};

type PinataMetadata = {
  name?: string;
};

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

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

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

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

type SignedUrlOptions = {
  cid: string;
  date?: number;
  expires: number;
};

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 UpdateFileOptions = {
  id: string;
  name?: string;
};

type UpdateGroupOptions = {
  groupId: string;
  name?: string;
  isPublic?: boolean;
};

type UploadOptions = {
  metadata?: PinataMetadata;
  keys?: string;
  groupId?: string;
};

type UploadResponse = {
  id: string;
  name: string;
  cid: string;
  size: number;
  created_at: string;
  number_of_files: number;
  mime_type: string;
  user_id: string;
  group_id: string | null;
  is_duplicate: boolean | null;
};

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