@symbiote-native/contacts 0.1.0

package/build/legacy/contacts.js

@@ -0,0 +1,177 @@
+import { UnavailabilityError, uuid } from 'expo-modules-core';
+import { Platform, Share } from 'react-native';
+import { expoContacts, ON_CONTACTS_CHANGE_EVENT_NAME } from './native-module.js';
+export async function isAvailableAsync() {
+    return !!expoContacts.getContactsAsync;
+}
+export async function hasContactsAsync() {
+    if (!expoContacts.hasContactsAsync) {
+        throw new UnavailabilityError('Contacts', 'hasContactsAsync');
+    }
+    return expoContacts.hasContactsAsync();
+}
+export async function writeContactToFileAsync(contactQuery = {}) {
+    if (!expoContacts.writeContactToFileAsync) {
+        throw new UnavailabilityError('Contacts', 'writeContactToFileAsync');
+    }
+    return expoContacts.writeContactToFileAsync(contactQuery);
+}
+export async function shareContactAsync(contactId, message, shareOptions = {}) {
+    if (Platform.OS === 'ios') {
+        const url = await writeContactToFileAsync({ id: contactId });
+        return Share.share({ url, message }, shareOptions);
+    }
+    if (!expoContacts.shareContactAsync) {
+        throw new UnavailabilityError('Contacts', 'shareContactAsync');
+    }
+    return expoContacts.shareContactAsync(contactId, message);
+}
+export async function getContactsAsync(contactQuery = {}) {
+    if (!expoContacts.getContactsAsync) {
+        throw new UnavailabilityError('Contacts', 'getContactsAsync');
+    }
+    return expoContacts.getContactsAsync(contactQuery);
+}
+export async function getPagedContactsAsync(contactQuery = {}) {
+    const { pageSize, ...rest } = contactQuery;
+    if (pageSize != null && pageSize <= 0) {
+        throw new Error('Error: Contacts.getPagedContactsAsync: `pageSize` must be greater than 0');
+    }
+    return getContactsAsync({ ...rest, pageSize });
+}
+export async function getContactByIdAsync(id, fields) {
+    if (!expoContacts.getContactsAsync) {
+        throw new UnavailabilityError('Contacts', 'getContactsAsync');
+    }
+    const results = await expoContacts.getContactsAsync({
+        pageSize: 1,
+        pageOffset: 0,
+        fields,
+        id,
+    });
+    return results.data.length > 0 ? results.data[0] : undefined;
+}
+export async function addContactAsync(contact, containerId) {
+    if (!expoContacts.addContactAsync) {
+        throw new UnavailabilityError('Contacts', 'addContactAsync');
+    }
+    return expoContacts.addContactAsync(contact, containerId);
+}
+export async function updateContactAsync(contact) {
+    if (!expoContacts.updateContactAsync) {
+        throw new UnavailabilityError('Contacts', 'updateContactAsync');
+    }
+    return expoContacts.updateContactAsync(contact);
+}
+export async function removeContactAsync(contactId) {
+    if (!expoContacts.removeContactAsync) {
+        throw new UnavailabilityError('Contacts', 'removeContactAsync');
+    }
+    return expoContacts.removeContactAsync(contactId);
+}
+export async function presentFormAsync(contactId, contact, formOptions = {}) {
+    if (!expoContacts.presentFormAsync) {
+        throw new UnavailabilityError('Contacts', 'presentFormAsync');
+    }
+    if (Platform.OS !== 'ios') {
+        return expoContacts.presentFormAsync(contactId, contact, formOptions);
+    }
+    let adjustedContact = contact;
+    if (contactId) {
+        if (adjustedContact) {
+            adjustedContact = undefined;
+            console.warn('Expo.Contacts.presentFormAsync: You should define either a `contact` or a `contactId` but not both.');
+        }
+        if (formOptions.isNew !== undefined) {
+            console.warn('Expo.Contacts.presentFormAsync: `formOptions.isNew` is not supported with `contactId`');
+        }
+    }
+    return expoContacts.presentFormAsync(contactId, adjustedContact, formOptions);
+}
+export async function addExistingGroupToContainerAsync(groupId, containerId) {
+    if (!expoContacts.addExistingGroupToContainerAsync) {
+        throw new UnavailabilityError('Contacts', 'addExistingGroupToContainerAsync');
+    }
+    return expoContacts.addExistingGroupToContainerAsync(groupId, containerId);
+}
+export async function getDefaultContainerIdAsync() {
+    if (!expoContacts.getDefaultContainerIdentifierAsync) {
+        throw new UnavailabilityError('Contacts', 'getDefaultContainerIdentifierAsync');
+    }
+    return expoContacts.getDefaultContainerIdentifierAsync();
+}
+export async function createGroupAsync(name, containerId) {
+    if (!expoContacts.createGroupAsync) {
+        throw new UnavailabilityError('Contacts', 'createGroupAsync');
+    }
+    const groupName = name ?? uuid.v4();
+    const resolvedContainerId = containerId ?? (await getDefaultContainerIdAsync());
+    return expoContacts.createGroupAsync(groupName, resolvedContainerId);
+}
+export async function updateGroupNameAsync(groupName, groupId) {
+    if (!expoContacts.updateGroupNameAsync) {
+        throw new UnavailabilityError('Contacts', 'updateGroupNameAsync');
+    }
+    return expoContacts.updateGroupNameAsync(groupName, groupId);
+}
+export async function removeGroupAsync(groupId) {
+    if (!expoContacts.removeGroupAsync) {
+        throw new UnavailabilityError('Contacts', 'removeGroupAsync');
+    }
+    return expoContacts.removeGroupAsync(groupId);
+}
+export async function addExistingContactToGroupAsync(contactId, groupId) {
+    if (!expoContacts.addExistingContactToGroupAsync) {
+        throw new UnavailabilityError('Contacts', 'addExistingContactToGroupAsync');
+    }
+    return expoContacts.addExistingContactToGroupAsync(contactId, groupId);
+}
+export async function removeContactFromGroupAsync(contactId, groupId) {
+    if (!expoContacts.removeContactFromGroupAsync) {
+        throw new UnavailabilityError('Contacts', 'removeContactFromGroupAsync');
+    }
+    return expoContacts.removeContactFromGroupAsync(contactId, groupId);
+}
+export async function getGroupsAsync(groupQuery) {
+    if (!expoContacts.getGroupsAsync) {
+        throw new UnavailabilityError('Contacts', 'getGroupsAsync');
+    }
+    return expoContacts.getGroupsAsync(groupQuery);
+}
+export async function presentContactPickerAsync() {
+    if (!expoContacts.presentContactPickerAsync) {
+        throw new UnavailabilityError('Contacts', 'presentContactPickerAsync');
+    }
+    return expoContacts.presentContactPickerAsync();
+}
+export async function getContainersAsync(containerQuery) {
+    if (!expoContacts.getContainersAsync) {
+        throw new UnavailabilityError('Contacts', 'getContainersAsync');
+    }
+    return expoContacts.getContainersAsync(containerQuery);
+}
+export async function presentAccessPickerAsync() {
+    if (!expoContacts.presentAccessPickerAsync) {
+        throw new UnavailabilityError('Contacts', 'presentAccessPickerAsync');
+    }
+    return expoContacts.presentAccessPickerAsync();
+}
+export async function getPermissionsAsync() {
+    if (!expoContacts.getPermissionsAsync) {
+        throw new UnavailabilityError('Contacts', 'getPermissionsAsync');
+    }
+    return expoContacts.getPermissionsAsync();
+}
+export async function requestPermissionsAsync() {
+    if (!expoContacts.requestPermissionsAsync) {
+        throw new UnavailabilityError('Contacts', 'requestPermissionsAsync');
+    }
+    return expoContacts.requestPermissionsAsync();
+}
+export function addContactsChangeListener(listener) {
+    if (!expoContacts.addListener) {
+        throw new UnavailabilityError('Contacts', 'addContactsChangeListener');
+    }
+    const subscription = expoContacts.addListener(ON_CONTACTS_CHANGE_EVENT_NAME, listener);
+    return { remove: () => subscription.remove() };
+}

