declare enum ServiceTypes {
  AMAZON = 'amazon',
  AMAZON_MUSIC = 'amazonMusic',
  ANGHAMI = 'anghami',
  APPLE_MUSIC = 'appleMusic',
  AUDIOMACK = 'audiomack',
  AUDIUS = 'audius',
  AWA = 'awa',
  BANDCAMP = 'bandcamp',
  BANDSINTOWN = 'bandsintown',
  BEATPORT = 'beatport',
  BOOMPLAY = 'boomplay',
  DEEZER = 'deezer',
  DISCOGS = 'discogs',
  FACEBOOK = 'facebook',
  FLO = 'flo',
  GAANA = 'gaana',
  GENIUS = 'genius',
  IHEART_RADIO = 'iHeartRadio',
  IMDB = 'imdb',
  INSTAGRAM = 'instagram',
  ITUNES_STORE = 'itunesStore',
  JIO_SAAVN = 'jioSaavn',
  JOOX = 'joox',
  KKBOX = 'kkbox',
  LINE_MUSIC = 'lineMusic',
  MUSIC_BRAINZ = 'musicBrainz',
  NAPSTER = 'napster',
  NETEASE = 'netease',
  PANDORA = 'pandora',
  QOBUZ = 'qobuz',
  QQ_MUSIC = 'qqMusic',
  SEVEN_DIGITAL = 'sevenDigital',
  SHAZAM = 'shazam',
  SNAPCHAT = 'snapchat',
  SONGKICK = 'songkick',
  SOUNDCLOUD = 'soundcloud',
  SPOTIFY = 'spotify',
  TELMORE_MUSIK = 'telmoreMusik',
  THREADS = 'threads',
  TICKETMASTER = 'ticketmaster',
  TIDAL = 'tidal',
  TIKTOK = 'tiktok',
  TREBEL = 'trebel',
  TWITTER = 'x',
  WIKIPEDIA = 'wikipedia',
  YANDEX = 'yandex',
  YOUSEE_MUSIK = 'youseeMusik',
  YOUTUBE = 'youtube',
  YOUTUBE_MUSIC = 'youtubeMusic',
  YOUTUBE_SHORTS = 'youtubeShorts',

  /**
   * Deprecated Services
   * These services are retained in the list to prevent errors
   * when they are passed as parameters.
   */
  TIKTOK_MUSIC = 'tiktokMusic',
  RESSO = 'resso',
  WYNK_MUSIC = 'wynkMusic',
}

// enum to union - https://stackoverflow.com/a/52396706/516629
type ServiceType$1 = `${ServiceTypes}`;

interface LookupUrlApiRequestParams {
  url: string;
  country?: string;
  services?: string;
  withTracks?: 'true' | 'false';
  withAllLinks?: 'true' | 'false';
  withPerformance?: 'true' | 'false';
}

interface LookupHealthResult {
  [key: string]:
    | {
        status: 'ok';
        performance: number;
      }
    | {
        status: 'error';
        performance: number;
        error: string;
      }
    | {
        status: 'unknown';
      };
}

type ItemGenres = string[];

declare enum ItemTypes {
  ARTIST = 'artist',
  ALBUM = 'album',
  TRACK = 'track',
  VIDEO = 'video',
}

interface Geolocation {
  latitude: number;
  longitude: number;
}

interface Link {
  url: string;
  countries?: string[];
}

interface Image {
  url: string;
  width?: number;
  height?: number;
  dominantColor?: string;
}

type BaseSerialized = {
  id?: string;

  service: ServiceTypes;

  name?: string;
  originalName?: string;

  // not required as not all services have country specific content/links
  country?: string;

  images?: Image[];
  links?: Link[];
  type: unknown;
  link?: string;
};

interface SerializedTrack extends BaseSerialized {
  type: ItemTypes.TRACK;
  artists?: SerializedArtist[];
  albums?: SerializedAlbum[];
  previewUrl?: string;
  duration?: number;
  isExplicit?: boolean;
  isrc?: string;
  label?: string;
  cLine?: string;
  pLine?: string
}

type TrackLyrics = { text: string }[];

interface SerializedVideo extends BaseSerialized {
  type: ItemTypes.VIDEO;
  channelTitle?: string;
  releaseDate?: Date;
  aspect: number | undefined;
  isEmbeddable?: boolean;
  description?: string;
  tracks?: SerializedTrack[];
}

