objcjs-types 0.2.1 → 0.3.0

package/dist/CoreText/functions.js

@@ -0,0 +1,611 @@
+// AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
+import { callFunction } from "objc-js";
+export function CTFontCollectionCopyExclusionDescriptors(collection) {
+    return callFunction("CTFontCollectionCopyExclusionDescriptors", { returns: "@" }, collection);
+}
+export function CTFontCollectionCopyFontAttribute(collection, attributeName, options) {
+    return callFunction("CTFontCollectionCopyFontAttribute", { returns: "@", args: ["@", "^", "@"] }, collection, attributeName, options);
+}
+export function CTFontCollectionCopyFontAttributes(collection, attributeNames, options) {
+    return callFunction("CTFontCollectionCopyFontAttributes", { returns: "@" }, collection, attributeNames, options);
+}
+export function CTFontCollectionCopyQueryDescriptors(collection) {
+    return callFunction("CTFontCollectionCopyQueryDescriptors", { returns: "@" }, collection);
+}
+export function CTFontCollectionCreateCopyWithFontDescriptors(original, queryDescriptors, options) {
+    return callFunction("CTFontCollectionCreateCopyWithFontDescriptors", { returns: "@" }, original, queryDescriptors, options);
+}
+export function CTFontCollectionCreateFromAvailableFonts(options) {
+    return callFunction("CTFontCollectionCreateFromAvailableFonts", { returns: "@" }, options);
+}
+export function CTFontCollectionCreateMatchingFontDescriptors(collection) {
+    return callFunction("CTFontCollectionCreateMatchingFontDescriptors", { returns: "@" }, collection);
+}
+export function CTFontCollectionCreateMatchingFontDescriptorsForFamily(collection, familyName, options) {
+    return callFunction("CTFontCollectionCreateMatchingFontDescriptorsForFamily", { returns: "@", args: ["@", "^", "@"] }, collection, familyName, options);
+}
+export function CTFontCollectionCreateMatchingFontDescriptorsSortedWithCallback(collection, sortCallback, refCon) {
+    return callFunction("CTFontCollectionCreateMatchingFontDescriptorsSortedWithCallback", { returns: "@", args: ["@", "@", "^v"] }, collection, sortCallback, refCon);
+}
+export function CTFontCollectionCreateMatchingFontDescriptorsWithOptions(collection, options) {
+    return callFunction("CTFontCollectionCreateMatchingFontDescriptorsWithOptions", { returns: "@" }, collection, options);
+}
+export function CTFontCollectionCreateMutableCopy(original) {
+    return callFunction("CTFontCollectionCreateMutableCopy", { returns: "@" }, original);
+}
+export function CTFontCollectionCreateWithFontDescriptors(queryDescriptors, options) {
+    return callFunction("CTFontCollectionCreateWithFontDescriptors", { returns: "@" }, queryDescriptors, options);
+}
+export function CTFontCollectionGetTypeID() {
+    return callFunction("CTFontCollectionGetTypeID", { returns: "L" });
+}
+export function CTFontCollectionSetExclusionDescriptors(collection, descriptors) {
+    callFunction("CTFontCollectionSetExclusionDescriptors", undefined, collection, descriptors);
+}
+export function CTFontCollectionSetQueryDescriptors(collection, descriptors) {
+    callFunction("CTFontCollectionSetQueryDescriptors", undefined, collection, descriptors);
+}
+export function CTFontCopyAttribute(font, attribute) {
+    return callFunction("CTFontCopyAttribute", { returns: "^", args: ["@", "^"] }, font, attribute);
+}
+export function CTFontCopyAvailableTables(font, options) {
+    return callFunction("CTFontCopyAvailableTables", { returns: "@" }, font, options);
+}
+export function CTFontCopyCharacterSet(font) {
+    return callFunction("CTFontCopyCharacterSet", { returns: "@" }, font);
+}
+export function CTFontCopyDefaultCascadeListForLanguages(font, languagePrefList) {
+    return callFunction("CTFontCopyDefaultCascadeListForLanguages", { returns: "@" }, font, languagePrefList);
+}
+export function CTFontCopyDisplayName(font) {
+    return callFunction("CTFontCopyDisplayName", { returns: "^" }, font);
+}
+export function CTFontCopyFamilyName(font) {
+    return callFunction("CTFontCopyFamilyName", { returns: "^" }, font);
+}
+export function CTFontCopyFeatures(font) {
+    return callFunction("CTFontCopyFeatures", { returns: "@" }, font);
+}
+export function CTFontCopyFeatureSettings(font) {
+    return callFunction("CTFontCopyFeatureSettings", { returns: "@" }, font);
+}
+export function CTFontCopyFontDescriptor(font) {
+    return callFunction("CTFontCopyFontDescriptor", { returns: "@" }, font);
+}
+export function CTFontCopyFullName(font) {
+    return callFunction("CTFontCopyFullName", { returns: "^" }, font);
+}
+export function CTFontCopyGraphicsFont(font, attributes) {
+    return callFunction("CTFontCopyGraphicsFont", { returns: "@" }, font, attributes);
+}
+export function CTFontCopyLocalizedName(font, nameKey, actualLanguage) {
+    return callFunction("CTFontCopyLocalizedName", { returns: "^", args: ["@", "^", "@"] }, font, nameKey, actualLanguage);
+}
+export function CTFontCopyName(font, nameKey) {
+    return callFunction("CTFontCopyName", { returns: "^", args: ["@", "^"] }, font, nameKey);
+}
+export function CTFontCopyNameForGlyph(font, glyph) {
+    return callFunction("CTFontCopyNameForGlyph", { returns: "^", args: ["@", "S"] }, font, glyph);
+}
+export function CTFontCopyPostScriptName(font) {
+    return callFunction("CTFontCopyPostScriptName", { returns: "^" }, font);
+}
+export function CTFontCopySupportedLanguages(font) {
+    return callFunction("CTFontCopySupportedLanguages", { returns: "@" }, font);
+}
+export function CTFontCopyTable(font, table, options) {
+    return callFunction("CTFontCopyTable", { returns: "@", args: ["@", "I", "@"] }, font, table, options);
+}
+export function CTFontCopyTraits(font) {
+    return callFunction("CTFontCopyTraits", { returns: "@" }, font);
+}
+export function CTFontCopyVariation(font) {
+    return callFunction("CTFontCopyVariation", { returns: "@" }, font);
+}
+export function CTFontCopyVariationAxes(font) {
+    return callFunction("CTFontCopyVariationAxes", { returns: "@" }, font);
+}
+export function CTFontCreateCopyWithAttributes(font, size, matrix, attributes) {
+    return callFunction("CTFontCreateCopyWithAttributes", { returns: "@", args: ["@", "d", "@", "@"] }, font, size, matrix, attributes);
+}
+export function CTFontCreateCopyWithFamily(font, size, matrix, family) {
+    return callFunction("CTFontCreateCopyWithFamily", { returns: "@", args: ["@", "d", "@", "^"] }, font, size, matrix, family);
+}
+export function CTFontCreateCopyWithSymbolicTraits(font, size, matrix, symTraitValue, symTraitMask) {
+    return callFunction("CTFontCreateCopyWithSymbolicTraits", { returns: "@", args: ["@", "d", "@", "@", "@"] }, font, size, matrix, symTraitValue, symTraitMask);
+}
+export function CTFontCreateForString(currentFont, string_, range) {
+    return callFunction("CTFontCreateForString", { returns: "@", args: ["@", "^", "@"] }, currentFont, string_, range);
+}
+export function CTFontCreateForStringWithLanguage(currentFont, string_, range, language) {
+    return callFunction("CTFontCreateForStringWithLanguage", { returns: "@", args: ["@", "^", "@", "^"] }, currentFont, string_, range, language);
+}
+export function CTFontCreatePathForGlyph(font, glyph, matrix) {
+    return callFunction("CTFontCreatePathForGlyph", { returns: "^", args: ["@", "S", "@"] }, font, glyph, matrix);
+}
+export function CTFontCreateUIFontForLanguage(uiType, size, language) {
+    return callFunction("CTFontCreateUIFontForLanguage", { returns: "@", args: ["@", "d", "^"] }, uiType, size, language);
+}
+export function CTFontCreateWithFontDescriptor(descriptor, size, matrix) {
+    return callFunction("CTFontCreateWithFontDescriptor", { returns: "@", args: ["@", "d", "@"] }, descriptor, size, matrix);
+}
+export function CTFontCreateWithFontDescriptorAndOptions(descriptor, size, matrix, options) {
+    return callFunction("CTFontCreateWithFontDescriptorAndOptions", { returns: "@", args: ["@", "d", "@", "@"] }, descriptor, size, matrix, options);
+}
+export function CTFontCreateWithGraphicsFont(graphicsFont, size, matrix, attributes) {
+    return callFunction("CTFontCreateWithGraphicsFont", { returns: "@", args: ["@", "d", "@", "@"] }, graphicsFont, size, matrix, attributes);
+}
+export function CTFontCreateWithName(name, size, matrix) {
+    return callFunction("CTFontCreateWithName", { returns: "@", args: ["^", "d", "@"] }, name, size, matrix);
+}
+export function CTFontCreateWithNameAndOptions(name, size, matrix, options) {
+    return callFunction("CTFontCreateWithNameAndOptions", { returns: "@", args: ["^", "d", "@", "@"] }, name, size, matrix, options);
+}
+export function CTFontCreateWithPlatformFont(platformFont, size, matrix, attributes) {
+    return callFunction("CTFontCreateWithPlatformFont", { returns: "@", args: ["I", "d", "@", "@"] }, platformFont, size, matrix, attributes);
+}
+export function CTFontCreateWithQuickdrawInstance(name, identifier, style, size) {
+    return callFunction("CTFontCreateWithQuickdrawInstance", { returns: "@", args: ["*", "s", "C", "d"] }, name, identifier, style, size);
+}
+export function CTFontDescriptorCopyAttribute(descriptor, attribute) {
+    return callFunction("CTFontDescriptorCopyAttribute", { returns: "^", args: ["@", "^"] }, descriptor, attribute);
+}
+export function CTFontDescriptorCopyAttributes(descriptor) {
+    return callFunction("CTFontDescriptorCopyAttributes", { returns: "@" }, descriptor);
+}
+export function CTFontDescriptorCopyLocalizedAttribute(descriptor, attribute, language) {
+    return callFunction("CTFontDescriptorCopyLocalizedAttribute", { returns: "^", args: ["@", "^", "@"] }, descriptor, attribute, language);
+}
+export function CTFontDescriptorCreateCopyWithAttributes(original, attributes) {
+    return callFunction("CTFontDescriptorCreateCopyWithAttributes", { returns: "@" }, original, attributes);
+}
+export function CTFontDescriptorCreateCopyWithFamily(original, family) {
+    return callFunction("CTFontDescriptorCreateCopyWithFamily", { returns: "@", args: ["@", "^"] }, original, family);
+}
+export function CTFontDescriptorCreateCopyWithFeature(original, featureTypeIdentifier, featureSelectorIdentifier) {
+    return callFunction("CTFontDescriptorCreateCopyWithFeature", { returns: "@" }, original, featureTypeIdentifier, featureSelectorIdentifier);
+}
+export function CTFontDescriptorCreateCopyWithSymbolicTraits(original, symTraitValue, symTraitMask) {
+    return callFunction("CTFontDescriptorCreateCopyWithSymbolicTraits", { returns: "@" }, original, symTraitValue, symTraitMask);
+}
+export function CTFontDescriptorCreateCopyWithVariation(original, variationIdentifier, variationValue) {
+    return callFunction("CTFontDescriptorCreateCopyWithVariation", { returns: "@", args: ["@", "@", "d"] }, original, variationIdentifier, variationValue);
+}
+export function CTFontDescriptorCreateMatchingFontDescriptor(descriptor, mandatoryAttributes) {
+    return callFunction("CTFontDescriptorCreateMatchingFontDescriptor", { returns: "@" }, descriptor, mandatoryAttributes);
+}
+export function CTFontDescriptorCreateMatchingFontDescriptors(descriptor, mandatoryAttributes) {
+    return callFunction("CTFontDescriptorCreateMatchingFontDescriptors", { returns: "@" }, descriptor, mandatoryAttributes);
+}
+export function CTFontDescriptorCreateWithAttributes(attributes) {
+    return callFunction("CTFontDescriptorCreateWithAttributes", { returns: "@" }, attributes);
+}
+export function CTFontDescriptorCreateWithNameAndSize(name, size) {
+    return callFunction("CTFontDescriptorCreateWithNameAndSize", { returns: "@", args: ["^", "d"] }, name, size);
+}
+export function CTFontDescriptorGetTypeID() {
+    return callFunction("CTFontDescriptorGetTypeID", { returns: "L" });
+}
+export function CTFontDescriptorMatchFontDescriptorsWithProgressHandler(descriptors, mandatoryAttributes, progressBlock) {
+    return callFunction("CTFontDescriptorMatchFontDescriptorsWithProgressHandler", { returns: "B" }, descriptors, mandatoryAttributes, progressBlock);
+}
+export function CTFontDrawGlyphs(font, glyphs, positions, count, context) {
+    callFunction("CTFontDrawGlyphs", { args: ["@", "@", "@", "Q", "^"] }, font, glyphs, positions, count, context);
+}
+export function CTFontDrawImageFromAdaptiveImageProviderAtPoint(font, provider, point, context) {
+    callFunction("CTFontDrawImageFromAdaptiveImageProviderAtPoint", { args: ["@", "@", "{CGPoint}", "^"] }, font, provider, point, context);
+}
+export function CTFontGetAdvancesForGlyphs(font, orientation, glyphs, advances, count) {
+    return callFunction("CTFontGetAdvancesForGlyphs", { returns: "d", args: ["@", "@", "@", "@", "q"] }, font, orientation, glyphs, advances, count);
+}
+export function CTFontGetAscent(font) {
+    return callFunction("CTFontGetAscent", { returns: "d" }, font);
+}
+export function CTFontGetBoundingBox(font) {
+    return callFunction("CTFontGetBoundingBox", { returns: "{CGRect}" }, font);
+}
+export function CTFontGetBoundingRectsForGlyphs(font, orientation, glyphs, boundingRects, count) {
+    return callFunction("CTFontGetBoundingRectsForGlyphs", { returns: "{CGRect}", args: ["@", "@", "@", "@", "q"] }, font, orientation, glyphs, boundingRects, count);
+}
+export function CTFontGetCapHeight(font) {
+    return callFunction("CTFontGetCapHeight", { returns: "d" }, font);
+}
+export function CTFontGetDescent(font) {
+    return callFunction("CTFontGetDescent", { returns: "d" }, font);
+}
+export function CTFontGetGlyphCount(font) {
+    return callFunction("CTFontGetGlyphCount", { returns: "q" }, font);
+}
+export function CTFontGetGlyphsForCharacters(font, characters, glyphs, count) {
+    return callFunction("CTFontGetGlyphsForCharacters", { returns: "B", args: ["@", "@", "@", "q"] }, font, characters, glyphs, count);
+}
+export function CTFontGetGlyphWithName(font, glyphName) {
+    return callFunction("CTFontGetGlyphWithName", { returns: "S", args: ["@", "^"] }, font, glyphName);
+}
+export function CTFontGetLeading(font) {
+    return callFunction("CTFontGetLeading", { returns: "d" }, font);
+}
+export function CTFontGetLigatureCaretPositions(font, glyph, positions, maxPositions) {
+    return callFunction("CTFontGetLigatureCaretPositions", { returns: "q", args: ["@", "S", "@", "q"] }, font, glyph, positions, maxPositions);
+}
+export function CTFontGetMatrix(font) {
+    return callFunction("CTFontGetMatrix", { returns: "{CGAffineTransform}" }, font);
+}
+export function CTFontGetOpticalBoundsForGlyphs(font, glyphs, boundingRects, count, options) {
+    return callFunction("CTFontGetOpticalBoundsForGlyphs", { returns: "{CGRect}", args: ["@", "@", "@", "q", "L"] }, font, glyphs, boundingRects, count, options);
+}
+export function CTFontGetPlatformFont(font, attributes) {
+    return callFunction("CTFontGetPlatformFont", { returns: "I" }, font, attributes);
+}
+export function CTFontGetSize(font) {
+    return callFunction("CTFontGetSize", { returns: "d" }, font);
+}
+export function CTFontGetSlantAngle(font) {
+    return callFunction("CTFontGetSlantAngle", { returns: "d" }, font);
+}
+export function CTFontGetStringEncoding(font) {
+    return callFunction("CTFontGetStringEncoding", { returns: "I" }, font);
+}
+export function CTFontGetSymbolicTraits(font) {
+    return callFunction("CTFontGetSymbolicTraits", { returns: "@" }, font);
+}
+export function CTFontGetTypeID() {
+    return callFunction("CTFontGetTypeID", { returns: "L" });
+}
+export function CTFontGetTypographicBoundsForAdaptiveImageProvider(font, provider) {
+    return callFunction("CTFontGetTypographicBoundsForAdaptiveImageProvider", { returns: "{CGRect}" }, font, provider);
+}
+export function CTFontGetUnderlinePosition(font) {
+    return callFunction("CTFontGetUnderlinePosition", { returns: "d" }, font);
+}
+export function CTFontGetUnderlineThickness(font) {
+    return callFunction("CTFontGetUnderlineThickness", { returns: "d" }, font);
+}
+export function CTFontGetUnitsPerEm(font) {
+    return callFunction("CTFontGetUnitsPerEm", { returns: "I" }, font);
+}
+export function CTFontGetVerticalTranslationsForGlyphs(font, glyphs, translations, count) {
+    callFunction("CTFontGetVerticalTranslationsForGlyphs", { args: ["@", "@", "@", "q"] }, font, glyphs, translations, count);
+}
+export function CTFontGetXHeight(font) {
+    return callFunction("CTFontGetXHeight", { returns: "d" }, font);
+}
+export function CTFontHasTable(font, tag) {
+    return callFunction("CTFontHasTable", { returns: "B", args: ["@", "I"] }, font, tag);
+}
+export function CTFontManagerCompareFontFamilyNames(family1, family2, context) {
+    return callFunction("CTFontManagerCompareFontFamilyNames", { returns: "@", args: ["^v", "^v", "^v"] }, family1, family2, context);
+}
+export function CTFontManagerCopyAvailableFontFamilyNames() {
+    return callFunction("CTFontManagerCopyAvailableFontFamilyNames", { returns: "@" });
+}
+export function CTFontManagerCopyAvailableFontURLs() {
+    return callFunction("CTFontManagerCopyAvailableFontURLs", { returns: "@" });
+}
+export function CTFontManagerCopyAvailablePostScriptNames() {
+    return callFunction("CTFontManagerCopyAvailablePostScriptNames", { returns: "@" });
+}
+export function CTFontManagerCopyRegisteredFontDescriptors(scope, enabled) {
+    return callFunction("CTFontManagerCopyRegisteredFontDescriptors", { returns: "@", args: ["@", "B"] }, scope, enabled);
+}
+export function CTFontManagerCreateFontDescriptorFromData(data) {
+    return callFunction("CTFontManagerCreateFontDescriptorFromData", { returns: "@" }, data);
+}
+export function CTFontManagerCreateFontDescriptorsFromData(data) {
+    return callFunction("CTFontManagerCreateFontDescriptorsFromData", { returns: "@" }, data);
+}
+export function CTFontManagerCreateFontDescriptorsFromURL(fileURL) {
+    return callFunction("CTFontManagerCreateFontDescriptorsFromURL", { returns: "@" }, fileURL);
+}
+export function CTFontManagerCreateFontRequestRunLoopSource(sourceOrder, createMatchesCallback) {
+    return callFunction("CTFontManagerCreateFontRequestRunLoopSource", { returns: "@", args: ["q", "@"] }, sourceOrder, createMatchesCallback);
+}
+export function CTFontManagerEnableFontDescriptors(descriptors, enable) {
+    callFunction("CTFontManagerEnableFontDescriptors", { args: ["@", "B"] }, descriptors, enable);
+}
+export function CTFontManagerGetAutoActivationSetting(bundleIdentifier) {
+    return callFunction("CTFontManagerGetAutoActivationSetting", { returns: "@", args: ["^"] }, bundleIdentifier);
+}
+export function CTFontManagerGetScopeForURL(fontURL) {
+    return callFunction("CTFontManagerGetScopeForURL", { returns: "@" }, fontURL);
+}
+export function CTFontManagerIsSupportedFont(fontURL) {
+    return callFunction("CTFontManagerIsSupportedFont", { returns: "B" }, fontURL);
+}
+export function CTFontManagerRegisterFontDescriptors(fontDescriptors, scope, enabled, registrationHandler) {
+    callFunction("CTFontManagerRegisterFontDescriptors", { args: ["@", "@", "B", "@"] }, fontDescriptors, scope, enabled, registrationHandler);
+}
+export function CTFontManagerRegisterFontsForURL(fontURL, scope, error) {
+    return callFunction("CTFontManagerRegisterFontsForURL", { returns: "B" }, fontURL, scope, error);
+}
+export function CTFontManagerRegisterFontsForURLs(fontURLs, scope, errors) {
+    return callFunction("CTFontManagerRegisterFontsForURLs", { returns: "B" }, fontURLs, scope, errors);
+}
+export function CTFontManagerRegisterFontsWithAssetNames(fontAssetNames, bundle, scope, enabled, registrationHandler) {
+    callFunction("CTFontManagerRegisterFontsWithAssetNames", { args: ["@", "@", "@", "B", "@"] }, fontAssetNames, bundle, scope, enabled, registrationHandler);
+}
+export function CTFontManagerRegisterFontURLs(fontURLs, scope, enabled, registrationHandler) {
+    callFunction("CTFontManagerRegisterFontURLs", { args: ["@", "@", "B", "@"] }, fontURLs, scope, enabled, registrationHandler);
+}
+export function CTFontManagerRegisterGraphicsFont(font, error) {
+    return callFunction("CTFontManagerRegisterGraphicsFont", { returns: "B" }, font, error);
+}
+export function CTFontManagerRequestFonts(fontDescriptors, completionHandler) {
+    callFunction("CTFontManagerRequestFonts", undefined, fontDescriptors, completionHandler);
+}
+export function CTFontManagerSetAutoActivationSetting(bundleIdentifier, setting) {
+    callFunction("CTFontManagerSetAutoActivationSetting", { args: ["^", "@"] }, bundleIdentifier, setting);
+}
+export function CTFontManagerUnregisterFontDescriptors(fontDescriptors, scope, registrationHandler) {
+    callFunction("CTFontManagerUnregisterFontDescriptors", undefined, fontDescriptors, scope, registrationHandler);
+}
+export function CTFontManagerUnregisterFontsForURL(fontURL, scope, error) {
+    return callFunction("CTFontManagerUnregisterFontsForURL", { returns: "B" }, fontURL, scope, error);
+}
+export function CTFontManagerUnregisterFontsForURLs(fontURLs, scope, errors) {
+    return callFunction("CTFontManagerUnregisterFontsForURLs", { returns: "B" }, fontURLs, scope, errors);
+}
+export function CTFontManagerUnregisterFontURLs(fontURLs, scope, registrationHandler) {
+    callFunction("CTFontManagerUnregisterFontURLs", undefined, fontURLs, scope, registrationHandler);
+}
+export function CTFontManagerUnregisterGraphicsFont(font, error) {
+    return callFunction("CTFontManagerUnregisterGraphicsFont", { returns: "B" }, font, error);
+}
+export function CTFrameDraw(frame, context) {
+    callFunction("CTFrameDraw", { args: ["@", "^"] }, frame, context);
+}
+export function CTFrameGetFrameAttributes(frame) {
+    return callFunction("CTFrameGetFrameAttributes", { returns: "@" }, frame);
+}
+export function CTFrameGetLineOrigins(frame, range, origins) {
+    callFunction("CTFrameGetLineOrigins", undefined, frame, range, origins);
+}
+export function CTFrameGetLines(frame) {
+    return callFunction("CTFrameGetLines", { returns: "@" }, frame);
+}
+export function CTFrameGetPath(frame) {
+    return callFunction("CTFrameGetPath", { returns: "^" }, frame);
+}
+export function CTFrameGetStringRange(frame) {
+    return callFunction("CTFrameGetStringRange", { returns: "@" }, frame);
+}
+export function CTFrameGetTypeID() {
+    return callFunction("CTFrameGetTypeID", { returns: "L" });
+}
+export function CTFrameGetVisibleStringRange(frame) {
+    return callFunction("CTFrameGetVisibleStringRange", { returns: "@" }, frame);
+}
+export function CTFramesetterCreateFrame(framesetter, stringRange, path, frameAttributes) {
+    return callFunction("CTFramesetterCreateFrame", { returns: "@", args: ["@", "@", "^", "@"] }, framesetter, stringRange, path, frameAttributes);
+}
+export function CTFramesetterCreateWithAttributedString(attrString) {
+    return callFunction("CTFramesetterCreateWithAttributedString", { returns: "@" }, attrString);
+}
+export function CTFramesetterCreateWithTypesetter(typesetter) {
+    return callFunction("CTFramesetterCreateWithTypesetter", { returns: "@" }, typesetter);
+}
+export function CTFramesetterGetTypeID() {
+    return callFunction("CTFramesetterGetTypeID", { returns: "L" });
+}
+export function CTFramesetterGetTypesetter(framesetter) {
+    return callFunction("CTFramesetterGetTypesetter", { returns: "@" }, framesetter);
+}
+export function CTFramesetterSuggestFrameSizeWithConstraints(framesetter, stringRange, frameAttributes, constraints, fitRange) {
+    return callFunction("CTFramesetterSuggestFrameSizeWithConstraints", { returns: "{CGSize}", args: ["@", "@", "@", "{CGSize}", "@"] }, framesetter, stringRange, frameAttributes, constraints, fitRange);
+}
+export function CTGetCoreTextVersion() {
+    return callFunction("CTGetCoreTextVersion", { returns: "I" });
+}
+export function CTGlyphInfoCreateWithCharacterIdentifier(cid, collection, baseString) {
+    return callFunction("CTGlyphInfoCreateWithCharacterIdentifier", { returns: "@", args: ["S", "@", "^"] }, cid, collection, baseString);
+}
+export function CTGlyphInfoCreateWithGlyph(glyph, font, baseString) {
+    return callFunction("CTGlyphInfoCreateWithGlyph", { returns: "@", args: ["S", "@", "^"] }, glyph, font, baseString);
+}
+export function CTGlyphInfoCreateWithGlyphName(glyphName, font, baseString) {
+    return callFunction("CTGlyphInfoCreateWithGlyphName", { returns: "@", args: ["^", "@", "^"] }, glyphName, font, baseString);
+}
+export function CTGlyphInfoGetCharacterCollection(glyphInfo) {
+    return callFunction("CTGlyphInfoGetCharacterCollection", { returns: "@" }, glyphInfo);
+}
+export function CTGlyphInfoGetCharacterIdentifier(glyphInfo) {
+    return callFunction("CTGlyphInfoGetCharacterIdentifier", { returns: "S" }, glyphInfo);
+}
+export function CTGlyphInfoGetGlyph(glyphInfo) {
+    return callFunction("CTGlyphInfoGetGlyph", { returns: "S" }, glyphInfo);
+}
+export function CTGlyphInfoGetGlyphName(glyphInfo) {
+    return callFunction("CTGlyphInfoGetGlyphName", { returns: "^" }, glyphInfo);
+}
+export function CTGlyphInfoGetTypeID() {
+    return callFunction("CTGlyphInfoGetTypeID", { returns: "L" });
+}
+export function CTLineCreateJustifiedLine(line, justificationFactor, justificationWidth) {
+    return callFunction("CTLineCreateJustifiedLine", { returns: "@", args: ["@", "d", "d"] }, line, justificationFactor, justificationWidth);
+}
+export function CTLineCreateTruncatedLine(line, width, truncationType, truncationToken) {
+    return callFunction("CTLineCreateTruncatedLine", { returns: "@", args: ["@", "d", "@", "@"] }, line, width, truncationType, truncationToken);
+}
+export function CTLineCreateWithAttributedString(attrString) {
+    return callFunction("CTLineCreateWithAttributedString", { returns: "@" }, attrString);
+}
+export function CTLineDraw(line, context) {
+    callFunction("CTLineDraw", { args: ["@", "^"] }, line, context);
+}
+export function CTLineEnumerateCaretOffsets(line, block) {
+    callFunction("CTLineEnumerateCaretOffsets", undefined, line, block);
+}
+export function CTLineGetBoundsWithOptions(line, options) {
+    return callFunction("CTLineGetBoundsWithOptions", { returns: "{CGRect}" }, line, options);
+}
+export function CTLineGetGlyphCount(line) {
+    return callFunction("CTLineGetGlyphCount", { returns: "q" }, line);
+}
+export function CTLineGetGlyphRuns(line) {
+    return callFunction("CTLineGetGlyphRuns", { returns: "@" }, line);
+}
+export function CTLineGetImageBounds(line, context) {
+    return callFunction("CTLineGetImageBounds", { returns: "{CGRect}", args: ["@", "^"] }, line, context);
+}
+export function CTLineGetOffsetForStringIndex(line, charIndex, secondaryOffset) {
+    return callFunction("CTLineGetOffsetForStringIndex", { returns: "d", args: ["@", "q", "@"] }, line, charIndex, secondaryOffset);
+}
+export function CTLineGetPenOffsetForFlush(line, flushFactor, flushWidth) {
+    return callFunction("CTLineGetPenOffsetForFlush", { returns: "d", args: ["@", "d", "d"] }, line, flushFactor, flushWidth);
+}
+export function CTLineGetStringIndexForPosition(line, position) {
+    return callFunction("CTLineGetStringIndexForPosition", { returns: "q", args: ["@", "{CGPoint}"] }, line, position);
+}
+export function CTLineGetStringRange(line) {
+    return callFunction("CTLineGetStringRange", { returns: "@" }, line);
+}
+export function CTLineGetTrailingWhitespaceWidth(line) {
+    return callFunction("CTLineGetTrailingWhitespaceWidth", { returns: "d" }, line);
+}
+export function CTLineGetTypeID() {
+    return callFunction("CTLineGetTypeID", { returns: "L" });
+}
+export function CTLineGetTypographicBounds(line, ascent, descent, leading) {
+    return callFunction("CTLineGetTypographicBounds", { returns: "d" }, line, ascent, descent, leading);
+}
+export function CTParagraphStyleCreate(settings, settingCount) {
+    return callFunction("CTParagraphStyleCreate", { returns: "@", args: ["@", "Q"] }, settings, settingCount);
+}
+export function CTParagraphStyleCreateCopy(paragraphStyle) {
+    return callFunction("CTParagraphStyleCreateCopy", { returns: "@" }, paragraphStyle);
+}
+export function CTParagraphStyleGetTypeID() {
+    return callFunction("CTParagraphStyleGetTypeID", { returns: "L" });
+}
+export function CTParagraphStyleGetValueForSpecifier(paragraphStyle, spec, valueBufferSize, valueBuffer) {
+    return callFunction("CTParagraphStyleGetValueForSpecifier", { returns: "B", args: ["@", "@", "Q", "^v"] }, paragraphStyle, spec, valueBufferSize, valueBuffer);
+}
+export function CTRubyAnnotationCreate(alignment, overhang, sizeFactor, text) {
+    return callFunction("CTRubyAnnotationCreate", { returns: "@", args: ["@", "@", "d", "@"] }, alignment, overhang, sizeFactor, text);
+}
+export function CTRubyAnnotationCreateCopy(rubyAnnotation) {
+    return callFunction("CTRubyAnnotationCreateCopy", { returns: "@" }, rubyAnnotation);
+}
+export function CTRubyAnnotationCreateWithAttributes(alignment, overhang, position, string_, attributes) {
+    return callFunction("CTRubyAnnotationCreateWithAttributes", { returns: "@", args: ["@", "@", "@", "^", "@"] }, alignment, overhang, position, string_, attributes);
+}
+export function CTRubyAnnotationGetAlignment(rubyAnnotation) {
+    return callFunction("CTRubyAnnotationGetAlignment", { returns: "@" }, rubyAnnotation);
+}
+export function CTRubyAnnotationGetOverhang(rubyAnnotation) {
+    return callFunction("CTRubyAnnotationGetOverhang", { returns: "@" }, rubyAnnotation);
+}
+export function CTRubyAnnotationGetSizeFactor(rubyAnnotation) {
+    return callFunction("CTRubyAnnotationGetSizeFactor", { returns: "d" }, rubyAnnotation);
+}
+export function CTRubyAnnotationGetTextForPosition(rubyAnnotation, position) {
+    return callFunction("CTRubyAnnotationGetTextForPosition", { returns: "^" }, rubyAnnotation, position);
+}
+export function CTRubyAnnotationGetTypeID() {
+    return callFunction("CTRubyAnnotationGetTypeID", { returns: "L" });
+}
+export function CTRunDelegateCreate(callbacks, refCon) {
+    return callFunction("CTRunDelegateCreate", { returns: "@", args: ["@", "^v"] }, callbacks, refCon);
+}
+export function CTRunDelegateGetRefCon(runDelegate) {
+    return callFunction("CTRunDelegateGetRefCon", { returns: "^v" }, runDelegate);
+}
+export function CTRunDelegateGetTypeID() {
+    return callFunction("CTRunDelegateGetTypeID", { returns: "L" });
+}
+export function CTRunDraw(run, context, range) {
+    callFunction("CTRunDraw", { args: ["@", "^", "@"] }, run, context, range);
+}
+export function CTRunGetAdvances(run, range, buffer) {
+    callFunction("CTRunGetAdvances", undefined, run, range, buffer);
+}
+export function CTRunGetAdvancesPtr(run) {
+    return callFunction("CTRunGetAdvancesPtr", { returns: "@" }, run);
+}
+export function CTRunGetAttributes(run) {
+    return callFunction("CTRunGetAttributes", { returns: "@" }, run);
+}
+export function CTRunGetBaseAdvancesAndOrigins(runRef, range, advancesBuffer, originsBuffer) {
+    callFunction("CTRunGetBaseAdvancesAndOrigins", undefined, runRef, range, advancesBuffer, originsBuffer);
+}
+export function CTRunGetGlyphCount(run) {
+    return callFunction("CTRunGetGlyphCount", { returns: "q" }, run);
+}
+export function CTRunGetGlyphs(run, range, buffer) {
+    callFunction("CTRunGetGlyphs", undefined, run, range, buffer);
+}
+export function CTRunGetGlyphsPtr(run) {
+    return callFunction("CTRunGetGlyphsPtr", { returns: "@" }, run);
+}
+export function CTRunGetImageBounds(run, context, range) {
+    return callFunction("CTRunGetImageBounds", { returns: "{CGRect}", args: ["@", "^", "@"] }, run, context, range);
+}
+export function CTRunGetPositions(run, range, buffer) {
+    callFunction("CTRunGetPositions", undefined, run, range, buffer);
+}
+export function CTRunGetPositionsPtr(run) {
+    return callFunction("CTRunGetPositionsPtr", { returns: "@" }, run);
+}
+export function CTRunGetStatus(run) {
+    return callFunction("CTRunGetStatus", { returns: "@" }, run);
+}
+export function CTRunGetStringIndices(run, range, buffer) {
+    callFunction("CTRunGetStringIndices", undefined, run, range, buffer);
+}
+export function CTRunGetStringIndicesPtr(run) {
+    return callFunction("CTRunGetStringIndicesPtr", { returns: "@" }, run);
+}
+export function CTRunGetStringRange(run) {
+    return callFunction("CTRunGetStringRange", { returns: "@" }, run);
+}
+export function CTRunGetTextMatrix(run) {
+    return callFunction("CTRunGetTextMatrix", { returns: "{CGAffineTransform}" }, run);
+}
+export function CTRunGetTypeID() {
+    return callFunction("CTRunGetTypeID", { returns: "L" });
+}
+export function CTRunGetTypographicBounds(run, range, ascent, descent, leading) {
+    return callFunction("CTRunGetTypographicBounds", { returns: "d" }, run, range, ascent, descent, leading);
+}
+export function CTTextTabCreate(alignment, location, options) {
+    return callFunction("CTTextTabCreate", { returns: "@", args: ["@", "d", "@"] }, alignment, location, options);
+}
+export function CTTextTabGetAlignment(tab) {
+    return callFunction("CTTextTabGetAlignment", { returns: "@" }, tab);
+}
+export function CTTextTabGetLocation(tab) {
+    return callFunction("CTTextTabGetLocation", { returns: "d" }, tab);
+}
+export function CTTextTabGetOptions(tab) {
+    return callFunction("CTTextTabGetOptions", { returns: "@" }, tab);
+}
+export function CTTextTabGetTypeID() {
+    return callFunction("CTTextTabGetTypeID", { returns: "L" });
+}
+export function CTTypesetterCreateLine(typesetter, stringRange) {
+    return callFunction("CTTypesetterCreateLine", { returns: "@" }, typesetter, stringRange);
+}
+export function CTTypesetterCreateLineWithOffset(typesetter, stringRange, offset) {
+    return callFunction("CTTypesetterCreateLineWithOffset", { returns: "@", args: ["@", "@", "d"] }, typesetter, stringRange, offset);
+}
+export function CTTypesetterCreateWithAttributedString(string_) {
+    return callFunction("CTTypesetterCreateWithAttributedString", { returns: "@" }, string_);
+}
+export function CTTypesetterCreateWithAttributedStringAndOptions(string_, options) {
+    return callFunction("CTTypesetterCreateWithAttributedStringAndOptions", { returns: "@" }, string_, options);
+}
+export function CTTypesetterGetTypeID() {
+    return callFunction("CTTypesetterGetTypeID", { returns: "L" });
+}
+export function CTTypesetterSuggestClusterBreak(typesetter, startIndex, width) {
+    return callFunction("CTTypesetterSuggestClusterBreak", { returns: "q", args: ["@", "q", "d"] }, typesetter, startIndex, width);
+}
+export function CTTypesetterSuggestClusterBreakWithOffset(typesetter, startIndex, width, offset) {
+    return callFunction("CTTypesetterSuggestClusterBreakWithOffset", { returns: "q", args: ["@", "q", "d", "d"] }, typesetter, startIndex, width, offset);
+}
+export function CTTypesetterSuggestLineBreak(typesetter, startIndex, width) {
+    return callFunction("CTTypesetterSuggestLineBreak", { returns: "q", args: ["@", "q", "d"] }, typesetter, startIndex, width);
+}
+export function CTTypesetterSuggestLineBreakWithOffset(typesetter, startIndex, width, offset) {
+    return callFunction("CTTypesetterSuggestLineBreakWithOffset", { returns: "q", args: ["@", "q", "d", "d"] }, typesetter, startIndex, width, offset);
+}