package/build/legacy/enums.d.ts

@@ -0,0 +1,68 @@
+export declare enum Fields {
+    ID = "id",
+    ContactType = "contactType",
+    Name = "name",
+    FirstName = "firstName",
+    MiddleName = "middleName",
+    LastName = "lastName",
+    MaidenName = "maidenName",
+    NamePrefix = "namePrefix",
+    NameSuffix = "nameSuffix",
+    Nickname = "nickname",
+    PhoneticFirstName = "phoneticFirstName",
+    PhoneticMiddleName = "phoneticMiddleName",
+    PhoneticLastName = "phoneticLastName",
+    Birthday = "birthday",
+    NonGregorianBirthday = "nonGregorianBirthday",
+    Emails = "emails",
+    PhoneNumbers = "phoneNumbers",
+    Addresses = "addresses",
+    SocialProfiles = "socialProfiles",
+    InstantMessageAddresses = "instantMessageAddresses",
+    UrlAddresses = "urlAddresses",
+    Company = "company",
+    JobTitle = "jobTitle",
+    Department = "department",
+    ImageAvailable = "imageAvailable",
+    Image = "image",
+    RawImage = "rawImage",
+    ExtraNames = "extraNames",
+    Note = "note",
+    Dates = "dates",
+    Relationships = "relationships",
+    IsFavorite = "isFavorite"
+}
+export declare enum CalendarFormats {
+    Gregorian = "gregorian",
+    Buddhist = "buddhist",
+    Chinese = "chinese",
+    Coptic = "coptic",
+    EthiopicAmeteMihret = "ethiopicAmeteMihret",
+    EthiopicAmeteAlem = "ethiopicAmeteAlem",
+    Hebrew = "hebrew",
+    ISO8601 = "iso8601",
+    Indian = "indian",
+    Islamic = "islamic",
+    IslamicCivil = "islamicCivil",
+    Japanese = "japanese",
+    Persian = "persian",
+    RepublicOfChina = "republicOfChina",
+    IslamicTabular = "islamicTabular",
+    IslamicUmmAlQura = "islamicUmmAlQura"
+}
+export declare enum ContainerTypes {
+    Local = "local",
+    Exchange = "exchange",
+    CardDAV = "cardDAV",
+    Unassigned = "unassigned"
+}
+export declare enum SortTypes {
+    UserDefault = "userDefault",
+    FirstName = "firstName",
+    LastName = "lastName",
+    None = "none"
+}
+export declare enum ContactTypes {
+    Person = "person",
+    Company = "company"
+}