interface SerializedAlbum extends BaseSerialized {
  type: ItemTypes.ALBUM;
  name: string;
  artists?: SerializedArtist[];
  tracks?: (SerializedTrack | SerializedVideo)[];
  children?: SerializedChildAlbum[];
  isSingle?: boolean;
  description?: string;
  releaseDate?: Date | string;
  totalTracks?: number;
  upc?: string;
  isExplicit?: boolean;
}

type SerializedChildAlbum = Pick<
  SerializedAlbum,
  'type' | 'service' | 'id' | 'images' | 'links' | 'link'
>;

interface SerializedArtist extends BaseSerialized {
  type: ItemTypes.ARTIST;
  name: string;
  dateOfBirth?: string;
  dateOfDeath?: string;
  hometown?: string;
  description?: string;
  genres?: ItemGenres;
  albums?: SerializedAlbum[];
  children?: SerializedChildArtist[];
  shows?: ArtistShow[];
}

type SerializedChildArtist = Pick<
  SerializedArtist,
  'type' | 'id' | 'images' | 'links' | 'link'
> & {
  service: ServiceTypes;
};

interface ArtistShow {
  name: string;
  venueName: string;
  url: string;

  // YYYY-MM-DD
  localDate: string;

  // HH:mm:ss
  // Optional because some shows don't have a start time,
  // in the case of festival tickets for example
  localTime?: string;

  geolocation?: Geolocation;
}

type ItemServices<
  TOptions extends { withAllLinks?: boolean } = { withAllLinks: false }
> = {
  [K in ServiceType$1]?: {
    id?: string;
    service?: ServiceTypes;
  } & (TOptions['withAllLinks'] extends true
    ? {
        links: {
          url: string;
          countries?: string[];
        }[];
      }
    : {
        link: string;
      });
};

type ReducedTrack<
  TOptions extends { withAllLinks?: boolean } = { withAllLinks: false }
> = {
  type: 'track';
  name: string;
  artists?: ReducedArtist<TOptions>[];
  image?: Image;
  images?: Image[];
  duration?: number;
  isrc?: string;
  isExplicit?: boolean;
  previewUrl?: string;
  releaseDate: string | undefined;
  lyrics?: TrackLyrics;
  services?: ItemServices<TOptions>;
  albums?: ReducedAlbum<TOptions>[];
  label?: string;
  copyright?: string;
  distributor?: string;
};

type ReducedAlbum<
  TOptions extends { withAllLinks?: boolean } = { withAllLinks: false }
> = Pick<
  SerializedAlbum,
  'name' | 'releaseDate' | 'upc' | 'isExplicit' | 'description' | 'totalTracks'
> & {
  type: 'album';
  artists?: ReducedArtist<TOptions>[];
  image?: Image;
  images?: Image[];
  previewUrl?: string;
  releaseDate?: string;
  services?: ItemServices<TOptions>;
  tracks?: ReducedTrack<TOptions>[];
  label?: string;
  copyright?: string;
};

type ReduceArtistOptions = { withAllLinks?: boolean };

type ReducedArtist<
  TOptions extends ReduceArtistOptions = { withAllLinks: false }
> = Pick<SerializedArtist, 'name' | 'description'> & {
  type: 'artist';
  image?: Image;
  previewUrl?: string;
  releaseDate?: string;
  services?: ItemServices<TOptions>;
  dateOfBirth?: string;
  dateOfDeath?: string;
  hometown?: string;
  albums?: ReducedAlbum<TOptions>[];
  shows?: ArtistShow[];

  videos?: {
    service: ServiceType$1;
    id: string;
    link: string;
    image?: Image;
  }[];
};

/* eslint-disable @typescript-eslint/ban-types */


// force TS to use new naming
type MusicfetchArtist<TOptions extends ReduceArtistOptions = {}> =
  ReducedArtist<TOptions> & { _?: never };

type MusicfetchAlbum<TOptions extends ReduceAlbumOptions = {}> =
  ReducedAlbum<TOptions> & { _?: never };

type MusicfetchTrack<TOptions extends ReduceTrackOptions = {}> =
  ReducedTrack<TOptions> & { _?: never };

type MusicfetchItem<TOptions extends ReduceArtistOptions = {}> =
  | MusicfetchArtist<TOptions>
  | MusicfetchAlbum<TOptions>
  | MusicfetchTrack<TOptions>;

type MusicfetchLookupResult<
  TResult = MusicfetchTrack | MusicfetchAlbum | MusicfetchArtist
> = {
  result: TResult;
  performance?: Record<string, number>;
};

type MusicfetchLookupStreamResult<
  TResult = MusicfetchTrack | MusicfetchAlbum | MusicfetchArtist
