@wayke-se/components-react 3.0.0-beta.7 → 3.0.0-beta.9

package/dist-types/@types/codegen/types.d.ts

@@ -0,0 +1,343 @@
+export declare type Maybe<T> = T | null;
+export declare type InputMaybe<T> = Maybe<T>;
+export declare type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export declare type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export declare type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export declare type Scalars = {
+    ID: string;
+    String: string;
+    Boolean: boolean;
+    Int: number;
+    Float: number;
+    DateTime: Date;
+    Email: string;
+    FileDocument: {
+        contentType: string;
+        name: string;
+        url: string;
+    };
+    PersonalNumber: string;
+    PhoneNumber: string;
+    Time: string;
+    URL: string;
+    VehicleDataPropertyMap: {
+        [key: string]: string | number | boolean;
+    };
+    VehicleDataPropertySet: any;
+};
+export declare type Branch = {
+    __typename?: 'Branch';
+    connections: Array<BranchConnection>;
+    contact?: Maybe<ContactOptions>;
+    description?: Maybe<Scalars['String']>;
+    flags?: Maybe<BranchFlags>;
+    homepage?: Maybe<Scalars['URL']>;
+    id: Scalars['ID'];
+    location?: Maybe<Location>;
+    logotype?: Maybe<Scalars['URL']>;
+    name?: Maybe<Scalars['String']>;
+    openingHours?: Maybe<OpeningHours>;
+    organization?: Maybe<Organization>;
+    promos: Array<Promo>;
+    services: Array<Service>;
+};
+export declare type BranchConnection = {
+    __typename?: 'BranchConnection';
+    id: Scalars['ID'];
+    location?: Maybe<Location>;
+    name?: Maybe<Scalars['String']>;
+};
+export declare type BranchFlags = {
+    __typename?: 'BranchFlags';
+    centralStorage?: Maybe<Scalars['Boolean']>;
+    ecommerce?: Maybe<Scalars['Boolean']>;
+    mrf?: Maybe<Scalars['Boolean']>;
+};
+export declare type ContactOptions = {
+    __typename?: 'ContactOptions';
+    avatar?: Maybe<Scalars['URL']>;
+    email?: Maybe<Scalars['Email']>;
+    name?: Maybe<Scalars['String']>;
+    phonenumber?: Maybe<Scalars['PhoneNumber']>;
+};
+export declare enum DrivingDistance {
+    Between0And1000 = "BETWEEN0AND1000",
+    Between1000And1500 = "BETWEEN1000AND1500",
+    Between1500And2000 = "BETWEEN1500AND2000",
+    Between2000And2500 = "BETWEEN2000AND2500",
+    Over2500 = "OVER2500"
+}
+export declare type Ecommerce = {
+    __typename?: 'Ecommerce';
+    enabled?: Maybe<Scalars['Boolean']>;
+    reserved?: Maybe<Scalars['Boolean']>;
+    withHomeDelivery?: Maybe<Scalars['Boolean']>;
+    withTradeIn?: Maybe<Scalars['Boolean']>;
+};
+export declare type FinancialOption = {
+    __typename?: 'FinancialOption';
+    administrationFee?: Maybe<Scalars['Float']>;
+    description?: Maybe<Scalars['String']>;
+    downPayment?: Maybe<FinancialOptionDetail>;
+    duration?: Maybe<FinancialOptionDetail>;
+    effectiveInterest?: Maybe<Scalars['Float']>;
+    identifier?: Maybe<Scalars['String']>;
+    image?: Maybe<Scalars['URL']>;
+    includes: Array<FinancialOptionInclusion>;
+    interest?: Maybe<Scalars['Float']>;
+    link?: Maybe<Link>;
+    loanAmount?: Maybe<Scalars['Float']>;
+    logotype?: Maybe<Scalars['URL']>;
+    mileage?: Maybe<FinancialOptionDetail>;
+    monthlyCost?: Maybe<Scalars['Float']>;
+    name?: Maybe<Scalars['String']>;
+    residual?: Maybe<FinancialOptionDetail>;
+    setupFee?: Maybe<Scalars['Float']>;
+    terms?: Maybe<Scalars['URL']>;
+    totalCreditCost?: Maybe<Scalars['Float']>;
+    totalResidualValue?: Maybe<Scalars['Float']>;
+    type: Scalars['String'];
+    url?: Maybe<Scalars['URL']>;
+};
+export declare type FinancialOptionDetail = {
+    __typename?: 'FinancialOptionDetail';
+    current: Scalars['Float'];
+    default: Scalars['Float'];
+    max: Scalars['Float'];
+    min: Scalars['Float'];
+    step: Scalars['Float'];
+};
+export declare enum FinancialOptionInclusion {
+    IncludesInsurance = "INCLUDES_INSURANCE",
+    IncludesService = "INCLUDES_SERVICE",
+    IncludesWintertires = "INCLUDES_WINTERTIRES"
+}
+export declare type HoursOpen = {
+    __typename?: 'HoursOpen';
+    from?: Maybe<Scalars['Time']>;
+    until?: Maybe<Scalars['Time']>;
+};
+export declare type Insurance = {
+    __typename?: 'Insurance';
+    addons: Array<InsuranceAddon>;
+    description: Scalars['String'];
+    items: Array<InsuranceItem>;
+    legality?: Maybe<InsuranceLegality>;
+    logotype?: Maybe<Scalars['URL']>;
+    name: Scalars['String'];
+    price: Scalars['Float'];
+    terms?: Maybe<Scalars['URL']>;
+    unit: Scalars['String'];
+    url?: Maybe<Scalars['URL']>;
+};
+export declare type InsuranceAddon = {
+    __typename?: 'InsuranceAddon';
+    description?: Maybe<Scalars['String']>;
+    exclusions: Array<Scalars['String']>;
+    id: Scalars['ID'];
+    price: Scalars['Float'];
+    title?: Maybe<Scalars['String']>;
+    unit: Scalars['String'];
+};
+export declare type InsuranceItem = {
+    __typename?: 'InsuranceItem';
+    description?: Maybe<Scalars['String']>;
+    name?: Maybe<Scalars['String']>;
+};
+export declare type InsuranceLegality = {
+    __typename?: 'InsuranceLegality';
+    description?: Maybe<Scalars['String']>;
+    url?: Maybe<Scalars['URL']>;
+};
+export declare type InsuranceOption = {
+    __typename?: 'InsuranceOption';
+    description?: Maybe<Scalars['String']>;
+    identifier?: Maybe<Scalars['String']>;
+    institute?: Maybe<Scalars['String']>;
+    insuranceHeader?: Maybe<Scalars['String']>;
+    insuranceText?: Maybe<Scalars['String']>;
+    logotype?: Maybe<Scalars['URL']>;
+    longDescription?: Maybe<Scalars['String']>;
+    name?: Maybe<Scalars['String']>;
+    requiresDistance?: Maybe<Scalars['Boolean']>;
+    requiresPersonalNumber?: Maybe<Scalars['Boolean']>;
+    /** @deprecated No longer supported */
+    terms?: Maybe<Scalars['URL']>;
+    url?: Maybe<Scalars['URL']>;
+};
+export declare type Link = {
+    __typename?: 'Link';
+    title?: Maybe<Scalars['String']>;
+    url?: Maybe<Scalars['URL']>;
+};
+export declare type Location = {
+    __typename?: 'Location';
+    city?: Maybe<Scalars['String']>;
+    county?: Maybe<Scalars['String']>;
+    position?: Maybe<Position>;
+    postalCode?: Maybe<Scalars['String']>;
+    streetAddress?: Maybe<Scalars['String']>;
+};
+export declare type Manufacturer = {
+    __typename?: 'Manufacturer';
+    description?: Maybe<Scalars['String']>;
+    logotype?: Maybe<Scalars['URL']>;
+    name: Scalars['String'];
+    packageOption?: Maybe<PackageOption>;
+};
+export declare type Media = {
+    __typename?: 'Media';
+    files: Array<MediaFile>;
+    type: Scalars['String'];
+};
+export declare type MediaFile = {
+    __typename?: 'MediaFile';
+    formats: Array<Maybe<MediaFileFormat>>;
+    url: Scalars['URL'];
+};
+export declare type MediaFileFormat = {
+    __typename?: 'MediaFileFormat';
+    format: Scalars['String'];
+    url: Scalars['URL'];
+};
+export declare type OpeningHours = {
+    __typename?: 'OpeningHours';
+    friday?: Maybe<HoursOpen>;
+    monday?: Maybe<HoursOpen>;
+    saturday?: Maybe<HoursOpen>;
+    sunday?: Maybe<HoursOpen>;
+    thursday?: Maybe<HoursOpen>;
+    tuesday?: Maybe<HoursOpen>;
+    wednesday?: Maybe<HoursOpen>;
+};
+export declare type Organization = {
+    __typename?: 'Organization';
+    branches: Array<Maybe<Branch>>;
+    contact?: Maybe<ContactOptions>;
+    description?: Maybe<Scalars['String']>;
+    flags?: Maybe<BranchFlags>;
+    homepage?: Maybe<Scalars['URL']>;
+    id: Scalars['ID'];
+    logotype?: Maybe<Scalars['URL']>;
+    name?: Maybe<Scalars['String']>;
+    parent?: Maybe<Branch>;
+};
+export declare type PackageOption = {
+    __typename?: 'PackageOption';
+    description?: Maybe<Scalars['String']>;
+    image?: Maybe<Scalars['URL']>;
+    link?: Maybe<Link>;
+    title?: Maybe<Scalars['String']>;
+};
+export declare type Position = {
+    __typename?: 'Position';
+    latitude?: Maybe<Scalars['Float']>;
+    longitude?: Maybe<Scalars['Float']>;
+};
+export declare type Promo = {
+    __typename?: 'Promo';
+    description?: Maybe<Scalars['String']>;
+    image?: Maybe<Scalars['URL']>;
+    link?: Maybe<Link>;
+    title?: Maybe<Scalars['String']>;
+};
+export declare type Query = {
+    __typename?: 'Query';
+    branch?: Maybe<Branch>;
+    insurances: Array<Insurance>;
+    loan?: Maybe<FinancialOption>;
+    vehicle?: Maybe<Vehicle>;
+};
+export declare type QueryBranchArgs = {
+    id: Scalars['ID'];
+};
+export declare type QueryInsurancesArgs = {
+    branch?: InputMaybe<Scalars['ID']>;
+    drivingDistance: DrivingDistance;
+    id: Scalars['ID'];
+    personalNumber: Scalars['PersonalNumber'];
+};
+export declare type QueryLoanArgs = {
+    branch?: InputMaybe<Scalars['ID']>;
+    downPayment: Scalars['Int'];
+    duration: Scalars['Int'];
+    id: Scalars['ID'];
+    residual: Scalars['Float'];
+};
+export declare type QueryVehicleArgs = {
+    branch?: InputMaybe<Scalars['ID']>;
+    id: Scalars['ID'];
+};
+export declare type SafetyOption = {
+    __typename?: 'SafetyOption';
+    content?: Maybe<Scalars['String']>;
+    image?: Maybe<Scalars['URL']>;
+    name?: Maybe<Scalars['String']>;
+    title?: Maybe<Scalars['String']>;
+};
+export declare type Service = {
+    __typename?: 'Service';
+    markdown?: Maybe<Scalars['String']>;
+    title?: Maybe<Scalars['String']>;
+};
+export declare type Vehicle = {
+    __typename?: 'Vehicle';
+    branch?: Maybe<Branch>;
+    contact?: Maybe<ContactOptions>;
+    data: VehicleData;
+    description?: Maybe<Scalars['String']>;
+    discount?: Maybe<Scalars['Float']>;
+    documents: Array<Scalars['FileDocument']>;
+    ecommerce?: Maybe<Ecommerce>;
+    financialOptions: Array<FinancialOption>;
+    flags?: Maybe<VehicleFlags>;
+    id: Scalars['ID'];
+    insuranceOptions: Array<InsuranceOption>;
+    location?: Maybe<Location>;
+    manufacturer?: Maybe<Manufacturer>;
+    media: Array<Media>;
+    packageOptions: Array<PackageOption>;
+    price: Scalars['Float'];
+    publishedAt?: Maybe<Scalars['DateTime']>;
+    safety: Array<SafetyOption>;
+    shortDescription?: Maybe<Scalars['String']>;
+    title: Scalars['String'];
+};
+export declare type VehicleData = {
+    __typename?: 'VehicleData';
+    enginePower?: Maybe<Scalars['Float']>;
+    equipmentLevel?: Maybe<Scalars['String']>;
+    fuelType?: Maybe<Scalars['String']>;
+    gearbox?: Maybe<Scalars['String']>;
+    gearboxType?: Maybe<Scalars['String']>;
+    manufactureYear: Scalars['Int'];
+    manufacturer: Scalars['String'];
+    mileage: Scalars['Int'];
+    modelName?: Maybe<Scalars['String']>;
+    modelSeries?: Maybe<Scalars['String']>;
+    modelYear: Scalars['Int'];
+    options: Array<Scalars['String']>;
+    properties?: Maybe<Scalars['VehicleDataPropertyMap']>;
+    propertySet?: Maybe<Scalars['VehicleDataPropertySet']>;
+    registrationNumber?: Maybe<Scalars['String']>;
+    salesName?: Maybe<Scalars['String']>;
+    vin?: Maybe<Scalars['String']>;
+};
+export declare type VehicleDataPropertySetArgs = {
+    category?: InputMaybe<Scalars['String']>;
+    properties?: InputMaybe<Array<Scalars['String']>>;
+};
+export declare type VehicleFlags = {
+    __typename?: 'VehicleFlags';
+    auction?: Maybe<Scalars['Boolean']>;
+    testDrive?: Maybe<Scalars['Boolean']>;
+};