package/build/legacy/enums.js

@@ -0,0 +1,73 @@
+export var Fields;
+(function (Fields) {
+    Fields["ID"] = "id";
+    Fields["ContactType"] = "contactType";
+    Fields["Name"] = "name";
+    Fields["FirstName"] = "firstName";
+    Fields["MiddleName"] = "middleName";
+    Fields["LastName"] = "lastName";
+    Fields["MaidenName"] = "maidenName";
+    Fields["NamePrefix"] = "namePrefix";
+    Fields["NameSuffix"] = "nameSuffix";
+    Fields["Nickname"] = "nickname";
+    Fields["PhoneticFirstName"] = "phoneticFirstName";
+    Fields["PhoneticMiddleName"] = "phoneticMiddleName";
+    Fields["PhoneticLastName"] = "phoneticLastName";
+    Fields["Birthday"] = "birthday";
+    Fields["NonGregorianBirthday"] = "nonGregorianBirthday";
+    Fields["Emails"] = "emails";
+    Fields["PhoneNumbers"] = "phoneNumbers";
+    Fields["Addresses"] = "addresses";
+    Fields["SocialProfiles"] = "socialProfiles";
+    Fields["InstantMessageAddresses"] = "instantMessageAddresses";
+    Fields["UrlAddresses"] = "urlAddresses";
+    Fields["Company"] = "company";
+    Fields["JobTitle"] = "jobTitle";
+    Fields["Department"] = "department";
+    Fields["ImageAvailable"] = "imageAvailable";
+    Fields["Image"] = "image";
+    Fields["RawImage"] = "rawImage";
+    Fields["ExtraNames"] = "extraNames";
+    Fields["Note"] = "note";
+    Fields["Dates"] = "dates";
+    Fields["Relationships"] = "relationships";
+    Fields["IsFavorite"] = "isFavorite";
+})(Fields || (Fields = {}));
+export var CalendarFormats;
+(function (CalendarFormats) {
+    CalendarFormats["Gregorian"] = "gregorian";
+    CalendarFormats["Buddhist"] = "buddhist";
+    CalendarFormats["Chinese"] = "chinese";
+    CalendarFormats["Coptic"] = "coptic";
+    CalendarFormats["EthiopicAmeteMihret"] = "ethiopicAmeteMihret";
+    CalendarFormats["EthiopicAmeteAlem"] = "ethiopicAmeteAlem";
+    CalendarFormats["Hebrew"] = "hebrew";
+    CalendarFormats["ISO8601"] = "iso8601";
+    CalendarFormats["Indian"] = "indian";
+    CalendarFormats["Islamic"] = "islamic";
+    CalendarFormats["IslamicCivil"] = "islamicCivil";
+    CalendarFormats["Japanese"] = "japanese";
+    CalendarFormats["Persian"] = "persian";
+    CalendarFormats["RepublicOfChina"] = "republicOfChina";
+    CalendarFormats["IslamicTabular"] = "islamicTabular";
+    CalendarFormats["IslamicUmmAlQura"] = "islamicUmmAlQura";
+})(CalendarFormats || (CalendarFormats = {}));
+export var ContainerTypes;
+(function (ContainerTypes) {
+    ContainerTypes["Local"] = "local";
+    ContainerTypes["Exchange"] = "exchange";
+    ContainerTypes["CardDAV"] = "cardDAV";
+    ContainerTypes["Unassigned"] = "unassigned";
+})(ContainerTypes || (ContainerTypes = {}));
+export var SortTypes;
+(function (SortTypes) {
+    SortTypes["UserDefault"] = "userDefault";
+    SortTypes["FirstName"] = "firstName";
+    SortTypes["LastName"] = "lastName";
+    SortTypes["None"] = "none";
+})(SortTypes || (SortTypes = {}));
+export var ContactTypes;
+(function (ContactTypes) {
+    ContactTypes["Person"] = "person";
+    ContactTypes["Company"] = "company";
+})(ContactTypes || (ContactTypes = {}));