package/dist/CoreText/index.d.ts

@@ -2,3 +2,4 @@ import { NobjcLibrary } from "objc-js";
 export declare const CoreText: NobjcLibrary;
 import type { _CTAdaptiveImageProviding } from "./CTAdaptiveImageProviding.js";
 export type { _CTAdaptiveImageProviding };
+export * from "./functions.js";

package/dist/CoreText/index.js

@@ -1,3 +1,4 @@
 // AUTO-GENERATED by objcjs-types generator — DO NOT EDIT
 import { NobjcLibrary } from "objc-js";
 export const CoreText = new NobjcLibrary("/System/Library/Frameworks/CoreText.framework/CoreText");
+export * from "./functions.js";

package/dist/CoreWLAN/functions.d.ts

@@ -0,0 +1,23 @@
+import type { NobjcObject } from "objc-js";
+import type { _NSData } from "../Foundation/NSData.js";
+import type { _NSSet } from "../Foundation/NSSet.js";
+import type { _NSString } from "../Foundation/NSString.js";
+import type { CWKeychainDomain } from "./CWKeychainDomain.js";
+export declare function CWKeychainCopyEAPIdentity(ssidData: NobjcObject, identity: NobjcObject | null): number;
+export declare function CWKeychainCopyEAPIdentityList(list: NobjcObject | null): number;
+export declare function CWKeychainCopyEAPUsernameAndPassword(ssidData: NobjcObject, username: NobjcObject | null, password: NobjcObject | null): number;
+export declare function CWKeychainCopyPassword(ssidData: NobjcObject, password: NobjcObject | null): number;
+export declare function CWKeychainCopyWiFiEAPIdentity(domain: CWKeychainDomain, ssid: _NSData, identity: NobjcObject | null): number;
+export declare function CWKeychainDeleteEAPUsernameAndPassword(ssidData: NobjcObject): number;
+export declare function CWKeychainDeletePassword(ssidData: NobjcObject): number;
+export declare function CWKeychainDeleteWiFiEAPUsernameAndPassword(domain: CWKeychainDomain, ssid: _NSData): number;
+export declare function CWKeychainDeleteWiFiPassword(domain: CWKeychainDomain, ssid: _NSData): number;
+export declare function CWKeychainFindWiFiEAPUsernameAndPassword(domain: CWKeychainDomain, ssid: _NSData, username: NobjcObject | null, password: NobjcObject | null): number;
+export declare function CWKeychainFindWiFiPassword(domain: CWKeychainDomain, ssid: _NSData, password: NobjcObject | null): number;
+export declare function CWKeychainSetEAPIdentity(ssidData: NobjcObject, identity: Uint8Array | null): number;
+export declare function CWKeychainSetEAPUsernameAndPassword(ssidData: NobjcObject, username: Uint8Array | null, password: Uint8Array | null): number;
+export declare function CWKeychainSetPassword(ssidData: NobjcObject, password: Uint8Array): number;
+export declare function CWKeychainSetWiFiEAPIdentity(domain: CWKeychainDomain, ssid: _NSData, identity: Uint8Array | null): number;
+export declare function CWKeychainSetWiFiEAPUsernameAndPassword(domain: CWKeychainDomain, ssid: _NSData, username: _NSString | null, password: _NSString | null): number;
+export declare function CWKeychainSetWiFiPassword(domain: CWKeychainDomain, ssid: _NSData, password: _NSString): number;
+export declare function CWMergeNetworks(networks: _NSSet): _NSSet;