> = {
  result: TResult;
  statuses: Record<
    ServiceType,
    {
      status: 'done' | 'error' | 'pending' | 'no-result';
      duration?: number;
      message?: string;
    }
  >;
};

type MusicfetchLookupArtistResult =
  MusicfetchLookupResult<MusicfetchArtist>;

type MusicfetchLookupAlbumUResult =
  MusicfetchLookupResult<MusicfetchAlbum>;

type MusicfetchLookupTrackResult =
  MusicfetchLookupResult<MusicfetchTrack>;

declare type Primitive = string | number | symbol | bigint | boolean | null | undefined;

declare namespace util {
    type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
    export type isAny<T> = 0 extends 1 & T ? true : false;
    export const assertEqual: <A, B>(val: AssertEqual<A, B>) => AssertEqual<A, B>;
    export function assertIs<T>(_arg: T): void;
    export function assertNever(_x: never): never;
    export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
    export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
    export type MakePartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
    export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
    export const arrayToEnum: <T extends string, U extends [T, ...T[]]>(items: U) => { [k in U[number]]: k; };
    export const getValidEnumValues: (obj: any) => any[];
    export const objectValues: (obj: any) => any[];
    export const objectKeys: ObjectConstructor["keys"];
    export const find: <T>(arr: T[], checker: (arg: T) => any) => T | undefined;
    export type identity<T> = objectUtil.identity<T>;
    export type flatten<T> = objectUtil.flatten<T>;
    export type noUndefined<T> = T extends undefined ? never : T;
    export const isInteger: NumberConstructor["isInteger"];
    export function joinValues<T extends any[]>(array: T, separator?: string): string;
    export const jsonStringifyReplacer: (_: string, value: any) => any;
    export {  };
}
declare namespace objectUtil {
    export type MergeShapes<U, V> = {
        [k in Exclude<keyof U, keyof V>]: U[k];
    } & V;
    type optionalKeys<T extends object> = {
        [k in keyof T]: undefined extends T[k] ? k : never;
    }[keyof T];
    type requiredKeys<T extends object> = {
        [k in keyof T]: undefined extends T[k] ? never : k;
    }[keyof T];
    export type addQuestionMarks<T extends object, _O = any> = {
        [K in requiredKeys<T>]: T[K];
    } & {
        [K in optionalKeys<T>]?: T[K];
    } & {
        [k in keyof T]?: unknown;
    };
    export type identity<T> = T;
    export type flatten<T> = identity<{
        [k in keyof T]: T[k];
    }>;
    export type noNeverKeys<T> = {
        [k in keyof T]: [T[k]] extends [never] ? never : k;
    }[keyof T];
    export type noNever<T> = identity<{
        [k in noNeverKeys<T>]: k extends keyof T ? T[k] : never;
    }>;
    export const mergeShapes: <U, T>(first: U, second: T) => T & U;
    export type extendShape<A extends object, B extends object> = {
        [K in keyof A as K extends keyof B ? never : K]: A[K];
    } & {
        [K in keyof B]: B[K];
    };
    export {  };
}
declare const ZodParsedType: {
    function: "function";
    number: "number";
    string: "string";
    nan: "nan";
    integer: "integer";
    float: "float";
    boolean: "boolean";
    date: "date";
    bigint: "bigint";
    symbol: "symbol";
    undefined: "undefined";
    null: "null";
    array: "array";
    object: "object";
    unknown: "unknown";
    promise: "promise";
    void: "void";
    never: "never";
    map: "map";
    set: "set";
};
declare type ZodParsedType = keyof typeof ZodParsedType;