package/build/legacy/index.d.ts

@@ -0,0 +1,3 @@
+export * from './enums';
+export * from './types';
+export * from './contacts';

package/build/legacy/index.js

@@ -0,0 +1,3 @@
+export * from './enums.js';
+export * from './types.js';
+export * from './contacts.js';

package/build/legacy/native-module.d.ts

@@ -0,0 +1,30 @@
+import type { EventSubscription } from 'expo-modules-core';
+import type { Contact, ContactQuery, ContactResponse, Container, ContainerQuery, ContactsPermissionResponse, ExistingContact, FormOptions, Group, GroupQuery } from './types';
+export declare const ON_CONTACTS_CHANGE_EVENT_NAME = "onContactsChange";
+export type INativeContactsModule = {
+    hasContactsAsync?(): Promise<boolean>;
+    shareContactAsync?(contactId: string, message: string): Promise<unknown>;
+    getContactsAsync?(contactQuery: ContactQuery): Promise<ContactResponse>;
+    addContactAsync?(contact: Contact, containerId?: string): Promise<string>;
+    updateContactAsync?(contact: {
+        id: string;
+    } & Partial<ExistingContact>): Promise<string>;
+    removeContactAsync?(contactId: string): Promise<unknown>;
+    writeContactToFileAsync?(contactQuery: ContactQuery): Promise<string | undefined>;
+    presentFormAsync?(contactId?: string | null, contact?: Contact | null, formOptions?: FormOptions): Promise<unknown>;
+    addExistingGroupToContainerAsync?(groupId: string, containerId: string): Promise<unknown>;
+    createGroupAsync?(name: string, containerId?: string): Promise<string>;
+    updateGroupNameAsync?(groupName: string, groupId: string): Promise<unknown>;
+    removeGroupAsync?(groupId: string): Promise<unknown>;
+    addExistingContactToGroupAsync?(contactId: string, groupId: string): Promise<unknown>;
+    removeContactFromGroupAsync?(contactId: string, groupId: string): Promise<unknown>;
+    getGroupsAsync?(groupQuery: GroupQuery): Promise<Group[]>;
+    presentContactPickerAsync?(): Promise<ExistingContact | null>;
+    getDefaultContainerIdentifierAsync?(): Promise<string>;
+    getContainersAsync?(containerQuery: ContainerQuery): Promise<Container[]>;
+    presentAccessPickerAsync?(): Promise<string[]>;
+    getPermissionsAsync?(): Promise<ContactsPermissionResponse>;
+    requestPermissionsAsync?(): Promise<ContactsPermissionResponse>;
+    addListener?(eventName: typeof ON_CONTACTS_CHANGE_EVENT_NAME, listener: () => void): EventSubscription;
+};
+export declare const expoContacts: INativeContactsModule;