package/dist-types/@types/filter.d.ts

@@ -0,0 +1,5 @@
+export declare type SearchFilterNameTypes = 'manufacturer' | 'modelSeries' | 'fuelType' | 'gearboxType' | 'branch' | 'color' | 'environmentClass' | 'properties.segment' | 'drivingWheel' | 'price' | 'mileage' | 'modelYear';
+export declare type SearchFilterTypes = {
+    filterName: SearchFilterNameTypes;
+    displayName?: string;
+};

package/dist-types/@types/queryFilter.d.ts

@@ -0,0 +1,5 @@
+export interface QueryFilter {
+    searchParams: URLSearchParams;
+    concatResult?: boolean;
+    block?: boolean;
+}

package/dist-types/@types/search.d.ts

@@ -0,0 +1,105 @@
+export interface Stats {
+    totalHits: number;
+    searchEngineTimeInMillis: number;
+    searchEngineRoundTripTimeInMillis: number;
+    searchProcessingTimeInMillis: number;
+}
+export interface Branch {
+    id: string;
+    name: string;
+}
+export interface Format {
+    format: string;
+    id: string;
+    url: string;
+}
+export interface File {
+    formats: Format[];
+    id: string;
+    sortOrder: number;
+    url: string;
+}
+export interface FeaturedImage {
+    files: File[];
+    id: string;
+    sortOrder: number;
+    type: 'Image';
+}
+export interface PaginationPage {
+    displayName: string;
+    selected: boolean;
+    query: string;
+}
+export interface Pagination {
+    offset: number;
+    hitsPerPage: number;
+    firstPage: string | null;
+    previousPage: string | null;
+    nextPage: PaginationPage | null;
+    pages: PaginationPage[];
+}
+export interface SortOption {
+    displayName: string;
+    selected: boolean;
+    query: string;
+}
+export interface DocumentList {
+    id: string;
+    displayName: string;
+    numberOfHits: number;
+    documents: Document[];
+    pagination: Pagination;
+    sortOptions: SortOption[];
+}
+export interface Document {
+    _id: string;
+    _type: string;
+    branches: Branch[];
+    deductibleVat: boolean;
+    featuredImage: FeaturedImage;
+    gearboxType: string;
+    hasManufacturerPackaging: boolean;
+    itemPublished: string;
+    itemUpdated: string;
+    manufacturer: string;
+    mileage: number;
+    modelSeries: string;
+    modelYear: number;
+    fuelType: string;
+    price: number;
+    oldPrice?: number;
+    registrationNumber: string;
+    salesName: string;
+    shortDescription: string;
+    title: string;
+    leasingPrice?: number;
+}
+export interface FacetFilter {
+    displayName: string;
+    selected: boolean;
+    query: string;
+    count: number;
+    children: any[];
+}
+export interface Facet {
+    id: string;
+    displayName: string;
+    selectionType: 'OR';
+    multipleLevels: boolean;
+    filters: FacetFilter[];
+}
+export interface Query {
+    displayName: string;
+    id: string;
+    parameters: string | null;
+    queryString: string | null;
+}
+export interface Search {
+    stats: Stats;
+    query: Query | null;
+    documentList: DocumentList;
+    facets: Facet[];
+    spell: null;
+    quickLinks: null;
+    errorMessages: string[];
+}