declare type allKeys<T> = T extends any ? keyof T : never;
declare type typeToFlattenedError<T, U = string> = {
    formErrors: U[];
    fieldErrors: {
        [P in allKeys<T>]?: U[];
    };
};
declare const ZodIssueCode: {
    invalid_type: "invalid_type";
    invalid_literal: "invalid_literal";
    custom: "custom";
    invalid_union: "invalid_union";
    invalid_union_discriminator: "invalid_union_discriminator";
    invalid_enum_value: "invalid_enum_value";
    unrecognized_keys: "unrecognized_keys";
    invalid_arguments: "invalid_arguments";
    invalid_return_type: "invalid_return_type";
    invalid_date: "invalid_date";
    invalid_string: "invalid_string";
    too_small: "too_small";
    too_big: "too_big";
    invalid_intersection_types: "invalid_intersection_types";
    not_multiple_of: "not_multiple_of";
    not_finite: "not_finite";
};
declare type ZodIssueCode = keyof typeof ZodIssueCode;
declare type ZodIssueBase = {
    path: (string | number)[];
    message?: string;
};
interface ZodInvalidTypeIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.invalid_type;
    expected: ZodParsedType;
    received: ZodParsedType;
}
interface ZodInvalidLiteralIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.invalid_literal;
    expected: unknown;
    received: unknown;
}
interface ZodUnrecognizedKeysIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.unrecognized_keys;
    keys: string[];
}
interface ZodInvalidUnionIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.invalid_union;
    unionErrors: ZodError[];
}
interface ZodInvalidUnionDiscriminatorIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.invalid_union_discriminator;
    options: Primitive[];
}
interface ZodInvalidEnumValueIssue extends ZodIssueBase {
    received: string | number;
    code: typeof ZodIssueCode.invalid_enum_value;
    options: (string | number)[];
}
interface ZodInvalidArgumentsIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.invalid_arguments;
    argumentsError: ZodError;
}
interface ZodInvalidReturnTypeIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.invalid_return_type;
    returnTypeError: ZodError;
}
interface ZodInvalidDateIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.invalid_date;
}
declare type StringValidation = "email" | "url" | "emoji" | "uuid" | "nanoid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "date" | "time" | "duration" | "ip" | "base64" | {
    includes: string;
    position?: number;
} | {
    startsWith: string;
} | {
    endsWith: string;
};
interface ZodInvalidStringIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.invalid_string;
    validation: StringValidation;
}
interface ZodTooSmallIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.too_small;
    minimum: number | bigint;
    inclusive: boolean;
    exact?: boolean;
    type: "array" | "string" | "number" | "set" | "date" | "bigint";
}
interface ZodTooBigIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.too_big;
    maximum: number | bigint;
    inclusive: boolean;
    exact?: boolean;
    type: "array" | "string" | "number" | "set" | "date" | "bigint";
}
interface ZodInvalidIntersectionTypesIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.invalid_intersection_types;
}
interface ZodNotMultipleOfIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.not_multiple_of;
    multipleOf: number | bigint;
}
interface ZodNotFiniteIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.not_finite;
}
interface ZodCustomIssue extends ZodIssueBase {
    code: typeof ZodIssueCode.custom;
    params?: {
        [k: string]: any;
    };
}
declare type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;
declare type ZodIssue = ZodIssueOptionalMessage & {
    fatal?: boolean;
    message: string;
};
declare type recursiveZodFormattedError<T> = T extends [any, ...any[]] ? {
    [K in keyof T]?: ZodFormattedError<T[K]>;
} : T extends any[] ? {
    [k: number]: ZodFormattedError<T[number]>;
} : T extends object ? {
    [K in keyof T]?: ZodFormattedError<T[K]>;
} : unknown;
declare type ZodFormattedError<T, U = string> = {
    _errors: U[];
} & recursiveZodFormattedError<NonNullable<T>>;
declare class ZodError<T = any> extends Error {
    issues: ZodIssue[];
    get errors(): ZodIssue[];
    constructor(issues: ZodIssue[]);
    format(): ZodFormattedError<T>;
    format<U>(mapper: (issue: ZodIssue) => U): ZodFormattedError<T, U>;
    static create: (issues: ZodIssue[]) => ZodError<any>;
    static assert(value: unknown): asserts value is ZodError;
    toString(): string;
    get message(): string;
    get isEmpty(): boolean;
    addIssue: (sub: ZodIssue) => void;
    addIssues: (subs?: ZodIssue[]) => void;
    flatten(): typeToFlattenedError<T>;
    flatten<U>(mapper?: (issue: ZodIssue) => U): typeToFlattenedError<T, U>;
    get formErrors(): typeToFlattenedError<T, string>;
}
declare type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;
declare type IssueData = stripPath<ZodIssueOptionalMessage> & {
    path?: (string | number)[];
    fatal?: boolean;
};
declare type ErrorMapCtx = {
    defaultError: string;
    data: any;
};
declare type ZodErrorMap = (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
    message: string;
};