package/build/legacy/native-module.js

@@ -0,0 +1,4 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_CONTACTS_MODULE_NAME = 'ExpoContacts';
+export const ON_CONTACTS_CHANGE_EVENT_NAME = 'onContactsChange';
+export const expoContacts = requireNativeModule(EXPO_CONTACTS_MODULE_NAME);

package/build/legacy/types.d.ts

@@ -0,0 +1,158 @@
+import type { PermissionResponse } from 'expo-modules-core';
+import type { CalendarFormats, ContactTypes, ContainerTypes, Fields, SortTypes } from './enums';
+export type ContactsPermissionResponse = PermissionResponse & {
+    accessPrivileges?: 'all' | 'limited' | 'none';
+};
+export type CalendarFormatType = CalendarFormats | `${CalendarFormats}`;
+export type ContainerType = ContainerTypes | `${ContainerTypes}`;
+export type ContactType = ContactTypes | `${ContactTypes}`;
+export type FieldType = Fields | `${Fields}`;
+export type Date = {
+    day: number;
+    month: number;
+    year?: number;
+    id?: string;
+    label?: string;
+    format?: CalendarFormatType;
+};
+export type Relationship = {
+    label: string;
+    name?: string;
+    id?: string;
+};
+export type Email = {
+    email?: string;
+    isPrimary?: boolean;
+    label: string;
+    id?: string;
+};
+export type PhoneNumber = {
+    number?: string;
+    isPrimary?: boolean;
+    digits?: string;
+    countryCode?: string;
+    label: string;
+    id?: string;
+};
+export type Address = {
+    street?: string;
+    city?: string;
+    country?: string;
+    region?: string;
+    neighborhood?: string;
+    postalCode?: string;
+    poBox?: string;
+    isoCountryCode?: string;
+    label: string;
+    id?: string;
+};
+export type SocialProfile = {
+    service?: string;
+    localizedProfile?: string;
+    url?: string;
+    username?: string;
+    userId?: string;
+    label: string;
+    id?: string;
+};
+export type InstantMessageAddress = {
+    service?: string;
+    username?: string;
+    localizedService?: string;
+    label: string;
+    id?: string;
+};
+export type UrlAddress = {
+    label: string;
+    url?: string;
+    id?: string;
+};
+export type Image = {
+    uri?: string;
+    width?: number;
+    height?: number;
+    base64?: string;
+};
+export type Contact = {
+    contactType: ContactType;
+    name: string;
+    firstName?: string;
+    middleName?: string;
+    lastName?: string;
+    maidenName?: string;
+    namePrefix?: string;
+    nameSuffix?: string;
+    nickname?: string;
+    phoneticFirstName?: string;
+    phoneticMiddleName?: string;
+    phoneticLastName?: string;
+    company?: string;
+    jobTitle?: string;
+    department?: string;
+    note?: string;
+    imageAvailable?: boolean;
+    image?: Image;
+    rawImage?: Image;
+    birthday?: Date;
+    dates?: Date[];
+    relationships?: Relationship[];
+    emails?: Email[];
+    phoneNumbers?: PhoneNumber[];
+    addresses?: Address[];
+    instantMessageAddresses?: InstantMessageAddress[];
+    urlAddresses?: UrlAddress[];
+    nonGregorianBirthday?: Date;
+    socialProfiles?: SocialProfile[];
+    isFavorite?: boolean;
+};
+export type ExistingContact = Contact & {
+    id: string;
+};
+export type ContactResponse = {
+    data: ExistingContact[];
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+};
+export type ContactSort = `${SortTypes}`;
+export type ContactQuery = {
+    pageSize?: number;
+    pageOffset?: number;
+    fields?: FieldType[];
+    sort?: ContactSort;
+    name?: string;
+    id?: string | string[];
+    groupId?: string;
+    containerId?: string;
+    rawContacts?: boolean;
+};
+export type FormOptions = {
+    displayedPropertyKeys?: FieldType[];
+    message?: string;
+    alternateName?: string;
+    allowsEditing?: boolean;
+    allowsActions?: boolean;
+    shouldShowLinkedContacts?: boolean;
+    isNew?: boolean;
+    cancelButtonTitle?: string;
+    preventAnimation?: boolean;
+    groupId?: string;
+};
+export type GroupQuery = {
+    groupId?: string;
+    groupName?: string;
+    containerId?: string;
+};
+export type Group = {
+    name?: string;
+    id?: string;
+};
+export type ContainerQuery = {
+    contactId?: string;
+    groupId?: string;
+    containerId?: string | string[];
+};
+export type Container = {
+    name: string;
+    id: string;
+    type: ContainerType;
+};