package/dist-types/@types/vehicle-properties.d.ts

@@ -0,0 +1,29 @@
+export interface Property {
+    value: string | number | boolean | string[];
+    name: string;
+    type: string;
+    unit: string | null | undefined;
+    hint: string | null | undefined;
+}
+export interface Category {
+    id: number;
+    name: string;
+    properties: Property[];
+    subCategories: Category[];
+}
+export interface Tree {
+    categories: Category[];
+}
+export interface EnhancedProperty {
+    value: number | string | boolean | string[];
+    name: string;
+    type: string;
+    unit: string | undefined | null;
+    category: ItemCategory | undefined | null;
+    hint: string | undefined | null;
+}
+export interface ItemCategory {
+    name: string;
+    id: number;
+    subCategory: ItemCategory | undefined | null;
+}

package/dist-types/State/CentralStorage/CentralStorageContext.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+export interface CentralStorageContextProps {
+    centralStorageId?: string | null;
+    setCentralStorageId: (id?: string) => void;
+}
+export declare const CentralStorageContext: import("react").Context<CentralStorageContextProps>;

package/dist-types/State/CentralStorage/CentralStorageProvider.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface CentralStorageProviderProps {
+    children: React.ReactNode;
+}
+declare const CentralStorageProvider: ({ children }: CentralStorageProviderProps) => JSX.Element;
+export default CentralStorageProvider;