declare type ParseParams = {
    path: (string | number)[];
    errorMap: ZodErrorMap;
    async: boolean;
};
declare type ParsePathComponent = string | number;
declare type ParsePath = ParsePathComponent[];
interface ParseContext {
    readonly common: {
        readonly issues: ZodIssue[];
        readonly contextualErrorMap?: ZodErrorMap;
        readonly async: boolean;
    };
    readonly path: ParsePath;
    readonly schemaErrorMap?: ZodErrorMap;
    readonly parent: ParseContext | null;
    readonly data: any;
    readonly parsedType: ZodParsedType;
}
declare type ParseInput = {
    data: any;
    path: (string | number)[];
    parent: ParseContext;
};
declare class ParseStatus {
    value: "aborted" | "dirty" | "valid";
    dirty(): void;
    abort(): void;
    static mergeArray(status: ParseStatus, results: SyncParseReturnType<any>[]): SyncParseReturnType;
    static mergeObjectAsync(status: ParseStatus, pairs: {
        key: ParseReturnType<any>;
        value: ParseReturnType<any>;
    }[]): Promise<SyncParseReturnType<any>>;
    static mergeObjectSync(status: ParseStatus, pairs: {
        key: SyncParseReturnType<any>;
        value: SyncParseReturnType<any>;
        alwaysSet?: boolean;
    }[]): SyncParseReturnType;
}
declare type INVALID = {
    status: "aborted";
};
declare const INVALID: INVALID;
declare type DIRTY<T> = {
    status: "dirty";
    value: T;
};
declare const DIRTY: <T>(value: T) => DIRTY<T>;
declare type OK<T> = {
    status: "valid";
    value: T;
};
declare const OK: <T>(value: T) => OK<T>;
declare type SyncParseReturnType<T = any> = OK<T> | DIRTY<T> | INVALID;
declare type AsyncParseReturnType<T> = Promise<SyncParseReturnType<T>>;
declare type ParseReturnType<T> = SyncParseReturnType<T> | AsyncParseReturnType<T>;

declare namespace errorUtil {
    type ErrMessage = string | {
        message?: string;
    };
    const errToObj: (message?: ErrMessage | undefined) => {
        message?: string | undefined;
    };
    const toString: (message?: ErrMessage | undefined) => string | undefined;
}

interface RefinementCtx {
    addIssue: (arg: IssueData) => void;
    path: (string | number)[];
}
declare type ZodTypeAny = ZodType<any, any, any>;
declare type TypeOf<T extends ZodType<any, any, any>> = T["_output"];
declare type input<T extends ZodType<any, any, any>> = T["_input"];
declare type output<T extends ZodType<any, any, any>> = T["_output"];