package/build/legacy/types.js

@@ -0,0 +1 @@
+export {};

package/build/react/contact-access-button.d.ts

@@ -0,0 +1,10 @@
+import type { ReactElement } from 'react';
+import { isContactAccessButtonAvailable } from '../core/contact-access-button';
+import type { IContactAccessButtonProps } from '../core/contact-access-button';
+declare function ContactAccessButtonView(props: IContactAccessButtonProps): ReactElement | null;
+/** React twin of `expo-contacts`' `ContactAccessButton`, iOS 18+ only, nothing elsewhere */
+export declare const ContactAccessButton: typeof ContactAccessButtonView & {
+    /** True only on iOS 18.0 and newer */
+    isAvailable: typeof isContactAccessButtonAvailable;
+};
+export {};

package/build/react/contact-access-button.js

@@ -0,0 +1,11 @@
+import { descriptorToReact } from '@symbiote-native/react';
+import { isContactAccessButtonAvailable, renderContactAccessButton, } from '../core/contact-access-button.js';
+function ContactAccessButtonView(props) {
+    const descriptor = renderContactAccessButton(props);
+    return descriptor ? descriptorToReact(descriptor) : null;
+}
+/** React twin of `expo-contacts`' `ContactAccessButton`, iOS 18+ only, nothing elsewhere */
+export const ContactAccessButton = Object.assign(ContactAccessButtonView, {
+    /** True only on iOS 18.0 and newer */
+    isAvailable: isContactAccessButtonAvailable,
+});

package/build/react/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { ContactAccessButton } from './contact-access-button';

package/build/react/index.js

@@ -0,0 +1,2 @@
+export * from '../core/index.js';
+export { ContactAccessButton } from './contact-access-button.js';

package/build/solid/contact-access-button.d.ts

@@ -0,0 +1,10 @@
+import { descriptorToSolid } from '@symbiote-native/solid';
+import { isContactAccessButtonAvailable } from '../core/contact-access-button';
+import type { IContactAccessButtonProps } from '../core/contact-access-button';
+declare function ContactAccessButtonView(props: IContactAccessButtonProps): ReturnType<typeof descriptorToSolid> | null;
+/** Solid twin of `expo-contacts`' `ContactAccessButton`, iOS 18+ only, nothing elsewhere */
+export declare const ContactAccessButton: typeof ContactAccessButtonView & {
+    /** True only on iOS 18.0 and newer */
+    isAvailable: typeof isContactAccessButtonAvailable;
+};
+export {};