package/dist-types/State/CentralStorage/useCentralStorage.d.ts

@@ -0,0 +1,6 @@
+import { Vehicle } from '../../@types/codegen/types';
+declare const useCentralStorage: (vehicle?: Vehicle | null) => {
+    vehicle: import("../../@types/codegen/types").Maybe<Vehicle> | undefined;
+    loading: boolean;
+};
+export default useCentralStorage;

package/dist-types/State/Path/PathContext.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+export interface PathContextProps {
+    path: string;
+    previousPath?: string;
+    id?: string;
+    pushState: (id: string) => void;
+    replaceState: (id: string) => void;
+}
+export declare const PathContext: import("react").Context<PathContextProps | undefined>;

package/dist-types/State/Path/PathProvider.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface PathProviderProps {
+    children: React.ReactNode;
+}
+declare const PathProvider: ({ children }: PathProviderProps) => JSX.Element;
+export default PathProvider;

package/dist-types/State/Path/reducer.d.ts

@@ -0,0 +1,14 @@
+import { BaseAction } from '../../@types/action';
+export declare const SET_PATH = "SET_PATH";
+declare type SET_PATH_TYPE = BaseAction<typeof SET_PATH> & {
+    path: string;
+};
+declare type PathAction = SET_PATH_TYPE;
+interface PathState {
+    path: string;
+}
+export declare const initialState: PathState;
+declare const pathReducer: (state: PathState, action: PathAction) => {
+    path: string;
+};
+export default pathReducer;