declare type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, "code">>;
interface ZodTypeDef {
    errorMap?: ZodErrorMap;
    description?: string;
}
declare type RawCreateParams = {
    errorMap?: ZodErrorMap;
    invalid_type_error?: string;
    required_error?: string;
    message?: string;
    description?: string;
} | undefined;
declare type SafeParseSuccess<Output> = {
    success: true;
    data: Output;
    error?: never;
};
declare type SafeParseError<Input> = {
    success: false;
    error: ZodError<Input>;
    data?: never;
};
declare type SafeParseReturnType<Input, Output> = SafeParseSuccess<Output> | SafeParseError<Input>;
declare abstract class ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> {
    readonly _type: Output;
    readonly _output: Output;
    readonly _input: Input;
    readonly _def: Def;
    get description(): string | undefined;
    abstract _parse(input: ParseInput): ParseReturnType<Output>;
    _getType(input: ParseInput): string;
    _getOrReturnCtx(input: ParseInput, ctx?: ParseContext | undefined): ParseContext;
    _processInputParams(input: ParseInput): {
        status: ParseStatus;
        ctx: ParseContext;
    };
    _parseSync(input: ParseInput): SyncParseReturnType<Output>;
    _parseAsync(input: ParseInput): AsyncParseReturnType<Output>;
    parse(data: unknown, params?: Partial<ParseParams>): Output;
    safeParse(data: unknown, params?: Partial<ParseParams>): SafeParseReturnType<Input, Output>;
    parseAsync(data: unknown, params?: Partial<ParseParams>): Promise<Output>;
    safeParseAsync(data: unknown, params?: Partial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
    /** Alias of safeParseAsync */
    spa: (data: unknown, params?: Partial<ParseParams> | undefined) => Promise<SafeParseReturnType<Input, Output>>;
    refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, RefinedOutput, Input>;
    refine(check: (arg: Output) => unknown | Promise<unknown>, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, Output, Input>;
    refinement<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, RefinedOutput, Input>;
    refinement(check: (arg: Output) => boolean, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, Output, Input>;
    _refinement(refinement: RefinementEffect<Output>["refinement"]): ZodEffects<this, Output, Input>;
    superRefine<RefinedOutput extends Output>(refinement: (arg: Output, ctx: RefinementCtx) => arg is RefinedOutput): ZodEffects<this, RefinedOutput, Input>;
    superRefine(refinement: (arg: Output, ctx: RefinementCtx) => void): ZodEffects<this, Output, Input>;
    superRefine(refinement: (arg: Output, ctx: RefinementCtx) => Promise<void>): ZodEffects<this, Output, Input>;
    constructor(def: Def);
    optional(): ZodOptional<this>;
    nullable(): ZodNullable<this>;
    nullish(): ZodOptional<ZodNullable<this>>;
    array(): ZodArray<this>;
    promise(): ZodPromise<this>;
    or<T extends ZodTypeAny>(option: T): ZodUnion<[this, T]>;
    and<T extends ZodTypeAny>(incoming: T): ZodIntersection<this, T>;
    transform<NewOut>(transform: (arg: Output, ctx: RefinementCtx) => NewOut | Promise<NewOut>): ZodEffects<this, NewOut>;
    default(def: util.noUndefined<Input>): ZodDefault<this>;
    default(def: () => util.noUndefined<Input>): ZodDefault<this>;
    brand<B extends string | number | symbol>(brand?: B): ZodBranded<this, B>;
    catch(def: Output): ZodCatch<this>;
    catch(def: (ctx: {
        error: ZodError;
        input: Input;
    }) => Output): ZodCatch<this>;
    describe(description: string): this;
    pipe<T extends ZodTypeAny>(target: T): ZodPipeline<this, T>;
    readonly(): ZodReadonly<this>;
    isOptional(): boolean;
    isNullable(): boolean;
}
interface ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
    type: T;
    typeName: ZodFirstPartyTypeKind.ZodArray;
    exactLength: {
        value: number;
        message?: string;
    } | null;
    minLength: {
        value: number;
        message?: string;
    } | null;
    maxLength: {
        value: number;
        message?: string;
    } | null;
}
declare type ArrayCardinality = "many" | "atleastone";
declare type arrayOutputType<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> = Cardinality extends "atleastone" ? [T["_output"], ...T["_output"][]] : T["_output"][];
declare class ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> extends ZodType<arrayOutputType<T, Cardinality>, ZodArrayDef<T>, Cardinality extends "atleastone" ? [T["_input"], ...T["_input"][]] : T["_input"][]> {
    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
    get element(): T;
    min(minLength: number, message?: errorUtil.ErrMessage): this;
    max(maxLength: number, message?: errorUtil.ErrMessage): this;
    length(len: number, message?: errorUtil.ErrMessage): this;
    nonempty(message?: errorUtil.ErrMessage): ZodArray<T, "atleastone">;
    static create: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodArray<T_1, "many">;
}
declare type ZodUnionOptions = Readonly<[ZodTypeAny, ...ZodTypeAny[]]>;
interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[
    ZodTypeAny,
    ZodTypeAny,
    ...ZodTypeAny[]
]>> extends ZodTypeDef {
    options: T;
    typeName: ZodFirstPartyTypeKind.ZodUnion;
}
declare class ZodUnion<T extends ZodUnionOptions> extends ZodType<T[number]["_output"], ZodUnionDef<T>, T[number]["_input"]> {
    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
    get options(): T;
    static create: <T_1 extends readonly [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(types: T_1, params?: RawCreateParams) => ZodUnion<T_1>;
}
interface ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
    left: T;
    right: U;
    typeName: ZodFirstPartyTypeKind.ZodIntersection;
}
declare class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> extends ZodType<T["_output"] & U["_output"], ZodIntersectionDef<T, U>, T["_input"] & U["_input"]> {
    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
    static create: <T_1 extends ZodTypeAny, U_1 extends ZodTypeAny>(left: T_1, right: U_1, params?: RawCreateParams) => ZodIntersection<T_1, U_1>;
}
interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
    type: T;
    typeName: ZodFirstPartyTypeKind.ZodPromise;
}
declare class ZodPromise<T extends ZodTypeAny> extends ZodType<Promise<T["_output"]>, ZodPromiseDef<T>, Promise<T["_input"]>> {
    unwrap(): T;
    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
    static create: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodPromise<T_1>;
}
declare type RefinementEffect<T> = {
    type: "refinement";
    refinement: (arg: T, ctx: RefinementCtx) => any;
};
declare type TransformEffect<T> = {
    type: "transform";
    transform: (arg: T, ctx: RefinementCtx) => any;
};
declare type PreprocessEffect<T> = {
    type: "preprocess";
    transform: (arg: T, ctx: RefinementCtx) => any;
};
declare type Effect<T> = RefinementEffect<T> | TransformEffect<T> | PreprocessEffect<T>;
interface ZodEffectsDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
    schema: T;
    typeName: ZodFirstPartyTypeKind.ZodEffects;
    effect: Effect<any>;
}
declare class ZodEffects<T extends ZodTypeAny, Output = output<T>, Input = input<T>> extends ZodType<Output, ZodEffectsDef<T>, Input> {
    innerType(): T;
    sourceType(): T;
    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
    static create: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"], input<I>>;
    static createWithPreprocess: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: RefinementCtx) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
}