package/build/solid/contact-access-button.js

@@ -0,0 +1,15 @@
+import { descriptorToSolid } from '@symbiote-native/solid';
+import { isContactAccessButtonAvailable, renderContactAccessButton, } from '../core/contact-access-button.js';
+// The platform decision is made once at mount: the descriptor bridge builds the node once and
+// only diffs prop values afterwards, so the descriptor's shape must not change
+function ContactAccessButtonView(props) {
+    const initial = renderContactAccessButton({ ...props });
+    if (!initial)
+        return null;
+    return descriptorToSolid(() => renderContactAccessButton({ ...props }) ?? initial);
+}
+/** Solid twin of `expo-contacts`' `ContactAccessButton`, iOS 18+ only, nothing elsewhere */
+export const ContactAccessButton = Object.assign(ContactAccessButtonView, {
+    /** True only on iOS 18.0 and newer */
+    isAvailable: isContactAccessButtonAvailable,
+});

package/build/solid/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { ContactAccessButton } from './contact-access-button';

package/build/solid/index.js

@@ -0,0 +1,2 @@
+export * from '../core/index.js';
+export { ContactAccessButton } from './contact-access-button.js';

package/build/svelte/contact-access-button.svelte

@@ -0,0 +1,18 @@
+<script lang="ts">
+  // The native view name is mixed-case, which a literal tag would parse as a component reference,
+  // so the tag is dynamic. The platform decision is made once at mount, like the other adapters
+  import { hostProps } from '@symbiote-native/svelte/native-view-bridge';
+  import {
+    contactAccessButtonViewName,
+    ensureContactAccessButtonRegistered,
+  } from '../core/contact-access-button';
+  import type { IContactAccessButtonProps } from '../core/contact-access-button';
+
+  const props: IContactAccessButtonProps = $props();
+  const isRegistered = ensureContactAccessButtonRegistered();
+  const viewName = contactAccessButtonViewName();
+</script>
+
+{#if isRegistered}
+  <svelte:element this={viewName} {@attach hostProps({ ...props })} />
+{/if}

package/build/svelte/contact-access-button.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { IContactAccessButtonProps } from '../core/contact-access-button';
+declare const ContactAccessButton: import("svelte").Component<IContactAccessButtonProps, {}, "">;
+type ContactAccessButton = ReturnType<typeof ContactAccessButton>;
+export default ContactAccessButton;

package/build/svelte/index.d.ts

@@ -0,0 +1,7 @@
+import { isContactAccessButtonAvailable } from '../core/contact-access-button';
+export * from '../core';
+/** Svelte twin of `expo-contacts`' `ContactAccessButton`, iOS 18+ only, nothing elsewhere */
+export declare const ContactAccessButton: import("svelte").Component<import(".").IContactAccessButtonProps, {}, ""> & {
+    /** True only on iOS 18.0 and newer */
+    isAvailable: typeof isContactAccessButtonAvailable;
+};

package/build/svelte/index.js

@@ -0,0 +1,8 @@
+import { isContactAccessButtonAvailable } from '../core/contact-access-button.js';
+import ContactAccessButtonView from './contact-access-button.svelte';
+export * from '../core/index.js';
+/** Svelte twin of `expo-contacts`' `ContactAccessButton`, iOS 18+ only, nothing elsewhere */
+export const ContactAccessButton = Object.assign(ContactAccessButtonView, {
+    /** True only on iOS 18.0 and newer */
+    isAvailable: isContactAccessButtonAvailable,
+});

package/build/vue/contact-access-button.d.ts

@@ -0,0 +1,19 @@
+import { type VNode } from '@vue/runtime-core';
+import { isContactAccessButtonAvailable } from '../core/contact-access-button';
+/** Vue twin of `expo-contacts`' `ContactAccessButton`, iOS 18+ only, nothing elsewhere */
+export declare const ContactAccessButton: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, () => VNode | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{}> & Readonly<{}>, () => VNode | null, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<{}> & Readonly<{}>, () => VNode | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    /** True only on iOS 18.0 and newer */
+    isAvailable: typeof isContactAccessButtonAvailable;
+};