package/dist-types/State/Path/usePath.d.ts

@@ -0,0 +1,3 @@
+import { PathContextProps } from './PathContext';
+declare const usePath: () => PathContextProps;
+export default usePath;

package/dist-types/State/RelatedSearch/RelatedSearchContext.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { Search } from '../../@types/search';
+export interface RelatedSearchContextProps {
+    moreLikeThisUrl: boolean;
+    loading: boolean;
+    response?: Search;
+    error: boolean;
+    fetchRelated: (searchParmas: URLSearchParams) => void;
+}
+export declare const RelatedSearchContext: import("react").Context<RelatedSearchContextProps>;

package/dist-types/State/RelatedSearch/RelatedSearchProvider.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+interface RelatedSearchProviderProps {
+    url: string;
+    urlMlt?: string;
+    apiKey?: string;
+    children: React.ReactNode;
+}
+declare const RelatedSearchProvider: ({ url, urlMlt, apiKey, children }: RelatedSearchProviderProps) => JSX.Element;
+export default RelatedSearchProvider;

package/dist-types/State/RelatedSearch/useRelatedSearch.d.ts

@@ -0,0 +1,2 @@
+declare const useRelatedSearch: (id: string) => import("./RelatedSearchContext").RelatedSearchContextProps;
+export default useRelatedSearch;