interface ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
    innerType: T;
    typeName: ZodFirstPartyTypeKind.ZodOptional;
}
declare class ZodOptional<T extends ZodTypeAny> extends ZodType<T["_output"] | undefined, ZodOptionalDef<T>, T["_input"] | undefined> {
    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
    unwrap(): T;
    static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodOptional<T_1>;
}
interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
    innerType: T;
    typeName: ZodFirstPartyTypeKind.ZodNullable;
}
declare class ZodNullable<T extends ZodTypeAny> extends ZodType<T["_output"] | null, ZodNullableDef<T>, T["_input"] | null> {
    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
    unwrap(): T;
    static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodNullable<T_1>;
}
interface ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
    innerType: T;
    defaultValue: () => util.noUndefined<T["_input"]>;
    typeName: ZodFirstPartyTypeKind.ZodDefault;
}
declare class ZodDefault<T extends ZodTypeAny> extends ZodType<util.noUndefined<T["_output"]>, ZodDefaultDef<T>, T["_input"] | undefined> {
    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
    removeDefault(): T;
    static create: <T_1 extends ZodTypeAny>(type: T_1, params: {
        errorMap?: ZodErrorMap | undefined;
        invalid_type_error?: string | undefined;
        required_error?: string | undefined;
        message?: string | undefined;
        description?: string | undefined;
    } & {
        default: T_1["_input"] | (() => util.noUndefined<T_1["_input"]>);
    }) => ZodDefault<T_1>;
}
interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
    innerType: T;
    catchValue: (ctx: {
        error: ZodError;
        input: unknown;
    }) => T["_input"];
    typeName: ZodFirstPartyTypeKind.ZodCatch;
}
declare class ZodCatch<T extends ZodTypeAny> extends ZodType<T["_output"], ZodCatchDef<T>, unknown> {
    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
    removeCatch(): T;
    static create: <T_1 extends ZodTypeAny>(type: T_1, params: {
        errorMap?: ZodErrorMap | undefined;
        invalid_type_error?: string | undefined;
        required_error?: string | undefined;
        message?: string | undefined;
        description?: string | undefined;
    } & {
        catch: T_1["_output"] | (() => T_1["_output"]);
    }) => ZodCatch<T_1>;
}
interface ZodBrandedDef<T extends ZodTypeAny> extends ZodTypeDef {
    type: T;
    typeName: ZodFirstPartyTypeKind.ZodBranded;
}
declare const BRAND: unique symbol;
declare type BRAND<T extends string | number | symbol> = {
    [BRAND]: {
        [k in T]: true;
    };
};
declare class ZodBranded<T extends ZodTypeAny, B extends string | number | symbol> extends ZodType<T["_output"] & BRAND<B>, ZodBrandedDef<T>, T["_input"]> {
    _parse(input: ParseInput): ParseReturnType<any>;
    unwrap(): T;
}
interface ZodPipelineDef<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodTypeDef {
    in: A;
    out: B;
    typeName: ZodFirstPartyTypeKind.ZodPipeline;
}
declare class ZodPipeline<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodType<B["_output"], ZodPipelineDef<A, B>, A["_input"]> {
    _parse(input: ParseInput): ParseReturnType<any>;
    static create<A extends ZodTypeAny, B extends ZodTypeAny>(a: A, b: B): ZodPipeline<A, B>;
}
declare type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
    readonly [Symbol.toStringTag]: string;
} | Date | Error | Generator | Promise<unknown> | RegExp;
declare type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;
interface ZodReadonlyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
    innerType: T;
    typeName: ZodFirstPartyTypeKind.ZodReadonly;
}
declare class ZodReadonly<T extends ZodTypeAny> extends ZodType<MakeReadonly<T["_output"]>, ZodReadonlyDef<T>, MakeReadonly<T["_input"]>> {
    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
    static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodReadonly<T_1>;
    unwrap(): T;
}
declare enum ZodFirstPartyTypeKind {
    ZodString = "ZodString",
    ZodNumber = "ZodNumber",
    ZodNaN = "ZodNaN",
    ZodBigInt = "ZodBigInt",
    ZodBoolean = "ZodBoolean",
    ZodDate = "ZodDate",
    ZodSymbol = "ZodSymbol",
    ZodUndefined = "ZodUndefined",
    ZodNull = "ZodNull",
    ZodAny = "ZodAny",
    ZodUnknown = "ZodUnknown",
    ZodNever = "ZodNever",
    ZodVoid = "ZodVoid",
    ZodArray = "ZodArray",
    ZodObject = "ZodObject",
    ZodUnion = "ZodUnion",
    ZodDiscriminatedUnion = "ZodDiscriminatedUnion",
    ZodIntersection = "ZodIntersection",
    ZodTuple = "ZodTuple",
    ZodRecord = "ZodRecord",
    ZodMap = "ZodMap",
    ZodSet = "ZodSet",
    ZodFunction = "ZodFunction",
    ZodLazy = "ZodLazy",
    ZodLiteral = "ZodLiteral",
    ZodEnum = "ZodEnum",
    ZodEffects = "ZodEffects",
    ZodNativeEnum = "ZodNativeEnum",
    ZodOptional = "ZodOptional",
    ZodNullable = "ZodNullable",
    ZodDefault = "ZodDefault",
    ZodCatch = "ZodCatch",
    ZodPromise = "ZodPromise",
    ZodBranded = "ZodBranded",
    ZodPipeline = "ZodPipeline",
    ZodReadonly = "ZodReadonly"
}

type Optional<T, K extends keyof T> = Omit<T, K> & Partial<T>;

interface CachedItemRecord {
  id: string;
  keys: string[];

  /**
   * ISO date string
   */
  createdAt: string;

  /**
   * ISO date string
   */
  refreshedAt: string;

  /**
   * ISO date string
   */
  updatedAt: string;

  fetchedServices: {
    [country: string]: ServiceType$1[];
  };

  source: {
    url: string;
    country: string;
    // isrc?: string;
    // upc?: string;
  };

  data:
    | MusicfetchArtist<{ withAllLinks: true }>
    | MusicfetchAlbum<{ withAllLinks: true }>
    | MusicfetchTrack<{ withAllLinks: true }>;
}

type SerializedCachedItem = Optional<
  CachedItemRecord,
  'keys' | 'createdAt' | 'updatedAt' | 'refreshedAt'
>;

type MusicfetchOpenArtist = Omit<
  MusicfetchArtist,
  'artists' | 'services' | 'albums'
> & {
  id: string;

  services: Record<
    ServiceType$1,
    {
      link: string;
    }
  >;
};

type MusicfetchOpenTrack = Omit<
  MusicfetchTrack,
  'artists' | 'services'
> & {
  id: string;

  services: Record<
    ServiceType$1,
    {
      link: string;
    }
  >;

  artists?: Omit<NonNullable<MusicfetchTrack['artists']>[0], 'services'>[];
  albums?: Omit<NonNullable<MusicfetchTrack['albums']>[0], 'services'>[];
};

type MusicfetchOpenAlbum = Omit<
  MusicfetchAlbum,
  'artists' | 'tracks'
> & {
  id: string;

  services: Record<
    ServiceType$1,
    {
      link: string;
    }
  >;

  artists?: Omit<NonNullable<MusicfetchTrack['artists']>[0], 'services'>[];
  tracks?: Omit<NonNullable<MusicfetchAlbum['tracks']>[0], 'services'>[];
};

type MusicfetchOpenItem =
  | MusicfetchOpenArtist
  | MusicfetchOpenTrack
  | MusicfetchOpenAlbum;

declare const putOpenUrlParamsSchema = z.object({
  url: z.string().url(),
  country: z.string().optional(),

  services: z.string().transform((val) => {
    const values = val.split(',').filter(isTruthy);
    return lookupUrlParamsSchema.shape.services.parse(values);
  }),
});

type PutOpenUrlParams = TypeOf<typeof putOpenUrlParamsSchema>;

type GetOpenUrlResult = {
  result: MusicfetchOpenItem;
};

type GetCacheUrlResult<TOptions extends { asRaw: boolean }> = {
  result: TOptions['asRaw'] extends true
    ? SerializedCachedItem
    : MusicfetchItem;
};

export { type GetCacheUrlResult, type GetOpenUrlResult, type LookupHealthResult, type LookupUrlApiRequestParams, type MusicfetchAlbum, type MusicfetchArtist, type MusicfetchItem, type MusicfetchLookupAlbumUResult, type MusicfetchLookupArtistResult, type MusicfetchLookupResult, type MusicfetchLookupStreamResult, type MusicfetchLookupTrackResult, type MusicfetchOpenItem, type MusicfetchTrack, type PutOpenUrlParams, type ServiceType$1 as ServiceType, ServiceTypes, putOpenUrlParamsSchema };