package/dist-types/State/Search/SearchContext.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import { Facet, Document, Search } from '../../@types/search';
+import { QueryFilter } from '../../@types/queryFilter';
+export interface SearchContextProps {
+    loading: boolean;
+    response?: Search;
+    error: boolean;
+    documents?: Document[];
+    initialFacets?: Facet[];
+    queryFilter: QueryFilter;
+    onFilterUpdate: (nextQuery: string) => void;
+    onLoadMore: () => void;
+    onInitialize: (initialQueryParams?: URLSearchParams) => void;
+}
+export declare const SearchContext: import("react").Context<SearchContextProps>;

package/dist-types/State/Search/SearchProvider.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface SearchProviderProps {
+    url: string;
+    apiKey?: string;
+    useQueryParamsFromUrl?: boolean;
+    pathRoute?: string;
+    children: React.ReactNode;
+}
+declare const SearchProvider: ({ url, apiKey, useQueryParamsFromUrl, pathRoute, children, }: SearchProviderProps) => JSX.Element;
+export default SearchProvider;

package/dist-types/State/Search/useSearch.d.ts

@@ -0,0 +1,2 @@
+declare const useSearch: () => import("./SearchContext").SearchContextProps;
+export default useSearch;

package/dist-types/State/Settings/SettingsContext.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+export interface SettingsContextProps {
+    googleMapsApiKey?: string;
+    googleMapsMarker?: string;
+    ecomSettings?: {
+        url: string;
+        useBankId?: boolean;
+        displayBankIdAlert?: boolean;
+        serviceLogotypeUrl?: string;
+        bankIdThumbprint?: string;
+    };
+}
+export declare const SettingsContext: import("react").Context<SettingsContextProps>;

package/dist-types/State/Settings/SettingsProvider.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { EcomSettings } from '../../providers/WaykeProvider';
+interface SettingsProps {
+    ecomSettings?: EcomSettings;
+    googleMapsApiKey?: string;
+    googleMapsMarker?: string;
+    children: React.ReactNode;
+}
+declare const SettingsProvider: ({ googleMapsApiKey, googleMapsMarker, ecomSettings, children, }: SettingsProps) => JSX.Element;
+export default SettingsProvider;

package/dist-types/State/Settings/useSettings.d.ts

@@ -0,0 +1,2 @@
+declare const useSettings: () => import("./SettingsContext").SettingsContextProps;
+export default useSettings;

package/dist-types/components/Accordion/index.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+export interface IAccordionItem {
+    heading: string;
+    activeCount?: number;
+    children: React.ReactNode;
+    isActive?: boolean;
+}
+export interface IAccordion {
+    children?: React.ReactNode;
+}
+export declare const AccordionItem: ({ heading, children, activeCount, isActive }: IAccordionItem) => JSX.Element;
+declare const Accordion: ({ children }: IAccordion) => JSX.Element;
+export default Accordion;

package/dist-types/components/Accordion/wrapper.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+export declare const List: import("styled-components").StyledComponent<"ul", import("styled-components").DefaultTheme, {}, never>;
+export declare const Header: import("styled-components").StyledComponent<"button", import("styled-components").DefaultTheme, {
+    type: "button";
+}, "type">;
+export declare const Label: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const Heading: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const Indicator: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    className: "wayke__theme wayke__color--primary-bg";
+}, "className">;
+export declare const IndicatorValue: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const Icon: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const Body: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const Item: import("styled-components").StyledComponent<"li", import("styled-components").DefaultTheme, import("react").ClassAttributes<HTMLLIElement> & import("react").HTMLAttributes<HTMLLIElement> & {
+    isOpen?: boolean | undefined;
+}, never>;